რა მართვის ნაკადის კონსტრუქციებს სთავაზობს C#?

Question

Accepted Answer

C# უზრუნველყოფს სტანდარტული მართვის ნაკადის კონსტრუქციებს — პირობითი დებულებები (`if`, `switch`), მარყუჟები (`for`, `foreach`, `while`) და განშტოება (`break`, `continue`, `return`) — პლუს თანამედროვე გაუმჯობესებები როგორიცაა switch გამონათქვამები და ნიმუშის დამთხვევა, რომელიც კოდს უფრო მოკლე ხდის.

## პირობითი დებულებები

```csharp
if (score >= 90)
    grade = "A";
else if (score >= 80)
    grade = "B";
else
    grade = "F";

// ternary and null-coalescing
string status = age >= 18 ? "adult" : "minor";
string name = input ?? "default";        // ?? — use default if input is null
name ??= "fallback";                      // ??= assign if null
```

## switch დებულება და თანამედროვე switch გამონათქვამი

```csharp
// traditional switch
switch (day)
{
    case "Sat":
    case "Sun":
        type = "weekend";
        break;                            // break required (no fall-through)
    default:
        type = "weekday";
        break;
}

// switch EXPRESSION (C# 8) — concise, returns a value, with pattern matching
string type = day switch
{
    "Sat" or "Sun" => "weekend",
    _ => "weekday",                        // _ = default
};

// pattern matching in switch
string describe = obj switch
{
    int n when n > 0 => "positive int",
    string s => $"string of length {s.Length}",
    null => "null",
    _ => "other",
};
```

თანამედროვე **switch გამონათქვამი** მოკლეა (აბრუნებს მნიშვნელობას, არ არის `break`), და მხარს უჭერს მძლავრ **ნიმუშის დამთხვევას** (ტიპების, პირობების და სხვა დამთხვევა) — დიდი გაუმჯობესება ვერბოზური ტრადიციული switch-ის შედეგად.

## მარყუჟები

```csharp
for (int i = 0; i < 10; i++) { }

foreach (var item in collection) { }      // iterate any IEnumerable

while (condition) { }
do { } while (condition);                  // runs at least once
```

`foreach` (ნებისმიერი `IEnumerable`-ის გამეორება) არის იდიომატური მარყუჟი კოლექციებისთვის.

## განშტოება

```csharp
foreach (var item in items)
{
    if (item.Skip) continue;   // next iteration
    if (item.Stop) break;       // exit loop
}
return result;                  // exit method
```

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

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

და თუ ძირითადი ნაწილები სტანდარტულია, თანამედროვე C# გაუმჯობესებები ღირს ცოდნისთვის და გამოყენებისთვის: **switch გამონათქვამი** (C# 8+) არის მნიშვნელოვანი გაუმჯობესება ტრადიციული switch-ის შედეგად — მოკლე, მნიშვნელობის დაბრუნება, არა fall-through bugs (უვიცი `break`), და მხარდამჭერი მძლავრი **ნიმუშის დამთხვევა** (ტიპების, პირობების, მნიშვნელობებისა და სტრუქტურის დამთხვევა), რაც რთულ პირობით ლოგიკას ბევრად უფრო სუფთა ხდის, ვიდრე ჩადებული if-else ჯაჭვები.

**null-coalescing ოპერატორები** (`??`, `??=`) უზრუნველყოფენ სუფთა null დამუშავებას, ხოლო `foreach` არის იდიომატური გზა კოლექციების გამეორებისთვის.

ამ კონსტრუქციების ცოდნა და თანამედროვე, უფრო გამოხატული ფორმების ამჯობინება (switch გამონათქვამები ნიმუშის დამთხვევით ვერბოზული switch დებულებების ნაცვლად, null-coalescing ნაგულისხმელი მნიშვნელობებისთვის) არის ყოველდღიური ცოდნა სუფთა, იდიომატური C#-ის დასაწერად.

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