How do properties work in C#? Explain auto-properties and backing fields, get/set/init accessors, required members (C# 11), the C# 14 field keyword, computed properties, and when to use a property, a field or a method.

1. Compiled form

public string Name { get; set; }

compiles to:

[CompilerGenerated] private string <Name>k__BackingField;
public string get_Name() => <Name>k__BackingField;
public void set_Name(string value) => <Name>k__BackingField = value;
// plus property metadata linking get_Name/set_Name

init accessors compile to a setter with a modreq(IsExternalInit) marker, which older compilers can't call — enforcing init-only semantics across languages. Because properties are methods, they can be virtual, abstract, part of interfaces, and have attributes on the property, accessors or backing field ([field: JsonIgnore]).

2. Inlining and performance

Trivial accessors are small enough that the JIT inlines them, producing the same machine code as a field access. Non-trivial accessors (validation, logging) may not inline. Virtual properties follow virtual-call rules (devirtualised when the type is sealed or known).

3. field keyword details (C# 14)

• field is only a keyword inside property accessors; a backing field is synthesised only when field is used (or the accessor is auto-implemented).
• You can mix: get; auto-implemented with a custom set => field = ....
• Attributes can target the synthesised field with [field: ...].
• Nullable analysis treats field like other fields; you may need initialisers or required for non-nullable reference types.
• Lazy patterns: get => field ??= ComputeExpensive(); (not thread-safe — use Lazy<T> when it matters).

4. required mechanics

The compiler emits RequiredMemberAttribute on the type and members, and marks constructors (other than those with [SetsRequiredMembers]) with CompilerFeatureRequiredAttribute/ObsoleteAttribute tricks so older compilers can't bypass the requirement. Reflection-based creators (DI, serialisers) don't automatically enforce required unless they're aware of it — System.Text.Json (.NET 7+) is.

5. Properties and frameworks

• Serialisation: System.Text.Json serialises public properties (fields only with IncludeFields); supports init, required, private setters with [JsonInclude].
• EF Core: maps properties (and can use backing fields — by convention it finds _name or <Name>k__BackingField; configurable with HasField and UsePropertyAccessMode). EF can bypass setters to avoid triggering validation when materialising.
• Data binding / MVVM: needs properties with change notification (INotifyPropertyChanged), which source generators now implement via partial properties (C# 13).
• Options pattern: binds configuration to properties with public setters (or init).

6. Indexers are parameterised properties

this[int index] compiles to get_Item/set_Item methods — same machinery with parameters.

Try it yourself

1. Decompile an auto-property and an init property and find the backing field and IsExternalInit marker.
2. Rewrite a property with an explicit backing field using the C# 14 field keyword.
3. Deserialise JSON missing a required property and observe the exception.
4. Find a property in your code that does I/O and convert it to a method.

public sealed class Product
{
    // C# 14: validation without a hand-written backing field
    public required string Sku
    {
        get;
        init => field = value is { Length: > 0 } ? value.ToUpperInvariant()
                                                 : throw new ArgumentException("SKU required");
    }

    public decimal Price
    {
        get;
        set => field = value >= 0 ? decimal.Round(value, 2)
                                  : throw new ArgumentOutOfRangeException(nameof(value));
    }

    private readonly List<string> _tags = [];
    public IReadOnlyList<string> Tags => _tags;               // read-only view
    public bool IsFree => Price == 0;                         // computed property
    public Guid Id { get; } = Guid.CreateVersion7();          // get-only, set at creation

    public void AddTag(string tag) => _tags.Add(tag.Trim().ToLowerInvariant());
}

// Options class with required + init (works with configuration binding and JSON)
public sealed class SmtpOptions
{
    public required string Host { get; init; }
    public int Port { get; init; } = 587;
    public required string FromAddress { get; init; }
}

// Method, not property: slow and has I/O
public sealed class Invoice(IInvoiceRepository repo)
{
    public Guid Id { get; init; }
    public Task<decimal> CalculateTotalAsync(CancellationToken ct) => repo.SumLinesAsync(Id, ct);
}