Cum funcționează clasele, constructorii și proprietățile?

Question

Accepted Answer

**Clasele** sunt fundamentul modelului orientat pe obiecte al C# — schițe pentru obiecte, cu **constructori** (inițializează obiecte) și **proprietăți** (acces controlat la date). Sintaxa proprietăților din C# este o caracteristică distinctivă și elegantă.

## O clasă cu constructor și proprietăți

```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ăți — încapsularea făcută 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
```

**Proprietățile** arată ca niște câmpuri, dar sunt de fapt metode (`get`/`set`) — oferind încapsulare (acces controlat, validare, valori calculate) cu sintaxă curată. Auto-proprietățile (`{ get; set; }`) gestionează cazul obișnuit fără cod repetitiv.

## Inițializatori de obiecte și caracteristici 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;
}
```

## De ce este important

Classele, constructorii și proprietățile sunt fundamentul C# orientat pe obiecte — aproape tot codul C# este organizat în clase, deci înțelegerea lor este esențială pentru orice dezvoltare C#.

Știind cum să definiți clase cu constructori (inițializând obiecte) și metode este fundamental, dar **proprietățile** din C# sunt o caracteristică deosebit de importantă și distinctivă care merită înțeleasă bine.

Proprietățile oferă **încapsulare** elegant — arată ca niște câmpuri, dar sunt de fapt metode `get`/`set`, permițând acces controlat, validare, valori calculate și modificatori de acces (cum ar fi `private set` sau numai `init`) păstrând în același timp sintaxa curată. **Auto-proprietățile** (`{ get; set; }`) gestionează cazul obișnuit fără zero cod repetitiv, făcând încapsularea fără efort (spre deosebire de limbajele în care scrieți metode getter/setter explicite).

Înțelegerea proprietăților (auto-proprietăți, logică personalizată, valori calculate/doar citire, numai `init` pentru imutabilitate), constructori, inițializatori de obiecte și comodități moderne (constructori primari) este cunoaștere de bază, de zi cu zi, pentru scrierea claselor C# bine încapsulate.

Deoarece clasele sunt cum modelați date și comportament în întreaga aplicație C#, și deoarece proprietățile sunt modul idiometic, elegant prin care C# gestionează încapsularea (o caracteristică limbajului distinctivă utilizată în mod constant), stăpânirea acestora — în special a sistemului de proprietăți — este material fundamental, care trebuie cunoscut pentru dezvoltare eficientă orientată pe obiecte în C#.