Properties, indexers and the field keyword

A Name that is a public field accepts " Ravi Iyer" with its spaces and null as well, and every caller has to remember to clean it. Made a property, Name cleans and checks each value itself, while callers still write person.Name = … as if it were a field.

You will write the kinds of property C# offers, add a rule to a setter with C# 14’s field keyword, and give a type an indexer so that callers can write hall["C7"].

A property looks like a field and runs like a method

course.Room = "C-110"; looks like an assignment to a field, but Room is a property: the assignment calls its set accessor, and reading course.Room calls its get accessor. Most accessors need no code. { get; set; } is an auto-propertyauto-property: A property whose accessors have no body, such as { get; set; }. The compiler declares a hidden backing field and writes accessors that only read and store the value.: the compiler declares a hidden backing fieldbacking field: The private field that stores a property's value. For an auto-property the compiler declares it, and from C# 14 an accessor can name it with the field keyword. and writes both accessors for you. kinds.cs gives one class five kinds of property:

// Five kinds of property on one class, and what code outside the class may do with each.
var course = new Course("CS101", capacity: 60) { Title = "Programming in C#" };
course.Room = "B-204";
course.Enrol(45);
Console.WriteLine($"{course.Code} {course.Title}, room {course.Room}: {course.Enrolled} of {course.Capacity}");
Console.WriteLine($"seats left: {course.SeatsLeft}");

course.Room = "C-110";
course.Enrol(10);
Console.WriteLine($"moved to {course.Room}: {course.Enrolled} enrolled, {course.SeatsLeft} seats left");

class Course
{
    public Course(string code, int capacity)
    {
        Code = code;
        Capacity = capacity;
    }

    // Get-only: the constructor sets it once.
    public string Code { get; }

    public int Capacity { get; }

    // Init-only: an object initializer sets it, and nothing can change it afterwards.
    public required string Title { get; init; }

    // Read-write: any code may read it and assign it.
    public string? Room { get; set; }

    // Readable everywhere, assigned only by code inside the class.
    public int Enrolled { get; private set; }

    // Computed: nothing is stored; the value is worked out on every read.
    public int SeatsLeft => Capacity - Enrolled;

    public void Enrol(int students) => Enrolled += students;
}

CS101 Programming in C#, room B-204: 45 of 60
seats left: 15
moved to C-110: 55 enrolled, 5 seats left

What each declaration lets the code outside the class do:

SeatsLeft is a computed propertycomputed property: A property whose get accessor works out its value on every read, such as int SeatsLeft => Capacity - Enrolled. It stores nothing of its own.: it stores nothing, and it gave 15 after the first enrolment and 5 after the second, because each read subtracts Enrolled from Capacity again. A get-only property stops callers from storing another value in it, not from changing the object it returns: a List<string> behind { get; } still accepts Add, so expose IReadOnlyList<string> when callers should only read the items.

The field keyword puts a rule into one accessor

A name should be stored without the spaces people type around it, and never as null. Before C# 14 that took a private field declared by hand and both accessors written out. The field keyword of C# 14 names the compiler’s backing field inside an accessor, so you write the accessor that needs the rule and leave the other as get;:

// The C# 14 field keyword: a setter with a rule, and no backing field to declare.
var person = new Person("  Asha Rao ");
Console.WriteLine($"[{person.Name}]");

person.Name = "   Ravi Iyer";
Console.WriteLine($"[{person.Name}]");

try
{
    // null! silences the compiler's warning, as code that reads JSON or ignores warnings can.
    person.Name = null!;
}
catch (ArgumentNullException e)
{
    Console.WriteLine($"{e.GetType().Name}: {e.Message}");
}

Console.WriteLine($"still [{person.Name}]");

class Person
{
    // The constructor assigns the property, so its setter trims this value too.
    public Person(string name) => Name = name;

    public string Name
    {
        get;
        set => field = value?.Trim() ?? throw new ArgumentNullException(nameof(value));
    }
}

[Asha Rao]
[Ravi Iyer]
ArgumentNullException: Value cannot be null. (Parameter 'value')
still [Ravi Iyer]

The constructor assigns Name, so the setter trimmed " Asha Rao " too. When null arrived, the setter threw ArgumentNullException before storing anything, and Name kept Ravi Iyer. Step through the assignments:

field works in the get, set and init accessors of properties, not of indexers, and only from C# 14, the language version of the .NET 10 SDK. In a class that already has a member named field, the word inside an accessor now means the backing field; write this.field or @field to reach the member.

An indexer lets callers index your type like an array

A cinema hall of 5 rows of 10 seats is a collection, and callers expect hall[2, 6] or hall["C7"] rather than a method name. An indexerindexer: A member declared as this[...] that lets code use square brackets on an object, as in hall[2, 6] or hall["C7"]. It is a property whose accessors take parameters. is a property with parameters, declared as this[...]: its accessors receive the arguments written between the brackets. A type may have several indexers whose parameter lists differ:

// An indexer lets code use [] on your own type: here by row and seat number, or by a label such as "C7".
var hall = new SeatMap(rows: 5, seatsPerRow: 10);
hall[2, 6] = "Asha";
hall["D1"] = "Ravi";

Console.WriteLine($"C7: {hall["C7"] ?? "free"}");
Console.WriteLine($"[3, 0]: {hall[3, 0] ?? "free"}");
Console.WriteLine($"A1: {hall["A1"] ?? "free"}");
Console.WriteLine($"booked: {hall.Booked} of {hall.Rows * hall.SeatsPerRow}");

class SeatMap
{
    private readonly string?[,] _seats;

    public SeatMap(int rows, int seatsPerRow) => _seats = new string?[rows, seatsPerRow];

    public int Rows => _seats.GetLength(0);

    public int SeatsPerRow => _seats.GetLength(1);

    public int Booked { get; private set; }

    // By position, counting from 0 as arrays do.
    public string? this[int row, int seat]
    {
        get => _seats[row, seat];
        set
        {
            if (_seats[row, seat] is null && value is not null)
            {
                Booked++;
            }

            _seats[row, seat] = value;
        }
    }

    // By the label on the seat: a row letter from A and a seat number from 1.
    public string? this[string label]
    {
        get => this[label[0] - 'A', int.Parse(label[1..]) - 1];
        set => this[label[0] - 'A', int.Parse(label[1..]) - 1] = value;
    }
}

C7: Asha
[3, 0]: Ravi
A1: free
booked: 2 of 50

hall["D1"] and hall[3, 0] reached the same seat, and Booked counted 2 seats, because the string indexer only turns a label into two positions and then calls the int indexer:

Microsoft’s property design guidelines keep indexers for types that hold a logical collection of items, as a seat map does. Unlike other getters, an indexer is expected to throw when its arguments name no item.

The field keyword's traps, reproduced: initializers, nulls and old names Pro: opens with a Pro, Premium or Ultimate pass

Setters that clamp, refuse and notify, with every change counted Pro: opens with a Pro, Premium or Ultimate pass

Fields, properties and indexers across a library boundary Pro: opens with a Pro, Premium or Ultimate pass

Practise: a thermostat with a weekly schedule

thermostat.cs checks a Thermostat that you complete: its TargetCelsius keeps values between 10 and 32 degrees and refuses NaN, and an indexer, this[DayOfWeek day], holds a target for each day, 21 degrees to start with. The property and the indexer you start from only throw, so all 8 checks fail:

using System.Globalization;

// Practice: write the TargetCelsius property and the day indexer of Thermostat, then run this file until all eight
// checks pass. A target is kept between 10 and 32 degrees: a lower value becomes 10 and a higher one 32. NaN is not a
// temperature, so it is rejected. Every day of the week starts at 21 degrees.
(string Check, Func<string> Run, string Expected)[] checks =
[
    ("a new thermostat", () => Text(new Thermostat().TargetCelsius), "21"),
    ("set to 5", () => Text(new Thermostat { TargetCelsius = 5 }.TargetCelsius), "10"),
    ("set to 40", () => Text(new Thermostat { TargetCelsius = 40 }.TargetCelsius), "32"),
    ("set to 22.5", () => Text(new Thermostat { TargetCelsius = 22.5 }.TargetCelsius), "22.5"),
    ("set to NaN", () => Text(new Thermostat { TargetCelsius = double.NaN }.TargetCelsius), "throws ArgumentException"),
    ("Monday set to 35", () => Text(Monday(35)), "32"),
    ("Sunday, never set", () => Text(new Thermostat()[DayOfWeek.Sunday]), "21"),
    ("day number 7", () => Text(new Thermostat()[(DayOfWeek)7]), "throws ArgumentOutOfRangeException"),
];

int passed = 0;
foreach (var (check, run, expected) in checks)
{
    string got;
    try
    {
        got = run();
    }
    catch (Exception e)
    {
        got = $"throws {e.GetType().Name}";
    }

    bool ok = got == expected;
    if (ok)
    {
        passed++;
    }

    Console.WriteLine(ok ? $"{check}: ok" : $"{check}: FAIL, {got} instead of {expected}");
}

Console.WriteLine($"{passed} of {checks.Length} checks pass");
return passed == checks.Length ? 0 : 1;

static string Text(double celsius) => celsius.ToString(CultureInfo.InvariantCulture);

static double Monday(double celsius)
{
    var thermostat = new Thermostat();
    thermostat[DayOfWeek.Monday] = celsius;
    return thermostat[DayOfWeek.Monday];
}

class Thermostat
{
    public double TargetCelsius
    {
        get => throw new NotImplementedException();
        set => throw new NotImplementedException();
    }

    public double this[DayOfWeek day]
    {
        get => throw new NotImplementedException();
        set => throw new NotImplementedException();
    }
}

a new thermostat: FAIL, throws NotImplementedException instead of 21
set to 5: FAIL, throws NotImplementedException instead of 10
set to 40: FAIL, throws NotImplementedException instead of 32
set to 22.5: FAIL, throws NotImplementedException instead of 22.5
set to NaN: FAIL, throws NotImplementedException instead of throws ArgumentException
Monday set to 35: FAIL, throws NotImplementedException instead of 32
Sunday, never set: FAIL, throws NotImplementedException instead of 21
day number 7: FAIL, throws NotImplementedException instead of throws ArgumentOutOfRangeException
0 of 8 checks pass

Then try the questions on properties, the field keyword and indexers. They start with the idea you are weakest on, and every answer explains itself.

Interview questions

Fresher · Why do C# classes expose properties instead of public fields?

A property reads like a field where it is used, but its accessors are methods, so the class keeps control. A setter can check or normalise a value, a getter can compute one, and the two can have different access, such as a public get with a private set. A property can also gain such a rule later without any change to its callers’ source, while turning a public field into a property changes the member that compiled callers refer to. The Framework design guidelines therefore allow no public or protected instance fields at all, with constants and static readonly fields as the exceptions.

Key takeaways

• A property reads like a field and runs accessors: auto-properties, get-only, init-only, private-set and computed properties each let outside code do something different.
• The field keyword of C# 14 names the compiler’s backing field inside a property accessor, so one accessor can trim, check or refuse a value while the other stays get;.
• An indexer is a property with parameters, this[...]; a type may overload it, and one indexer can call another so that the rules live in one place.