Quais construtos de controle de fluxo o C# oferece?

Question

Accepted Answer

C# fornece construtos de controle de fluxo padrão — condicionais (`if`, `switch`), loops (`for`, `foreach`, `while`) e desvios (`break`, `continue`, `return`) — mais aprimoramentos modernos como expressões switch e correspondência de padrões que tornam o código mais conciso.

## Condicionais

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

## Instrução switch e expressão switch moderna

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

A **expressão switch** moderna é concisa (retorna um valor, sem `break`), e suporta poderosa **correspondência de padrões** (correspondência de tipos, condições e muito mais) — uma melhoria significativa sobre o switch tradicional e verboso.

## Loops

```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` (iterando qualquer `IEnumerable`) é o loop idiomático para coleções.

## Desvios

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

## Por que isso importa

Controle de fluxo é o mecanismo básico para expressar lógica em todo programa, então compreender os construtos do C# é conhecimento fundamental do dia a dia.

Enquanto o básico é padrão, os aprimoramentos modernos do C# valem a pena conhecer e usar: a **expressão switch** (C# 8+) é uma melhoria significativa sobre o switch tradicional — concisa, retorna valor, sem bugs de fall-through (sem `break` esquecido), e suportando **correspondência de padrões** (correspondência em tipos, condições, valores e estrutura), que torna a lógica condicional complexa muito mais limpa do que cadeias aninhadas if-else.

Os **operadores de coalescência null** (`??`, `??=`) forncem tratamento limpo de null, e `foreach` é a forma idiomática de iterar coleções.

Conhecer esses construtos e preferir as formas modernas e mais expressivas (expressões switch com correspondência de padrões em vez de instruções switch verbosas, coalescência null para padrões) é conhecimento do dia a dia para escrever C# limpo e idiomático.

A expressão switch e a correspondência de padrões em particular refletem a evolução do C# moderno em direção a código mais funcional e conciso, tornando-os importantes para entender tanto para escrever melhor código quanto para ler bases de código C# atuais que usam essas funcionalidades extensivamente.