Vilka kontrollflödes-konstruktioner erbjuder C#?

Question

Accepted Answer

C# tillhandahåller standard kontrollflödes-konstruktioner — villkor (`if`, `switch`), loopar (`for`, `foreach`, `while`) och förgreningar (`break`, `continue`, `return`) — plus moderna förbättringar som switch expressions och pattern matching som gör koden mer koncis.

## Villkor

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

Den moderna **switch expression** är koncis (returnerar ett värde, ingen `break`), och stöder kraftfull **pattern matching** (matchning av typer, villkor och mer) — en stor förbättring jämfört med det utförliga traditionella switch.

## Loopar

```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` (iterering över vilken `IEnumerable` som helst) är det idiomatiska sättet att loopa över samlingar.

## Förgreningar

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

## Varför det är viktigt

Kontrollflöde är den grundläggande mekanismen för att uttrycka logik i varje program, så förståelse för C#:s konstruktioner är grundläggande kunskap som du använder dagligen.

Med tanke på att grunderna är standard, är det värt att känna till och använda moderna C#-förbättringar: **switch expression** (C# 8+) är en betydande förbättring jämfört med traditionell switch — koncis, värdereturnerande, utan fall-through-buggar (ingen glömd `break`), och med stöd för **pattern matching** (matchning på typer, villkor, värden och struktur), vilket gör komplex villkorslogik mycket renare än kapslade if-else-kedjor.

**Null-coalescing-operatorerna** (`??`, `??=`) tillhandahåller ren null-hantering, och `foreach` är det idiomatiska sättet att iterera över samlingar.

Att känna till dessa konstruktioner och föredra moderna, mer uttrycksfulla former (switch expressions med pattern matching framför utförliga switch-satser, null-coalescing för standardvärden) är daglig kunskap för att skriva ren, idiomatisk C#.

Switch expression och pattern matching reflekterar särskilt utvecklingen av modernt C# mot mer funktionell, koncis kod, vilket gör dem viktiga att förstå både för att skriva bättre kod och för att läsa nuvarande C#-kodbaser som använder dessa funktioner omfattande.