Come funzionano le classi, i costruttori e le proprietà?

Question

Accepted Answer

**Le classi** sono il fondamento del modello orientato agli oggetti di C# — progetti per oggetti, con **costruttori** (inizializzano gli oggetti) e **proprietà** (accesso controllato ai dati). La sintassi delle proprietà di C# è una caratteristica distintiva ed elegante.

## Una classe con costruttore e proprietà

```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());
```

## Proprietà — l'incapsulamento fatto elegante

```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
```

**Le proprietà** assomigliano a campi ma sono in realtà metodi (`get`/`set`) — forniscono incapsulamento (accesso controllato, validazione, valori calcolati) con sintassi pulita. Le proprietà automatiche (`{ get; set; }`) gestiscono il caso comune senza boilerplate.

## Inizializzatori di oggetti e caratteristiche moderne

```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;
}
```

## Perché è importante

Le classi, i costruttori e le proprietà sono il fondamento della programmazione orientata agli oggetti in C# — praticamente tutto il codice C# è organizzato in classi, quindi comprenderle è essenziale per qualsiasi sviluppo in C#.

Sapere come definire le classi con costruttori (inizializzazione degli oggetti) e metodi è fondamentale, ma le **proprietà** di C# sono una caratteristica particolarmente importante e distintiva che vale la pena comprendere bene.

Le proprietà forniscono **incapsulamento** in modo elegante — assomigliano a campi ma sono in realtà metodi `get`/`set`, consentendo accesso controllato, validazione, valori calcolati e modificatori di accesso (come `private set` o proprietà `init`-only) mantenendo una sintassi pulita. Le **proprietà automatiche** (`{ get; set; }`) gestiscono il caso comune senza alcun boilerplate, rendendo l'incapsulamento senza sforzo (a differenza di linguaggi in cui si scrivono metodi getter/setter espliciti).

Comprendere le proprietà (proprietà automatiche, logica personalizzata, proprietà calcolate/di sola lettura, `init`-only per l'immutabilità), i costruttori, gli inizializzatori di oggetti e le comodità moderne (costruttori primari) è conoscenza fondamentale, quotidiana per scrivere classi C# ben incapsulate.

Poiché le classi sono il modo in cui si modellano i dati e il comportamento in tutta l'applicazione C#, e poiché le proprietà sono il modo idiomatico ed elegante con cui C# gestisce l'incapsulamento (una caratteristica linguistica distintiva utilizzata costantemente), padroneggiare questi elementi — soprattutto il sistema delle proprietà — è materiale fondamentale e imprescindibile per uno sviluppo efficace in C# orientato agli oggetti.