Expression-bodied function members allow the use of lambda expressions as member bodies. For simple members, it can result in cleaner and more readable code.
Expression-bodied functions can be used for properties, indexers, methods, and operators.
public decimal TotalPrice => BasePrice + Taxes;
Is equivalent to:
public decimal TotalPrice
{
get
{
return BasePrice + Taxes;
}
}
When an expression-bodied function is used with a property, the property is implemented as a getter-only property.
public object this[string key] => dictionary[key];
Is equivalent to:
public object this[string key]
{
get
{
return dictionary[key];
}
}
static int Multiply(int a, int b) => a * b;
Is equivalent to:
static int Multiply(int a, int b)
{
return a * b;
}
Which can also be used with void
methods:
public void Dispose() => resource?.Dispose();
An override of ToString
could be added to the Pair<T>
class:
public override string ToString() => $"{First}, {Second}";
Additionally, this simplistic approach works with the override
keyword:
public class Foo
{
public int Bar { get; }
public string override ToString() => $"Bar: {Bar}";
}
This also can be used by operators:
public class Land
{
public double Area { get; set; }
public static Land operator +(Land first, Land second) =>
new Land { Area = first.Area + second.Area };
}
Expression-bodied function members have some limitations. They can't contain block statements and any other statements that contain blocks: if
, switch
, for
, foreach
, while
, do
, try
, etc.
Some if
statements can be replaced with ternary operators. Some for
and foreach
statements can be converted to LINQ queries, for example:
IEnumerable<string> Digits
{
get
{
for (int i = 0; i < 10; i++)
yield return i.ToString();
}
}
IEnumerable<string> Digits => Enumerable.Range(0, 10).Select(i => i.ToString());
In all other cases, the old syntax for function members can be used.
Expression-bodied function members can contain async
/await
, but it's often redundant:
async Task<int> Foo() => await Bar();
Can be replaced with:
Task<int> Foo() => Bar();