Apa konstruk kontrol-aliran yang ditawarkan C#?

Question

Accepted Answer

C# menyediakan konstruk kontrol-aliran standar — kondisional (`if`, `switch`), loop (`for`, `foreach`, `while`), dan branching (`break`, `continue`, `return`) — ditambah peningkatan modern seperti switch expressions dan pattern matching yang membuat kode lebih ringkas.

## Kondisional

```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 statement dan modern switch expression

```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 expression** modern lebih ringkas (mengembalikan nilai, tanpa `break`), dan mendukung **pattern matching** yang powerful (mencocokkan tipe, kondisi, dan lebih banyak) — peningkatan signifikan dibanding switch tradisional yang verbose.

## Loop

```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` (iterasi apa pun yang `IEnumerable`) adalah loop idiomatik untuk koleksi.

## Branching

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

## Mengapa ini penting

Kontrol aliran adalah mekanisme dasar untuk mengekspresikan logika dalam setiap program, jadi memahami konstruk C# adalah pengetahuan fundamental sehari-hari.

Meskipun dasar-dasarnya standar, peningkatan C# modern layak diketahui dan digunakan: **switch expression** (C# 8+) adalah peningkatan signifikan dibanding switch tradisional — ringkas, mengembalikan nilai, tanpa bug fall-through (tanpa `break` yang terlupakan), dan mendukung **pattern matching** (mencocokkan tipe, kondisi, nilai, dan struktur), yang membuat logika kondisional kompleks jauh lebih bersih dibanding rantai if-else bersarang.

**Operator null-coalescing** (`??`, `??=`) menyediakan penanganan null yang bersih, dan `foreach` adalah cara idiomatik untuk iterasi koleksi.

Memahami konstruk-konstruk ini dan memilih bentuk modern yang lebih ekspresif (switch expressions dengan pattern matching dibanding switch statements verbose, null-coalescing untuk nilai default) adalah pengetahuan sehari-hari untuk menulis C# yang bersih dan idiomatik.

Switch expression dan pattern matching khususnya mencerminkan evolusi C# modern menuju kode yang lebih fungsional dan ringkas, menjadikannya penting untuk dipahami baik untuk menulis kode yang lebih baik maupun untuk membaca codebase C# saat ini yang menggunakan fitur-fitur ini secara ekstensif.