როგორ მუშაობს კლასები, კონსტრუქტორები და თვისებები?

Question

Accepted Answer

**კლასები** არის C#-ის ობიექტ-ორიენტირებული მოდელის საფუძველი — ობიექტების ლურჯი სახაზველი, **კონსტრუქტორებით** (ობიექტების ინიციალიზაცია) და **თვისებებით** (მონაცემების კონტროლირებული წვდომა). C#-ის თვისებების სინტაქსი განსაკუთრებული, ელეგანტური ფუნქცია.

## კლასი კონსტრუქტორით და თვისებებით

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

## თვისებები — ინკაფსულაცია ელეგანტურად

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

**თვისებები** ფიელდებივით გამოიყურებიან, მაგრამ სინამდვილეში მეთოდები არიან (`get`/`set`) — ინკაფსულაციის უზრუნველყოფა (კონტროლირებული წვდომა, ვალიდაცია, გამოთვლილი მნიშვნელობები) სუფთა სინტაქსით. ავტო-თვისებები (`{ get; set; }`) ჩვეულებრივ შემთხვევას მოაწყობს ბიტი ბიტი არ დაწერის პირობებში.

## ობიექტის ინიციალიზატორები და თანამედროვე ფუნქციები

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

## რატომ აქვს ამას მნიშვნელობა

კლასები, კონსტრუქტორები და თვისებები არის ობიექტ-ორიენტირებული C#-ის საფუძველი — ფაქტიურად ყველა C# კოდი ორგანიზირებულია კლასებში, ამიტომ მათი გაგება აუცილებელია ნებისმიერი C# განვითარებისთვის.

კლასების განსაზღვრაა კონსტრუქტორებით (ობიექტების ინიციალიზაცია) და მეთოდებით — ეს ფუნდამენტური, მაგრამ C#-ის **თვისებები** განსაკუთრებით მნიშვნელოვანი და განსხვავებული ფუნქცია, რომელიც ღირს კარგად გაგებისთვის.

თვისებები უზრუნველყოფენ **ინკაფსულაციას** ელეგანტურად — ისინი ფიელდებივით გამოიყურებიან, მაგრამ სინამდვილეში `get`/`set` მეთოდები არიან, რაც საშუალებას აძლევს კონტროლირებული წვდომა, ვალიდაცია, გამოთვლილი მნიშვნელობები და წვდომის მოდიფიკატორები (როგორც `private set` ან `init`-მხოლოდ) თუმცა სუფთა სინტაქსი. **ავტო-თვისებები** (`{ get; set; }`) ჩვეულებრივ შემთხვევას იკავებენ ნულოვანი ბიტი ბიტი არ დაწერის პირობებში, რაც ინკაფსულაციას უძნელს ხდის (განსხვავებით ენებისგან, სადაც თქვენ წერთ ექსპლიციტურ getter/setter მეთოდებს).

თვისებების გაგება (ავტო-თვისებები, მორგებული ლოგიკა, გამოთვლილი/მხოლოდ-წაკითხვა, `init`-მხოლოდ განუცვლელობისთვის), კონსტრუქტორები, ობიექტის ინიციალიზატორები და თანამედროვე მოხერხებულობები (პირველადი კონსტრუქტორები) არის ყოველდღე ცოდნა კარგად-ინკაფსულირებული C# კლასების დასაწერად.

ვინაიდან კლასები არის ის, თუ როგორ მოდელირებთ მონაცემებს და ქცევას C# აპლიკაციებში, და რადგან თვისებები არის იდიომატური, ელეგანტური გზა C#-ის ინკაფსულაციის მოცემისთვის (განსხვავებული ენის ფუნქცია, რომელიც მუდმივად გამოიყენება), ამ დაუფლება — განსაკუთრებით თვისებების სისტემა — არის საფუძველი, აუცილებელი მასალა ეფექტიანი ობიექტ-ორიენტირებული C# განვითარებისთვის.