Cad iad na tógail sreabhadh-rialúcháin a chuireann C# ar fáil?

Question

Accepted Answer

Cuireann C# na tógail sreabhadh-rialúcháin caighdeánacha ar fáil — coinníollacha (`if`, `switch`), lúba (`for`, `foreach`, `while`), agus briseadh (`break`, `continue`, `return`) — móide feabhsuithe nua-aimseartha cosúil le switch expressions agus pattern matching a dhéanann an cód níos gearr.

## Coinníollacha

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

## Ráiteas switch agus switch expression nua-aimseartha

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

Tá an **switch expression** nua-aimseartha gearr (filleann sé luach, gan `break`), agus tacaíonn sé do **pattern matching** cumhachtach (meaitseáil chineálacha, coinníollacha, agus níos mó) — feabhas mór ar an switch traidisiúnta fada.

## Lúba

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

Tá `foreach` (ag atriall ar aon `IEnumerable`) ina bhealach idiomaiteach a lúb ar bhaileanna.

## Briseadh

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

## Cén fáth a bhíonn sé ábhairthach

Is é sreabhadh-rialúcháin an meicníoim bhunúsach chun loighic a chur in iúl i ngach clár, agus dá bhrí sin is fios bhunúsach a bhfuil gá do gach lá a bheith agat ar thógail C#.

Cé go bhfuil na bunúsacha caighdeánach, tá feabhsuithe nua-aimseartha C# fiú a bheith ar eolas agat agus iad a úsáid: tá an **switch expression** (C# 8+) ina fheabhas suntasach ar an switch traidisiúnta — gearr, ag filleadh luach, gan fabhtanna tuisle-trí (gan `break` dearmadta), agus tacaíochta do **pattern matching** (meaitseáil ar chineálacha, coinníollacha, luachanna, agus struchtúr), a dhéanann loighic choinníollach chasta i bhfad níos geal ná slabhraí fada if-else.

Tuigeann na **null-coalescing operators** (`??`, `??=`) láimhdeáil neamh-dhóchasach geal, agus is é `foreach` an bealach idiomaiteach chun baileanna a atriall.

Bheith ar eolas agat ar na tógail sin agus an bhreithiúnas a thabhairt do na foirmí nua-aimseartha, níos sloinnithí (switch expressions le pattern matching i bhreise ar ráitis switch fada, null-coalescing do réamhshocruithe) is fios laethúil atá riachtanach chun C# geal, idiomaiteach a scríobh.

Isítear an switch expression agus pattern matching go háirithe mar fhianaise ar iompar C# nua-aimseartha i dtreo cód níos feidhmiúil, níos gearr, agus dá bhrí sin tá siad tábhachtach a thuiscint chun cód níos fearr a scríobh agus chun códbhunachar reatha C# a léamh ina n-úsáidtear na gné seo go forleathan.