Jak działają klasy, konstruktory i właściwości?

Question

Accepted Answer

**Klasy** są fundamentem modelu zorientowanego obiektowo w C# — schematami dla obiektów, z **konstruktorami** (inicjalizujących obiekty) i **właściwościami** (kontrolowany dostęp do danych). Składnia właściwości w C# jest charakterystyczną, eleganckią cechą.

## Klasa z konstruktorem i właściwościami

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

## Właściwości — enkapsulacja w elegancki sposób

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

**Właściwości** wyglądają jak pola, ale są w rzeczywistości metodami (`get`/`set`) — zapewniającymi enkapsulację (kontrolowany dostęp, walidacja, wartości obliczane) z czystą składnią. Auto-właściwości (`{ get; set; }`) obsługują częsty przypadek bez stereotypowego kodu.

## Inicjalizatory obiektów i nowoczesne funkcje

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

## Dlaczego to ważne

Klasy, konstruktory i właściwości są fundamentem zorientowanego obiektowo C# — praktycznie cały kod C# jest zorganizowany w klasy, więc ich zrozumienie jest niezbędne dla każdego rozwoju C#.

Wiedzenie, jak definiować klasy z konstruktorami (inicjalizującymi obiekty) i metodami, jest fundamentalne, ale **właściwości** C# są szczególnie ważną i charakterystyczną cechą wartą dobrego zrozumienia.

Właściwości zapewniają **enkapsulację** w elegancki sposób — wyglądają jak pola, ale są w rzeczywistości metodami `get`/`set`, umożliwiającymi kontrolowany dostęp, walidację, wartości obliczane i modyfikatory dostępu (takie jak `private set` lub `init`-only) przy zachowaniu czystej składni. **Auto-właściwości** (`{ get; set; }`) obsługują częsty przypadek bez żadnego stereotypowego kodu, czyniąc enkapsulację bezproblemową (w przeciwieństwie do języków, w których piszesz jawne metody getter/setter).

Zrozumienie właściwości (auto-właściwości, logika niestandardowa, obliczane/tylko do odczytu, `init`-only dla niezmienności), konstruktorów, inicjalizatorów obiektów i nowoczesnych wygód (konstruktory pierwotne) jest codzienną, podstawową wiedzą do pisania dobrze enkapsulowanych klas C#.

Ponieważ klasy to sposób, w jaki modelujesz dane i zachowanie w całych aplikacjach C#, a właściwości to idiomatyczny, elegancki sposób, w jaki C# obsługuje enkapsulację (charakterystyczną cechę języka używaną stale), opanowanie tych zagadnień — zwłaszcza systemu właściwości — jest materiałem fundamentalnym, obowiązkową wiedzą do efektywnego zorientowanego obiektowo rozwoju C#.