Hogyan működnek az osztályok, konstruktorok és tulajdonságok?

Question

Accepted Answer

**Az osztályok** a C# objektumorientált modelljének alapja — objektumok tervrajzai, **konstruktorokkal** (objektumok inicializálása) és **tulajdonságokkal** (adatokhoz való irányított hozzáférés). A C# tulajdonság-szintaxisa egy jellegzetes, elegáns funkció.

## Osztály konstruktorral és tulajdonságokkal

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

## Tulajdonságok — az egységbe zárás eleganciája

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

A **tulajdonságok** mezőknek tűnnek, de valójában metódusok (`get`/`set`) — egységbe zárást biztosítanak (irányított hozzáférés, validáció, számított értékek) tiszta szintaxissal. Az automatikus tulajdonságok (`{ get; set; }`) a gyakori esetet kezеlik boilerplate nélkül.

## Objektum-inicializátorok és modern funkciók

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

## Miért fontos

Az osztályok, konstruktorok és tulajdonságok az objektumorientált C# alapja — gyakorlatilag az összes C# kód osztályokba szervezett, így megértésük elengedhetetlen bármilyen C# fejlesztéshez.

Annak ismerete, hogy miként definiáljunk konstruktorokkal rendelkező osztályokat (objektumok inicializálása) és metódusokat, alapvető, de a C# **tulajdonságai** egy különösen fontos és jellegzetes funkció, amelyet érdemes jól megérteni.

A tulajdonságok **elegánsan biztosítanak egységbe zárást** — mezőknek tűnnek, de valójában `get`/`set` metódusok, amelyek irányított hozzáférést, validációt, számított értékeket és hozzáférési módosítókat (mint `private set` vagy `init`-only) tesznek lehetővé, miközben tiszta szintaxist tartanak. Az **automatikus tulajdonságok** (`{ get; set; }`) a gyakori esetet nulla boilerplate-tal kezelik, így az egységbe zárás erőfeszítés nélkül megvalósítható (ellentétben azokkal a nyelvekkel, ahol explicit getter/setter metódusokat kell írni).

A tulajdonságok (automatikus tulajdonságok, egyéni logika, számított/írásvédett, `init`-only immutabilitáshoz), konstruktorok, objektum-inicializátorok és modern kényelmi funkciók (elsődleges konstruktorok) megértése napi szintű tudás az jól egységbe zárt C# osztályok írásához.

Mivel az osztályok az adatok és a viselkedés modellezésének módja a C# alkalmazásokon keresztül, és mivel a tulajdonságok az idiomatikus, elegáns módja a C# számára az egységbe zárás kezelésének (egy megkülönböztető nyelvfunkció, amely állandóan használatos), e tudás elsajátítása — különösen a tulajdonság-rendszer — alapvető, nélkülözhetetlen tudás az effektív objektumorientált C# fejlesztéshez.