C# Properties and Encapsulation: Read Clearly, Change Safely

What you will understand

• Distinguish fields from properties and accessor behavior.
• Read and assign an automatic property without assuming it validates input.
• Use value and a backing field to validate before writing.
• Choose public read access with a private setter or getter-only property.
• Compute derived availability from current stock.
• Explain init-only timing without confusing it with validation.
• Find constructor paths that bypass accessor rules.
• Test both permitted operations and rejected external assignments.

Property syntax looks like data access but invokes accessors

A field is storage. A property is a member with accessors that expose a value, control assignment or calculate a result. The caller reads label.Name and assigns label.Name = "Pen" without parentheses, but get and set define what those operations mean.

get returns the value requested by a read. set receives the new assignment value through the contextual keyword value. That value has the property’s declared type. A property can provide only a getter, or can make its setter less accessible than its getter when that matches the intended interface.

An automatic property such as public string Name { get; set; } uses compiler-generated backing storage. Its initializer supplies a chosen starting value. Do not mistake compact syntax for validation: an unrestricted automatic integer setter will happily accept a negative count unless you add a rule or remove that write path.

using System;

class Program
{
    static void Main()
    {
        ItemLabel label = new ItemLabel();
        label.Name = "Pen";
        Console.WriteLine(label.Name);
    }
}

class ItemLabel
{
    public string Name { get; set; } = "Unnamed";
}

Select Run code to compile and execute this program.

Pen

using System;

class Program
{
    static void Main()
    {
        StockEntry entry = new StockEntry();
        entry.Stock = -3;
        Console.WriteLine(entry.Stock);
    }
}

class StockEntry
{
    public int Stock { get; set; }
}

Select Run code to compile and execute this program.

-3

Use a backing field when a write needs explicit logic

The explicit Stock property separates the public member Stock from the private backing field stock. The getter returns the field. The setter receives value and can inspect it before storing anything. Using different capitalization helps show the two different members; the field and property are not interchangeable names for one declaration.

To require nonnegative values, reject a negative value before assigning stock. If you assign first and validate afterward, an exception could leave the object holding invalid state. The example starts at five, attempts minus one and then reads five again after handling the rejection.

A setter does not return a Boolean success result. Here invalid assignment throws an argument exception, caught in Main for explanation. For a domain action that commonly refuses a request, a method such as TrySell can communicate acceptance with a Boolean instead. Avoid a setter that silently ignores invalid input and leaves callers guessing whether assignment worked.

using System;

class Program
{
    static void Main()
    {
        StockEntry entry = new StockEntry();
        entry.Stock = 5;
        Console.WriteLine(entry.Stock);
    }
}

class StockEntry
{
    private int stock = 0;

    public int Stock
    {
        get
        {
            return stock;
        }
        set
        {
            stock = value;
        }
    }
}

Select Run code to compile and execute this program.

5

using System;

class Program
{
    static void Main()
    {
        StockEntry entry = new StockEntry();
        entry.Stock = 5;
        try
        {
            entry.Stock = -1;
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine("Rejected negative stock");
        }
        Console.WriteLine($"Still stored: {entry.Stock}");
    }
}

class StockEntry
{
    private int stock = 0;

    public int Stock
    {
        get
        {
            return stock;
        }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Stock cannot be negative.");
            }
            stock = value;
        }
    }
}

Select Run code to compile and execute this program.

Rejected negative stock
Still stored: 5

A public getter does not require a public setter

public int Stock { get; private set; } lets callers observe the count but restricts assignment to the declaring class. Its constructor and methods can still assign Stock. This preserves simple reading syntax while guiding callers toward meaningful operations for state changes.

A private setter is an accessibility boundary, not a validation routine. The constructor must reject invalid opening stock, and TrySell must reject nonpositive or excessive quantities. The private setter prevents unsupported external writes while the method bodies preserve the invariant internally.

Name uses a getter-only automatic property. Its value is assigned during construction, so the caller can identify the item without renaming it later. Getter-only and private-set properties differ: private set remains writable by the class’s ordinary methods, while this getter-only automatic property is assigned through its initializer or owning constructor.

using System;

class Program
{
    static void Main()
    {
        InventoryItem pen = new InventoryItem("Pen", 5);
        Console.WriteLine($"Before: {pen.Stock}");
        Console.WriteLine($"Accepted: {pen.TrySell(2)}");
        Console.WriteLine($"After: {pen.Stock}");
    }
}

class InventoryItem
{
    public string Name { get; }
    public int Stock { get; private set; }

    public bool InStock
    {
        get
        {
            return Stock > 0;
        }
    }

    public InventoryItem(string name, int stock)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("A name is required.", nameof(name));
        }
        if (stock < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(stock));
        }
        Name = name.Trim();
        Stock = stock;
    }

    public bool TrySell(int quantity)
    {
        if (quantity <= 0 || quantity > Stock)
        {
            return false;
        }
        Stock -= quantity;
        return true;
    }
}

Select Run code to compile and execute this program.

Before: 5
Accepted: True
After: 3

using System;

class Program
{
    static void Main()
    {
        InventoryItem pen = new InventoryItem("Pen", 5);
        pen.Stock = -1;
    }
}

class InventoryItem
{
    public string Name { get; }
    public int Stock { get; private set; }

    public bool InStock
    {
        get
        {
            return Stock > 0;
        }
    }

    public InventoryItem(string name, int stock)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("A name is required.", nameof(name));
        }
        if (stock < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(stock));
        }
        Name = name.Trim();
        Stock = stock;
    }

    public bool TrySell(int quantity)
    {
        if (quantity <= 0 || quantity > Stock)
        {
            return false;
        }
        Stock -= quantity;
        return true;
    }
}

Select Run code to compile and execute this program.

Compilation fails: the Stock set accessor is inaccessible.

using System;

class Program
{
    static void Main()
    {
        InventoryItem pen = new InventoryItem("Pen", 5);
        pen.Name = "Notebook";
    }
}

class InventoryItem
{
    public string Name { get; }
    public int Stock { get; private set; }

    public bool InStock
    {
        get
        {
            return Stock > 0;
        }
    }

    public InventoryItem(string name, int stock)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("A name is required.", nameof(name));
        }
        if (stock < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(stock));
        }
        Name = name.Trim();
        Stock = stock;
    }

    public bool TrySell(int quantity)
    {
        if (quantity <= 0 || quantity > Stock)
        {
            return false;
        }
        Stock -= quantity;
        return true;
    }
}

Select Run code to compile and execute this program.

Compilation fails: Name cannot be assigned because it is read-only.

Compute derived facts instead of duplicating state

InStock answers whether Stock is greater than zero. Storing both a count and an independent availability flag would create two values that could disagree. A computed getter derives the Boolean from the current count whenever a caller reads it.

The displayed getter body returns Stock > 0 directly and does not change the object. The shorter expression-bodied form public bool InStock => Stock > 0 expresses the same simple calculation. Neither form creates a separate stored availability flag in this example.

Keep ordinary property reads quick and predictable. Reading InStock should not sell an item, increment analytics, save a row or perform a network request. More substantial operations usually deserve a method name that makes their work visible. A computed getter can return a different value later because underlying state changed, not because the read itself changed state.

using System;

class Program
{
    static void Main()
    {
        InventoryItem pen = new InventoryItem("Pen", 2);
        Console.WriteLine(pen.InStock);
        pen.TrySell(2);
        Console.WriteLine(pen.InStock);
    }
}

class InventoryItem
{
    public string Name { get; }
    public int Stock { get; private set; }

    public bool InStock
    {
        get
        {
            return Stock > 0;
        }
    }

    public InventoryItem(string name, int stock)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("A name is required.", nameof(name));
        }
        if (stock < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(stock));
        }
        Name = name.Trim();
        Stock = stock;
    }

    public bool TrySell(int quantity)
    {
        if (quantity <= 0 || quantity > Stock)
        {
            return false;
        }
        Stock -= quantity;
        return true;
    }
}

Select Run code to compile and execute this program.

True
False

Init restricts assignment timing, not value meaning

An init accessor supports initialization-time assignment, including an object initializer, while rejecting ordinary assignments afterward. This is useful for options that callers choose as they construct an object. It is not the same policy as private set, which is available to later methods inside the declaring class.

LabelOptions demonstrates the timing rule without introducing more advanced construction features. The first program configures Prefix in its initializer. The second attempts to replace Prefix after that initializer and deliberately fails compilation. The private-set and getter-only examples demonstrate different permitted write contexts.

Neither init nor a getter-only declaration automatically validates a name, enforces a required input, or makes referenced child objects deeply immutable. C# also has required properties and newer field-backed syntax, but this lesson uses explicit backing fields and constructors so each rule remains visible. Choose a write policy from the model’s needs before choosing the shortest syntax.

using System;

class Program
{
    static void Main()
    {
        LabelOptions options = new LabelOptions { Prefix = "Stock" };
        Console.WriteLine(options.Prefix);
    }
}

class LabelOptions
{
    public string Prefix { get; init; } = "Item";
}

Select Run code to compile and execute this program.

Stock

using System;

class Program
{
    static void Main()
    {
        LabelOptions options = new LabelOptions { Prefix = "Stock" };
        options.Prefix = "Other";
    }
}

class LabelOptions
{
    public string Prefix { get; init; } = "Item";
}

Select Run code to compile and execute this program.

Compilation fails: the init-only property can only be assigned in allowed initialization contexts.

Encapsulation must cover every supported write path

Encapsulation combines an intentional interface with implementation rules that preserve valid state. A private backing field plus a validated setter is only safe when constructors and other methods also respect the same rule. Writing the field directly bypasses the property’s accessor code.

The guided repair shows a constructor storing a negative field even though the public setter rejects negative assignments. Routing construction through the setter reuses that check. Another valid design is a shared private validation helper used by both constructor and accessor, especially when diagnostic parameter names or different failure policies matter.

Our inventory lab uses a different sensible policy: callers cannot assign Stock at all after creation. They read it publicly and request a decrease through TrySell. The constructor validates starting state, the operation guards later changes, and InStock is computed. You do not need public setters for every stored fact just because properties support them.

Test values, refusal behavior and access boundaries

Test a validated setter with zero, a positive count and a negative assignment. Verify the stored value after rejection rather than checking only the exception message. For construction, test blank names and negative stock so invalid initial state does not bypass later property rules.

For the inventory operation, sell all remaining units and check that Stock becomes zero and InStock becomes false. A subsequent sale must be refused without changing either result. Repeat property reads to ensure reporting itself has no side effects.

Access is also observable behavior. The lab starter and solution intentionally print the same report, but the solution must reject external Stock assignment. Intentional compiler failures demonstrate private setters, getter-only assignment and init-only timing. These are separate from runtime input validation and from persistence or multi-user inventory coordination, which this in-memory exercise does not implement.

Guided repair: include initialization in the validation rule

Stock rejects negative assignments, but new StockEntry(-1) still creates an invalid count. The constructor writes the backing field directly. Make initialization respect the same property rule.

using System;

class Program
{
    static void Main()
    {
        StockEntry entry = new StockEntry(-1);
        Console.WriteLine(entry.Stock);
    }
}

class StockEntry
{
    private int stock = 0;

    public StockEntry(int initialStock)
    {
        stock = initialStock;
    }

    public int Stock
    {
        get
        {
            return stock;
        }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Stock cannot be negative.");
            }
            stock = value;
        }
    }
}

Select Run code to compile and execute this program.

-1

Repair checkpoints

1. Find stock = initialStock in the constructor.
2. Assign Stock = initialStock so the setter validates before storage.
3. Keep the negative-value check before stock = value in the setter.
4. Verify negative construction is rejected rather than printing -1.
5. Recognize that larger designs may share a private validator instead of duplicating rules.

using System;

class Program
{
    static void Main()
    {
        try
        {
            StockEntry entry = new StockEntry(-1);
            Console.WriteLine(entry.Stock);
        }
        catch (ArgumentOutOfRangeException)
        {
            Console.WriteLine("Rejected invalid construction");
        }
    }
}

class StockEntry
{
    private int stock = 0;

    public StockEntry(int initialStock)
    {
        Stock = initialStock;
    }

    public int Stock
    {
        get
        {
            return stock;
        }
        set
        {
            if (value < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(value), "Stock cannot be negative.");
            }
            stock = value;
        }
    }
}

Select Run code to compile and execute this program.

Rejected invalid construction

Independent lab: readable stock with guarded changes

Close the inventory item’s unrestricted property write path while preserving readable Name, Stock and computed InStock values. Keep changes flowing through valid construction and the guarded sale operation.

Acceptance checklist

• Keep Name as a getter-only automatic property assigned by the validated constructor.
• Change Stock to a public getter with a private setter.
• Keep InStock computed from Stock > 0 rather than a separately stored Boolean.
• Preserve name trimming and rejection of blank names or negative opening stock.
• Keep TrySell refusing nonpositive and excessive quantities before updating Stock.
• Preserve the reference output, including availability changing to False after selling the last units.
• Verify external Stock assignment fails compilation while permitted reads remain available.

using System;

class Program
{
    static void Main()
    {
        InventoryItem pen = new InventoryItem("  Pen  ", 2);
        Console.WriteLine($"{pen.Name}: {pen.Stock}, available: {pen.InStock}");
        Console.WriteLine($"Sale: {pen.TrySell(2)}");
        Console.WriteLine($"Oversell: {pen.TrySell(1)}");
        Console.WriteLine($"{pen.Name}: {pen.Stock}, available: {pen.InStock}");
    }
}

class InventoryItem
{
    public string Name { get; }
    public int Stock { get; set; }

    public bool InStock
    {
        get
        {
            return Stock > 0;
        }
    }

    public InventoryItem(string name, int stock)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("A name is required.", nameof(name));
        }
        if (stock < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(stock));
        }
        Name = name.Trim();
        Stock = stock;
    }

    public bool TrySell(int quantity)
    {
        if (quantity <= 0 || quantity > Stock)
        {
            return false;
        }
        Stock -= quantity;
        return true;
    }
}

Select Run code to compile and execute this program.

Pen: 2, available: True
Sale: True
Oversell: False
Pen: 0, available: False

using System;

class Program
{
    static void Main()
    {
        InventoryItem pen = new InventoryItem("  Pen  ", 2);
        Console.WriteLine($"{pen.Name}: {pen.Stock}, available: {pen.InStock}");
        Console.WriteLine($"Sale: {pen.TrySell(2)}");
        Console.WriteLine($"Oversell: {pen.TrySell(1)}");
        Console.WriteLine($"{pen.Name}: {pen.Stock}, available: {pen.InStock}");
    }
}

class InventoryItem
{
    public string Name { get; }
    public int Stock { get; private set; }

    public bool InStock
    {
        get
        {
            return Stock > 0;
        }
    }

    public InventoryItem(string name, int stock)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("A name is required.", nameof(name));
        }
        if (stock < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(stock));
        }
        Name = name.Trim();
        Stock = stock;
    }

    public bool TrySell(int quantity)
    {
        if (quantity <= 0 || quantity > Stock)
        {
            return false;
        }
        Stock -= quantity;
        return true;
    }
}

Select Run code to compile and execute this program.

Pen: 2, available: True
Sale: True
Oversell: False
Pen: 0, available: False

Changed-input checks

• An item with zero stock reports InStock False and refuses a sale of one.
• A sale of all remaining units succeeds and changes InStock to False.
• Zero, negative and excessive sale quantities leave Stock unchanged.
• An external pen.Stock = -1 must fail compilation.
• A rejected negative assignment in the separate validated-setter example preserves the previous value.
• Repeated Stock and InStock reads do not mutate the object.

Recap: read policy and write policy

Choose how values are read, where assignment is allowed and which operation preserves the invariant.

get

Return or compute the value requested by a read.

set

Receive an assignment through value and decide how to store it.

automatic property

Use compiler-generated backing storage without custom accessor bodies.

private backing field

Explicit internal storage behind a property.

get; private set;

Allow public reading while the declaring class owns later writes.

getter-only automatic property

Assign through its initializer or owning constructor, with no later ordinary setter.

computed getter

Derive an answer from current state without a duplicate stored flag.

init

Permit initialization-time assignment, not ordinary reassignment afterward.

Frequently asked questions

Next step and references

Properties expose accessor behavior through convenient member syntax. Validation must run before storage and cover initialization as well as later writes. Use computed facts and guarded operations to avoid inconsistent state.

Next is C# Inheritance and the Base Class. You will model a genuine is-a relationship, initialize the base part of an object and compare inheritance with composition.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

• Microsoft Learn: Properties, accessors and access control

Last updated: 27 October 2026.