Catalog / Primitives / inline-method

Inline Method

Replaces every call of a method with the method's body, across the solution, and deletes the method. The reverse of Extract Method. A read-only property whose getter computes its value is inlined the same way at every read.

Target

The method, by symbol, such as M:Shop.Order.Total(System.Int32); overloads are told apart by their signature. Or the property, such as P:Shop.Order.Total.

Precondition

The method has a body, is not virtual, abstract, an override or an interface implementation, is not async or an iterator, and does not call itself.
Every reference to the method is a call. A method group, such as one converted to a delegate, has no call to inline.
A method returning a value has a single expression: an expression body, or a block holding only return expression;. Its calls are expressions whose value is used.
A method returning a value from several statements returns only at its end, and each call starts its statement: it is the whole statement, the initializer of a local declaring nothing else, the value assigned to a simple target, or the value returned.
A void method returns, if at all, only at its end. Each call is a statement of its own.
Every member and type the method names is accessible at each call.
Locals the inlined code declares, including locals for arguments, do not clash with names at the call site.
A call passes no ref, out or in argument and no params array, and a call on an object other than this names it with a simple expression when the method reaches this more than once.

For a property:

It is not an auto-property, which stores its value, and has no setter or init accessor, whose writes could not be inlined. Its getter, or its expression body, is a single expression: => expression, or get { return expression; }.
It is not virtual, abstract, an override or an interface implementation, and its getter does not read the property itself.
Every member and type the getter names is accessible at each read, and a read on an object other than this names it with a simple expression when the getter reaches this more than once.
A read through ?. is of a getter that starts from a member of the object, such as Department.Manager, and reaches this nowhere else, so that the rest of the getter can follow the ?..

Transformation

A value-returning method's expression replaces the call, parenthesised only where precedence requires. A void method's statements replace the call statement, in a new block when the call was the body of an if or loop without braces.
For a method returning a value from several statements, the statements before its return go before the call's statement and the returned expression replaces the call. A call whose value is discarded keeps the expression only when evaluating it has side effects, as a discard.
Each parameter is replaced by its argument, or by the parameter's default when the call leaves it out. An argument with side effects that the method reads more than once or not at all, or that the method assigns, is first evaluated into a local named after the parameter and declared with its type. When several arguments have side effects, each gets a local so they run in the order written.
Type parameters are replaced by the call's type arguments, inferred or written.
Members the method reaches through this are reached through the call's receiver. Types and static members are qualified as much as the call site needs, so a call in a file without the method's using directives still compiles.
Calls nested in another call's arguments are inlined too.
The method is deleted, with its comments.
A property's getter expression replaces each read, parenthesised only where precedence requires, with members it reaches through this reached through the read's receiver: order.Total becomes order.Subtotal + order.Tax in parentheses where needed, and person?.Manager becomes person?.Department.Manager. The property is deleted, with its comments.

Preserved

Behaviour at every call: arguments are evaluated once, in order, before the method's code that depends on them.
Comments inside the method travel with its statements, below any comment above the call.
Other overloads of the method.

Limitations

A value-returning method with more than one statement is refused where its call sits inside a larger expression, rather than introducing a local for the result.
Extension methods the method calls need their namespace imported at the call site; no using directive is added.
An argument without side effects is substituted even when it reads a field the method changes before reading the parameter.
Only whole-method inlining is covered; inlining a single call site and keeping the method is not.
A property is only inlined when it cannot be written; a property with a setter is refused rather than turned into a field.

Error codes

Code	Meaning
`recursive-method`	the method calls itself
`polymorphic-method`	the method is virtual, an override or an interface implementation
`unsupported-method`	the method is async or an iterator
`method-group-reference`	the method is used without being called
`inaccessible-member`	the method uses a member or type a call site cannot access
`multiple-statements`	a value-returning method's body is more than a single return, and a call does not start its statement
`early-return`	a void method returns before its last statement
`name-conflict`	a local the inlined code declares clashes with a name at the call site
`unsupported-call`	a void method's call is not a statement of its own
`writable-property`	the property has a setter or `init` accessor
`auto-property`	the property is an auto-property, with no getter body to inline
`conditional-access`	a read through `?.` is of a getter that does not start from one member of the object

Cases

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

#argument-with-side-effects

An argument with side effects that the method reads twice is evaluated once, into a local named after the parameter

success

Targetsymbol M:Sample.Show(System.Int32)

Sample.csmodified

1	1		using System;
2	2
3	3		public class Sample
4	4		{
5	5		private int _counter;
6	6
7	7		public void Run()
8	8		{
9		−	Show(Next());
10		−	}
11		−
12		−	private void Show(int value)
13		−	{
	9	+	int value = Next();
14	10		Console.WriteLine(value);
15	11		Console.WriteLine(value * 2);
16	12		}
17	13
18	14		private int Next() => ++_counter;
19	15		}

1		using System.Threading.Tasks;
2
3		public class Sample
4		{
5		public async Task Run()
6		{
7		await Wait();
8		}
9
10		private async Task Wait()
11		{
12		await Task.Delay(1);
13		}
14		}

1	1		namespace Shop
2	2		{
3	3		public class Checkout
4	4		{
5		−	public string Label(Order order) => "Buying " + order.Describe();
	5	+	public string Label(Order order) => "Buying " + $"{order.Name} x {order.Quantity}";
6	6		}
7	7		}

1	1		namespace Shop
2	2		{
3	3		public class Order
4	4		{
5	5		public string Name { get; set; } = "";
6	6
7	7		public int Quantity { get; set; }
8		−
9		−	public string Describe() => $"{Name} x {Quantity}";
10	8		}
11	9		}

1		using System;
2
3		public class Sample
4		{
5		public Action Later() => () => Greet();
6
7		private void Greet()
8		{
9		Console.WriteLine("Hello");
10		Console.WriteLine("World");
11		}
12		}

1		using System;
2
3		public class Sample
4		{
5		public void Run(string text)
6		{
7		Log(text);
8		Console.WriteLine("Done");
9		}
10
11		private void Log(string text)
12		{
13		if (text.Length == 0)
14		return;
15		Console.WriteLine(text);
16		}
17		}

1	1		public class Sample
2	2		{
3	3		public int Calc(int a, int b)
4	4		{
5		−	return Doubled(a) + Doubled(b + 1);
6		−	}
7		−
8		−	private int Doubled(int x)
9		−	{
10		−	return x * 2;
	5	+	return a * 2 + (b + 1) * 2;
11	6		}
12	7		}

1	1		using System.Collections.Generic;
2	2
3	3		public class Sample
4	4		{
5		−	public List<string> Names() => Pair("a", "b");
6		−
7		−	private static List<T> Pair<T>(T first, T second) => new List<T> { first, second };
	5	+	public List<string> Names() => new List<string> { "a", "b" };
8	6		}

1		namespace Shop
2		{
3		public class Checkout
4		{
5		public int Pay(Order order) => order.Total();
6		}
7		}

1		namespace Shop
2		{
3		public class Order
4		{
5		private int _price = 5;
6
7		public int Total() => _price * 2;
8		}
9		}

1		public class Sample
2		{
3		public int Total(int w, int h) => Area(w, h) + 1;
4
5		private int Area(int width, int height)
6		{
7		var area = width * height;
8		return area;
9		}
10		}

1	1		namespace Shop
2	2		{
3	3		public class Invoice
4	4		{
5		−	public decimal Due(Order order) => order.Total * 1.1m;
	5	+	public decimal Due(Order order) => (order.Subtotal + order.Tax) * 1.1m;
6	6		}
7	7		}

1		public class Animal
2		{
3		public virtual string Sound() => "...";
4
5		public string Speak() => Sound() + "!";
6		}
7
8		public class Dog : Animal
9		{
10		public override string Sound() => "Woof";
11		}

1	1		namespace Shop
2	2		{
3	3		public class Bulk : Pricing
4	4		{
5		−	public int Four(int amount) => Twice(Twice(amount));
	5	+	public int Four(int amount) => amount * 2 * 2;
6	6		}
7	7		}

1	1		namespace Shop
2	2		{
3	3		public class Pricing
4	4		{
5		−	protected int Twice(int amount) => amount * 2;
6	5		}
7	6		}

1		using System;
2
3		public class Sample
4		{
5		public int Calc(int a)
6		{
7		Func<int, int> twice = Doubled;
8		return twice(a) + Doubled(a);
9		}
10
11		private int Doubled(int x) => x * 2;
12		}

1		using System;
2
3		public class Sample
4		{
5		public void Run(int a)
6		{
7		var total = a + 1;
8		Print(total);
9		}
10
11		private void Print(int value)
12		{
13		var total = value * 2;
14		Console.WriteLine(total);
15		}
16		}

1	1		public class Sample
2	2		{
3		−	public string Describe(string? name) => OrDefault(name);
4		−
5		−	private static string OrDefault(string? value) => value ?? "anonymous";
	3	+	public string Describe(string? name) => name ?? "anonymous";
6	4		}

1	1		public class Sample
2	2		{
3		−	public string Show(int count, string name) => Format(count) + Format(name);
4		−
5		−	private string Format(int value) => "#" + value;
	3	+	public string Show(int count, string name) => "#" + count + Format(name);
6	4
7	5		private string Format(string value) => "'" + value + "'";
8	6		}

1		namespace Shop
2		{
3		public class Order
4		{
5		public int Id { get; }
6
7		public string Label() => "#" + Id;
8		}
9		}

1	1		namespace Company
2	2		{
3	3		public class Department
4	4		{
5	5		public Employee Manager { get; set; }
6	6		}
7	7
8	8		public class Employee
9	9		{
10	10		public string Name { get; set; }
11	11		}
12	12
13	13		public class Person
14	14		{
15	15		public Department Department { get; set; }
16		−
17		−	public Employee Manager => Department.Manager;
18	16		}
19	17		}

1	1		namespace Company
2	2		{
3	3		public class Report
4	4		{
5	5		public string Describe(Person person)
6	6		{
7		−	return person?.Manager.Name;
	7	+	return person?.Department.Manager.Name;
8	8		}
9	9		}
10	10		}

1		namespace Company
2		{
3		public class Person
4		{
5		public string First { get; set; }
6
7		public string Last { get; set; }
8
9		public string Initials => First.Substring(0, 1) + Last.Substring(0, 1);
10		}
11
12		public class Report
13		{
14		public string Describe(Person person) => person?.Initials;
15		}
16		}

Inline Method

Target

Precondition

Transformation

Preserved

Limitations

Error codes

Cases

#argument-with-side-effects

#async-rejected

#call-in-another-file

#call-not-statement-rejected

#early-return-rejected

#expression-in-expressions

#generic-method

#inaccessible-member-rejected

#inherited-nested-calls

#keeps-comments

#method-group-rejected

#multiple-statements-rejected

#name-conflict-rejected

#nullable-context

#overload

#property-auto-rejected

#property-conditional-access

#property-conditional-access-rejected

#property-expression-bodied

#property-getter-block

#property-inaccessible-member-rejected

#property-nullable

#property-virtual-rejected

#property-writable-rejected

#recursive-rejected

#statements-before-result

#types-need-qualifying

#virtual-rejected

#void-method

1	1		namespace Shop
2	2		{
3	3		public class Order
4	4		{
5	5		public decimal Subtotal { get; set; }
6	6
7	7		public decimal Tax { get; set; }
8	8
9		−	public decimal Total => Subtotal + Tax;
10		−
11		−	public string Describe() => "Total: " + Total;
	9	+	public string Describe() => "Total: " + (Subtotal + Tax);
12	10		}
13	11		}

1	1		using System.Collections.Generic;
2	2
3	3		namespace Shop
4	4		{
5	5		public class Cart
6	6		{
7	7		private readonly List<string> _items = new List<string>();
8	8
9		−	// Whether anything has been added.
10		−	public bool IsEmpty
11		−	{
12		−	get { return _items.Count == 0; }
13		−	}
14		−
15	9		public string Summary()
16	10		{
17		−	if (!IsEmpty)
	11	+	if (!(_items.Count == 0))
18	12		{
19	13		return _items.Count + " items";
20	14		}
21	15
22	16		return "empty";
23	17		}
24	18		}
25	19		}

1	1		namespace People
2	2		{
3	3		public class Person
4	4		{
5	5		public string Name { get; set; } = "";
6	6
7	7		public string? Nickname { get; set; }
8		−
9		−	public string Display => Nickname ?? Name;
10	8		}
11	9
12	10		public class Badge
13	11		{
14		−	public int Width(Person person) => person.Display.Length * 8;
	12	+	public int Width(Person person) => (person.Nickname ?? person.Name).Length * 8;
15	13		}
16	14		}

1		namespace Shop
2		{
3		public class Order
4		{
5		private int _quantity;
6
7		public int Quantity
8		{
9		get => _quantity;
10		set => _quantity = value;
11		}
12
13		public int Twice() => Quantity * 2;
14		}
15		}

1		public class Sample
2		{
3		public int Six() => Factorial(3);
4
5		private int Factorial(int n) => n <= 1 ? 1 : n * Factorial(n - 1);
6		}

1	1		namespace Sample
2	2		{
3	3		public class Counter
4	4		{
5	5		private int _count;
6	6
7	7		public int Skip()
8	8		{
9		−	var first = Next();
10		−	Next();
11		−	var third = Next();
	9	+	_count++;
	10	+	var first = _count;
	11	+	_count++;
	12	+	_count++;
	13	+	var third = _count;
12	14		return first + third;
13		−	}
14		−
15		−	private int Next()
16		−	{
17		−	_count++;
18		−	return _count;
19	15		}
20	16		}
21	17		}

1	1		namespace Shop
2	2		{
3	3		public class Printer
4	4		{
5		−	public string Print(string text) => Report.Line(text);
	5	+	public string Print(string text) => new System.Text.StringBuilder(text).Append('.').ToString();
6	6		}
7	7		}

1	1		using System.Text;
2	2
3	3		namespace Shop
4	4		{
5	5		public static class Report
6	6		{
7		−	public static string Line(string text) => new StringBuilder(text).Append('.').ToString();
8	7		}
9	8		}

1	1		using System;
2	2
3	3		public class Sample
4	4		{
5	5		public void Run(string user)
6	6		{
7		−	Greet(user);
	7	+	Console.WriteLine("Hello");
	8	+	Console.WriteLine(user);
8	9		Console.WriteLine("Done");
9	10		}
10		−
11		−	private void Greet(string name)
12		−	{
13		−	Console.WriteLine("Hello");
14		−	Console.WriteLine(name);
15		−	}
16	11		}