> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# 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:**
```csharp theme={"dark"}
public string FullName
{
get { return $"{FirstName} {LastName}"; }
}
```
**Expression-Bodied Equivalent:**
```csharp theme={"dark"}
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:**
```csharp theme={"dark"}
private int _capacity;
public int Capacity
{
get { return _capacity; }
set { _capacity = value; }
}
```
**Expression-Bodied Equivalent:**
```csharp theme={"dark"}
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.
```csharp theme={"dark"}
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.
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
