How do classes, constructors and properties work?

Question

Accepted Answer

**Classes** are the foundation of C#'s object-oriented model — blueprints for objects, with **constructors** (initialize objects) and **properties** (controlled access to data). C#'s property syntax is a distinctive, elegant feature.

## A class with constructor and properties

```csharp
public class Person
{
    // auto-implemented PROPERTY — encapsulated access with get/set
    public string Name { get; set; }
    public int Age { get; private set; }      // settable only within the class
    public string Email { get; init; }          // set only during initialization (C# 9)

// CONSTRUCTOR
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

public string Greet() => $"Hi, I'm {Name}";   // a method
}

var person = new Person("Ann", 30);    // create an instance
person.Name = "Bob";                     // set a property
Console.WriteLine(person.Greet());
```

## Properties — encapsulation made elegant

```csharp
// auto-property (the common case) — compiler generates the backing field
public string Name { get; set; }

// property with custom logic
private decimal _balance;
public decimal Balance
{
    get => _balance;
    set => _balance = value >= 0 ? value : throw new ArgumentException();   // validation
}

// expression-bodied / computed property
public string FullName => $"{First} {Last}";   // read-only, computed
```

**Properties** look like fields but are actually methods (`get`/`set`) — providing encapsulation (controlled access, validation, computed values) with clean syntax. Auto-properties (`{ get; set; }`) handle the common case with no boilerplate.

## Object initializers and modern features

```csharp
var p = new Person("Ann", 30) { Email = "a@x.com" };   // object initializer

// primary constructor (C# 12) — concise constructor parameters
public class Point(int x, int y)
{
    public int X { get; } = x;
}
```

## Why it matters

Classes, constructors, and properties are the foundation of object-oriented C# — virtually all C# code is organized into classes, so understanding them is essential for any C# development.

Knowing how to define classes with constructors (initializing objects) and methods is fundamental, but C#'s **properties** are a particularly important and distinctive feature worth understanding well.

Properties provide **encapsulation** elegantly — they look like fields but are actually `get`/`set` methods, allowing controlled access, validation, computed values, and access modifiers (like `private set` or `init`-only) while keeping clean syntax. **Auto-properties** (`{ get; set; }`) handle the common case with zero boilerplate, making encapsulation effortless (unlike languages where you write explicit getter/setter methods).

Understanding properties (auto-properties, custom logic, computed/read-only, `init`-only for immutability), constructors, object initializers, and modern conveniences (primary constructors) is core, everyday knowledge for writing well-encapsulated C# classes.

Since classes are how you model data and behavior throughout C# applications, and since properties are the idiomatic, elegant way C# handles encapsulation (a distinctive language feature used constantly), mastering these — especially the property system — is foundational, must-know material for effective object-oriented C# development.