Expression-Bodied Property

An expression-bodied property is a syntactic shorthand in C# that utilizes the lambda arrow operator (=>) to implement property accessors as a single expression, eliminating the need for explicit block bodies ({}) and return statements.

Under the hood, the compiler translates this syntax into standard block-bodied accessors. The expression on the right side of the => operator must evaluate to a type implicitly convertible to the property’s return type for a get accessor. For a set or init accessor, the expression must be a valid statement expression, which includes assignments, method invocations, object creations (new), and increment/decrement operations.

Read-Only Properties (Introduced in C# 6)

For a read-only property, the get keyword is omitted entirely. The lambda arrow operator is placed directly after the property identifier.

Traditional Block Body:

public string FullName
{
    get { return $"{FirstName} {LastName}"; }
}

Expression-Bodied Equivalent:

public string FullName => $"{FirstName} {LastName}";

Read/Write and Init Properties (Introduced in C# 7 and C# 9)

For properties requiring explicit accessors, the expression-body syntax is applied individually to each accessor within the property block. Support for expression-bodied set accessors was introduced in C# 7, while support for init accessors was introduced in C# 9.

Traditional Block Body:

private int _capacity;

public int Capacity
{
    get { return _capacity; }
    set { _capacity = value; }
}

Expression-Bodied Equivalent:

private int _capacity;

public int Capacity
{
    get => _capacity;
    set => _capacity = value;
}

public int InitialCapacity
{
    get => _capacity;
    init => _capacity = value;
}

Exception Throwing (Introduced in C# 7)

Expression-bodied accessors support throw expressions, allowing an accessor to immediately throw an exception without requiring a statement block.

private string _status;

public string Status
{
    get => _status;
    set => _status = value ?? throw new ArgumentNullException(nameof(value));
}

Syntax Constraints

• The body must consist of exactly one expression.
• It cannot contain block-level statements such as if, switch, for, or try/catch (though ternary operators ?: and switch expressions are permitted as they evaluate to a single value).
• For set and init accessors, the compiler does not enforce state mutation. The accessor can execute any valid statement expression, such as logging a value or raising an event.
• If a set or init accessor expression invokes a method that returns a value, the compiler simply discards the returned value, identical to the behavior within a block-bodied accessor.

Master C# with Deep Grasping Methodology!

Learn More