# Fields vs Properties

A property looks like a field from outside but runs code inside, so a class can let others read and set a value while it checks every change.

Apprentice · C# · OOP · Updated November 15, 2026

By Gregor Dzierzon

## After this lesson you can

- Expose a private field through a property with get and set

## Key takeaways

- A property is read and assigned like a field, but its `get` runs when it's read and its `set` when it's assigned.
- In a `set`, `value` is whatever was assigned: in `fridge.Temperature = 34;`, `value` is 34.
- A `set` can check the value first, so the object never holds one that makes no sense, such as a refrigerator at 95 degrees.
- The usual C# style is private camelCase fields, such as `temperature`, and public PascalCase properties, such as `Temperature`.

Private fields keep an object's data safe, but other code often needs to read it, and sometimes to change it. In the last lessons, `GetTemperature()` did the reading. Many languages write a pair of methods for each value: `GetTemperature()` and `SetTemperature(...)`. C# has a better tool: the **property**.

## A property is a field with gatekeepers

From outside, a property looks just like a public field: you read it and assign to it with no parentheses. Inside, it runs code: a `get` when it's read, and a `set` when it's assigned.

```csharp
Refrigerator fridge = new Refrigerator();
fridge.Temperature = 34;
Console.WriteLine($"Set to {fridge.Temperature} degrees");

public class Refrigerator
{
    private int temperature = 37;

    public int Temperature
    {
        get { return temperature; }
        set { temperature = value; }
    }
}
```

```text
Set to 34 degrees
```

- The **field** `temperature` (camelCase, private) holds the value. It's called the property's **backing field**.
- The **property** `Temperature` (PascalCase, public) is the way in.
- In `set`, the word `value` is whatever was assigned: in `fridge.Temperature = 34;`, `value` is 34.

## Why not a public field?

A public field lets anyone put anything in it. A property's `set` can check the value first, so the object can never be put into a state that makes no sense:

```csharp
Refrigerator fridge = new Refrigerator();
fridge.Temperature = 34;
fridge.Temperature = 95;
fridge.Temperature = -10;
Console.WriteLine($"Temperature: {fridge.Temperature}");

public class Refrigerator
{
    private int temperature = 37;

    public int Temperature
    {
        get { return temperature; }
        set
        {
            if (value >= 32 && value <= 45)
            {
                temperature = value;
            }
        }
    }
}
```

```text
Temperature: 34
```

95 and -10 aren't safe refrigerator temperatures, so the `set` ignores them, and the temperature stays at 34. Code that uses the class doesn't have to remember the rule; the class enforces it.

That's **encapsulation** at work: the data is private, and every change passes through code the class controls. If the rule changes later, it changes in one place, and every caller stays the same.

## Fields and properties, side by side

| | Field | Property |
|---|---|---|
| Holds a value | yes | through a backing field (or works one out) |
| Can run code when read or set | no | yes |
| Usual access | `private` | `public` |
| Naming | camelCase: `temperature` | PascalCase: `Temperature` |

The usual C# style: fields are private, and anything others need is a property.

## Do it: keep the oven at a temperature it can reach

The kitchen's oven can be set from 170 to 500 degrees. Anything else is a typo, such as 4250 for 425, and the oven should ignore it. Put that rule in a property, so no code can set the oven to a temperature it can't reach.

The class `Oven` has a private field, `temperature`, that starts at `350`. Its property `Temperature` is the way in:

- `value`: inside the `set`, the temperature the code assigned, an `int` (in `oven.Temperature = 425;`, `value` is `425`).

For example:

```csharp
Oven oven = new Oven();
oven.Temperature = 425;
oven.Temperature = 4250;
oven.Temperature = 100;
Console.WriteLine(oven.Temperature);
```

| Line | `Temperature` after it | Why |
|---|---|---|
| `new Oven()` | 350 | the field's starting value |
| `= 425` | 425 | from 170 to 500, so it's kept |
| `= 4250` | 425 | above 500, so it's ignored |
| `= 100` | 425 | below 170, so it's ignored |

So the last line prints `425`.

**Your job:** finish the property `Temperature` in the class `Oven`.

- Its `get` returns the field `temperature`.
- Its `set` stores `value` in `temperature` only when `value` is from 170 to 500. Both 170 and 500 are allowed.
- Any other value is ignored: the temperature stays what it was.

Practiced live on the lesson page: write the C# right there and check it.

## Check yourself

2 questions to try on the lesson page.

## So what

Properties let a class share its data the easy way, with plain reads and assignments, while keeping the final say over every change.

## Key terms

- [Property](https://www.ask-codey.com/glossary/property)
- [Getter](https://www.ask-codey.com/glossary/getter-c-sharp)
- [Setter](https://www.ask-codey.com/glossary/setter-c-sharp)
- [Backing Field](https://www.ask-codey.com/glossary/backing-field)

## Cheat sheets

- [Fields vs Properties](https://www.ask-codey.com/cheat-sheets/properties-in-csharp-fields-vs-properties-cheat-sheet)

Source: https://www.ask-codey.com/lessons/properties-in-csharp-fields-vs-properties
