Catalog / Primitives / replace-constructor-with-factory-method

Replace Constructor with Factory Method

Adds a static factory method that calls a constructor, narrows the constructor, and makes every creation in the solution call the factory.

Arguments

Argument	Meaning
`name`	the factory method's name; `Create` when omitted
`accessibility`	the constructor's new accessibility; `private` when omitted

The target is the constructor, by symbol, which tells overloads apart.

Precondition

The constructor belongs to a class that is not abstract or static.
The accessibility is one of the six C# accessibilities.
The type has no member with the factory's name, other than methods whose parameters differ.
No creation sets members with an object or collection initializer.
Everything else that calls the constructor directly, such as a derived class's base(...) or a new() constraint, can still reach it with the new accessibility.

Transformation

The factory, static, with the constructor's former accessibility, its parameters (types, modifiers and defaults) and its type as the return type, goes after the constructor and returns new Type(arguments).
The constructor's accessibility becomes the requested one; its documentation and other modifiers stay.
Every new Type(...) and target-typed new(...) calling the constructor, outside the factory, becomes Type.Name(...) with the same arguments, including their names, and the same trivia. Constructed generic types keep their type arguments, as in Box<int>.Create(5).
Calls of other overloads and this(...) or base(...) calls are left alone.

Preserved

Every creation still runs the same constructor with the same arguments.

Limitations

Creations through reflection, Activator.CreateInstance or a new() generic constraint are not rewritten; the last is refused by the compile check when the constructor becomes inaccessible.

Error codes

Code	Meaning
`invalid-accessibility`	the accessibility argument is not a C# accessibility
`abstract-type`	the constructor belongs to an abstract or static class
`name-conflict`	the type already has a member with the factory's name and parameters
`object-initializer`	a creation uses an object or collection initializer
`constructor-still-needed`	a derived class or constraint needs the constructor at its old accessibility

Cases

Diffs show each file from before to after. /*[*/ … /*]*/ marks a selection and /*^*/ a caret; the runner removes them before the refactoring runs.

#abstract-type-rejected

Refuses a constructor of an abstract class, which a factory method cannot instantiate

refusal

Targetsymbol M:Shop.Adjustment.#ctor(System.Decimal)

Refusesabstract-type; every file is left unchanged

Adjustment.csinput

View fixture on GitHub

#calls-in-another-file

Adds a static Create method after the constructor, makes the constructor private and calls Create wherever the constructor was called

success

Targetsymbol M:Shop.Order.#ctor(System.String,System.Int32)

Checkout.csmodified

Order.csmodified

View fixture on GitHub

#derived-class-rejected

Refuses to make the constructor private while a derived class calls it

refusal

Targetsymbol M:Shop.Notice.#ctor(System.String)

Refusesconstructor-still-needed mentioning “Alert.cs”; every file is left unchanged

Alert.csinput

Notice.csinput

View fixture on GitHub

#generic-type

Calls the factory on the constructed type, whether its type argument is concrete or a type parameter

success

Targetsymbol M:Shop.Box`1.#ctor(`0)

Box.csmodified

View fixture on GitHub

#invalid-accessibility-rejected

Refuses an accessibility that is not a C# accessibility

refusal

Targetsymbol M:Shop.Order.#ctor(System.String)

Arguments

`accessibility`	`"hidden"`

Refusesinvalid-accessibility; every file is left unchanged

Order.csinput

View fixture on GitHub

#name-conflict-rejected

Refuses when the type already has a method with the factory's name and parameters

refusal

Targetsymbol M:Shop.Order.#ctor(System.String)

Refusesname-conflict; every file is left unchanged

Order.csinput

View fixture on GitHub

#object-initializer-rejected

Refuses when a call sets properties with an object initializer, which a method call cannot carry

refusal

Targetsymbol M:Shop.Order.#ctor(System.String)

Refusesobject-initializer; every file is left unchanged

Order.csinput

View fixture on GitHub

#one-overload

Replaces only the calls of the chosen overload; the other constructor, which chains to it, is untouched

success

Targetsymbol M:Shop.Money.#ctor(System.Decimal,System.String)

Arguments

`name`	`"Of"`

Money.csmodified

View fixture on GitHub

#protected-for-derived-class

Makes the constructor protected so a derived class can still call it, keeping its documentation and default value

success

Targetsymbol M:Shop.Notice.#ctor(System.String,System.Int32)

Arguments

`accessibility`	`"protected"`

Board.csmodified

Notice.csmodified

View fixture on GitHub

#target-typed-new

Replaces target-typed new expressions, naming the type they create

success

Targetsymbol M:Shop.Sku.#ctor(System.String)

Arguments

`name`	`"Parse"`

Sku.csmodified

View fixture on GitHub

1		namespace Shop;
2
3		public abstract class Adjustment
4		{
5		protected Adjustment(decimal amount)
6		{
7		Amount = amount;
8		}
9
10		public decimal Amount { get; }
11		}

1	1		namespace Shop;
2	2
3	3		public class Checkout
4	4		{
5		−	public Order Single(string customer) => new Order(customer, 1);
	5	+	public Order Single(string customer) => Order.Create(customer, 1);
6	6
7	7		public Order Bulk(string customer)
8	8		{
9	9		// Bulk orders are always a dozen.
10		−	return new Order(quantity: 12, customer: customer);
	10	+	return Order.Create(quantity: 12, customer: customer);
11	11		}
12	12		}

1	1		namespace Shop;
2	2
3	3		public class Order
4	4		{
5		−	public Order(string customer, int quantity)
	5	+	private Order(string customer, int quantity)
6	6		{
7	7		Customer = customer;
8	8		Quantity = quantity;
9	9		}
10	10
	11	+	public static Order Create(string customer, int quantity) => new Order(customer, quantity);
	12	+
11	13		public string Customer { get; }
12	14
13	15		public int Quantity { get; }
14	16		}

1		namespace Shop;
2
3		public class Notice
4		{
5		public Notice(string text)
6		{
7		Text = text;
8		}
9
10		public string Text { get; }
11		}

1	1		namespace Shop;
2	2
3	3		public class Box<T>
4	4		{
5		−	public Box(T value)
	5	+	private Box(T value)
6	6		{
7	7		Value = value;
8	8		}
	9	+
	10	+	public static Box<T> Create(T value) => new Box<T>(value);
9	11
10	12		public T Value { get; }
11	13		}
12	14
13	15		public static class Boxes
14	16		{
15		−	public static Box<int> Five() => new Box<int>(5);
	17	+	public static Box<int> Five() => Box<int>.Create(5);
16	18
17		−	public static Box<TItem> Of<TItem>(TItem item) => new Box<TItem>(item);
	19	+	public static Box<TItem> Of<TItem>(TItem item) => Box<TItem>.Create(item);
18	20		}

1		namespace Shop;
2
3		public class Alert : Notice
4		{
5		public Alert(string text) : base(text.ToUpperInvariant())
6		{
7		}
8		}

1		namespace Shop;
2
3		public class Order
4		{
5		public Order(string customer)
6		{
7		Customer = customer;
8		}
9
10		public string Customer { get; }
11		}

1	1		namespace Shop;
2	2
3	3		public class Money
4	4		{
5	5		public Money(decimal amount) : this(amount, "EUR")
6	6		{
7	7		}
8	8
9		−	public Money(decimal amount, string currency)
	9	+	private Money(decimal amount, string currency)
10	10		{
11	11		Amount = amount;
12	12		Currency = currency;
13	13		}
	14	+
	15	+	public static Money Of(decimal amount, string currency) => new Money(amount, currency);
14	16
15	17		public decimal Amount { get; }
16	18
17	19		public string Currency { get; }
18	20
19	21		public static Money Zero() => new Money(0m);
20	22
21		−	public static Money Dollars(decimal amount) => new Money(amount, "USD");
	23	+	public static Money Dollars(decimal amount) => Money.Of(amount, "USD");
22	24		}

1	1		namespace Shop;
2	2
3	3		public static class Board
4	4		{
5		−	public static Notice Welcome() => new Notice("Welcome");
	5	+	public static Notice Welcome() => Notice.Create("Welcome");
6	6		}

1	1		namespace Shop;
2	2
3	3		public class Notice
4	4		{
5	5		/// <summary>Creates a notice.</summary>
6		−	public Notice(string text, int priority = 0)
	6	+	protected Notice(string text, int priority = 0)
7	7		{
8	8		Text = text;
9	9		Priority = priority;
10	10		}
	11	+
	12	+	public static Notice Create(string text, int priority = 0) => new Notice(text, priority);
11	13
12	14		public string Text { get; }
13	15
14	16		public int Priority { get; }
15	17		}
16	18
17	19		public class Alert : Notice
18	20		{
19	21		public Alert(string text) : base(text, 9)
20	22		{
21	23		}
22	24		}

1	1		using System.Collections.Generic;
2	2
3	3		namespace Shop;
4	4
5	5		public sealed class Sku
6	6		{
7		−	public Sku(string code)
	7	+	private Sku(string code)
8	8		{
9	9		Code = code;
10	10		}
11	11
	12	+	public static Sku Parse(string code) => new Sku(code);
	13	+
12	14		public string Code { get; }
13	15
14		−	public static List<Sku> Defaults() => new() { new("A1"), new("B2") };
	16	+	public static List<Sku> Defaults() => new() { Sku.Parse("A1"), Sku.Parse("B2") };
15	17		}