Jak fungují třídy, konstruktory a vlastnosti?

Question

Accepted Answer

**Třídy** jsou základem objektově orientovaného modelu v C# — vzory pro objekty, s **konstruktory** (inicializují objekty) a **vlastnostmi** (řízený přístup k datům). Syntaxe vlastností v C# je výrazná, elegantní funkce.

## Třída s konstruktorem a vlastnostmi

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

## Vlastnosti — elegantně provedená enkapsulace

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

**Vlastnosti** vypadají jako pole, ale ve skutečnosti jsou metody (`get`/`set`) — poskytují enkapsulaci (řízený přístup, validaci, vypočítané hodnoty) s čistou syntaxí. Automatické vlastnosti (`{ get; set; }`) řeší běžný případ bez zbytečného kódu.

## Inicializátory objektů a moderní funkce

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

## Proč to je důležité

Třídy, konstruktory a vlastnosti jsou základem objektově orientovaného C# — prakticky všechen kód v C# je organizován do tříd, takže jejich pochopení je pro jakýkoliv vývoj v C# nezbytné.

Vědět, jak definovat třídy s konstruktory (inicializující objekty) a metodami, je zásadní, ale **vlastnosti** v C# jsou obzvláště důležitá a výrazná funkce, kterou stojí za to dobře porozumět.

Vlastnosti poskytují **enkapsulaci** elegantně — vypadají jako pole, ale jsou to ve skutečnosti metody `get`/`set`, které umožňují řízený přístup, validaci, vypočítané hodnoty a modifikátory přístupu (jako `private set` nebo `init`-only) při zachování čisté syntaxe. **Automatické vlastnosti** (`{ get; set; }`) řeší běžný případ bez jakéhokoliv zbytečného kódu, čímž je enkapsulace bez námahy (na rozdíl od jazyků, kde píšete explicitní getter/setter metody).

Pochopení vlastností (automatické vlastnosti, vlastní logika, vypočítané/jen pro čtení, `init`-only pro neměnnost), konstruktory, inicializátory objektů a moderní vymoženosti (primární konstruktory) je jádrem, každodenní znalostí pro psaní dobře zapouzdřených tříd v C#.

Požadavky jsou způsobem, jak modelujete data a chování v celých aplikacích v C#, a jelikož vlastnosti jsou idiomatický, elegantní způsob, jak C# řeší enkapsulaci (výrazná funkce jazyka používaná neustále), zvládnutí těchto — zejména systému vlastností — je základní, nezbytná znalost pro efektivní objektově orientovaný vývoj v C#.