C# Switch: Select Cases and Return Clear Results

What you will understand

• Trace a switch statement from its input to the selected section.
• Distinguish break from return and avoid accidental fall-through.
• Share one body between several documented case labels.
• Write a switch expression with result arms and a deliberate catch-all policy.
• Handle missing, differently cased and unsupported command text.
• Understand first-match guards, relational patterns and unreachable arms.
• Distinguish exhaustive coverage from a correct domain response.
• Build an export-request selector with useful rejection feedback.

Use switch when one input chooses among named cases

A switch selects behavior by matching one input against cases. A menu choice, a command token or a format code is often easier to read as a set of named cases than as a long sequence of repeated equality checks. Start with the possible inputs and the required response for each one.

The statement form writes switch (input), then a braced set of sections. A case label identifies a matching value and ends with a colon. The statements in the selected section run. A break then exits the switch, allowing later statements in the surrounding program to continue.

You need the strings, Boolean rules and if/else lessons first. Each editor below is a complete separate Program.cs. Two examples deliberately fail compilation, and one deliberately fails at runtime. Predict a normal input and an unknown input before selecting Run.

using System;

int choice = 2;
switch (choice)
{
    case 1:
        Console.WriteLine("Show course list.");
        break;
    case 2:
        Console.WriteLine("Show saved practice.");
        break;
    default:
        Console.WriteLine("Choose 1 or 2.");
        break;
}
Console.WriteLine("Menu check finished.");

Select Run code to compile and execute this program.

Show saved practice.
Menu check finished.

using System;

int choice = 9;
switch (choice)
{
    case 1:
        Console.WriteLine("Show course list.");
        break;
    case 2:
        Console.WriteLine("Show saved practice.");
        break;
    default:
        Console.WriteLine("Choose 1 or 2.");
        break;
}

Select Run code to compile and execute this program.

Choose 1 or 2.

Sections need an exit; aliases can share a body

C# does not allow ordinary execution to run from the end of a completed section into the next section. Use break to leave the switch, or another appropriate control transfer such as return. A return ends the current method or this top-level run; it does more than break.

Several labels can appear before one shared body. That is useful for documented aliases such as md and markdown. The shared labels do not mean both sections execute, and no completed body is falling through into another one.

A switch statement can omit default. If no section matches, execution simply continues after the statement. That may be intentional, but a user-facing choice often benefits from explicit unknown-input feedback. default supplies a fallback; it does not turn an invalid input into a valid choice by itself.

using System;

string format = "markdown";
switch (format)
{
    case "md":
    case "markdown":
        Console.WriteLine("Markdown export selected.");
        break;
    case "txt":
        Console.WriteLine("Plain-text export selected.");
        break;
    default:
        Console.WriteLine("Supported formats: md, markdown, txt.");
        break;
}

Select Run code to compile and execute this program.

Markdown export selected.

using System;

int choice = 1;
switch (choice)
{
    case 1:
        Console.WriteLine("First action.");
    case 2:
        Console.WriteLine("Second action.");
        break;
}

Select Run code to compile and execute this program.

Compilation fails: control cannot fall through from one completed case section.

using System;

string command = "quit";
switch (command)
{
    case "quit":
        Console.WriteLine("Goodbye.");
        return;
    default:
        Console.WriteLine("Continue working.");
        break;
}
Console.WriteLine("After switch.");

Select Run code to compile and execute this program.

Goodbye.

using System;

int choice = 9;
switch (choice)
{
    case 1:
        Console.WriteLine("Show course list.");
        break;
}
Console.WriteLine("After switch.");

Select Run code to compile and execute this program.

After switch.

Use a switch expression when selection returns one value

A switch expression puts the input before the switch keyword. Each arm has a pattern, an arrow and one result expression. Commas separate arms, and the completed assignment ends with a semicolon. Do not mix this syntax with case labels, colons and break statements from the statement form.

The selected arm supplies the value that is assigned or used by the surrounding expression. Use this form for a small mapping, such as a known format token to its extension, when all results fit the intended target type. Several actions or an early rejection path may read more naturally as a statement.

The discard pattern _ is a catch-all arm. It matches any remaining input and usually belongs last. A useful fallback must reflect the domain: a string saying unsupported may be suitable for a demonstration, while an actual request flow should avoid producing a misleading successful result.

using System;

string format = "md";
string extension = format switch
{
    "md" => ".md",
    "txt" => ".txt",
    _ => "unsupported"
};
Console.WriteLine($"Extension: {extension}");

Select Run code to compile and execute this program.

Extension: .md

using System;

string format = "pdf";
Console.WriteLine("Selecting extension");
string extension = format switch
{
    "md" => ".md",
    "txt" => ".txt"
};
Console.WriteLine(extension);

Select Run code to compile and execute this program.

Selecting extension
Then execution fails with SwitchExpressionException.

Decide how text should match before selecting a case

String constant cases use exact case-sensitive matching. A space-padded or differently cased command will not match its plain lowercase token automatically. Do not rely on a human reader seeing the spellings as equivalent; define the token policy explicitly.

The normalization example first rejects a missing or blank answer, then trims the text and converts the fictional ASCII format tokens to invariant lowercase. This is an application convention for a small documented vocabulary. Keep general display names and other identity fields separate from that convention.

The or pattern lets one expression arm match more than one alias. It is pattern syntax, not the Boolean operator || joining two comparisons. In a statement, adjacent case labels are another readable way to share a body. Neither alias support nor normalization establishes that every other token should be accepted.

using System;

string? rawFormat = "  Markdown  ";
if (string.IsNullOrWhiteSpace(rawFormat))
{
    Console.WriteLine("Choose an export format.");
    return;
}
string format = rawFormat.Trim().ToLowerInvariant();
string extension = format switch
{
    "md" or "markdown" => ".md",
    "txt" or "text" => ".txt",
    _ => "unsupported"
};
Console.WriteLine($"Extension: {extension}");

Select Run code to compile and execute this program.

Extension: .md

Match order and guards determine the selected section

A when guard adds a Boolean requirement after a matching pattern. The pattern and guard must both succeed for that section to be chosen. If the pattern matches but its guard is false, selection can continue to a later applicable section.

Place a guarded specific section before an unguarded fallback for the same label. Otherwise the earlier fallback already covers its inputs. A switch expression also rejects a specific arm placed below a catch-all, because that later arm cannot be selected.

Although default in a statement is a fallback regardless of where its label is written, put it last for clarity. Do not transfer that special statement rule to the expression discard arm: _ is an ordinary catch-all pattern considered in arm order.

using System;

string delivery = "express";
bool expressAvailable = false;
switch (delivery)
{
    case "express" when expressAvailable:
        Console.WriteLine("Express quote available.");
        break;
    case "express":
        Console.WriteLine("Express is unavailable; choose standard.");
        break;
    case "standard":
        Console.WriteLine("Standard quote available.");
        break;
    default:
        Console.WriteLine("Unknown delivery option.");
        break;
}

Select Run code to compile and execute this program.

Express is unavailable; choose standard.

using System;

string format = "md";
string extension = format switch
{
    _ => "unsupported",
    "md" => ".md"
};
Console.WriteLine(extension);

Select Run code to compile and execute this program.

Compilation fails: the md arm is unreachable after the catch-all.

Choose the structure that makes numeric categories easiest to verify

Modern switch patterns can express relational ranges and combine alternatives with or. For a score band, reject out-of-domain values before classifying the valid ones. A score of 101 should not accidentally reach a high-score arm merely because it exceeds ninety.

Within a switch expression, the first matching arm supplies the result. Reaching a lower threshold can carry the knowledge that an earlier higher threshold failed. Test the exact boundaries and their neighbors, just as you did with else-if chains.

You do not need to replace a clear if/else chain with switch patterns. Prefer if when the rule combines unrelated conditions or when the sequence is clearer as guards. Prefer switch when the input-centered set of alternatives makes the intended mapping easier to inspect.

using System;

int score = 85;
string band = score switch
{
    < 0 or > 100 => "Invalid score",
    >= 90 => "Excellent",
    >= 70 => "On track",
    _ => "Keep practicing"
};
Console.WriteLine(band);

Select Run code to compile and execute this program.

On track

Exhaustive syntax is not the same as a correct fallback policy

A statement can continue silently after no match, but a switch expression needs a result. On the .NET runtime used by these editors, an unmatched nonexhaustive expression throws SwitchExpressionException. The compiler often warns about missing coverage, yet a warning may not prevent the program from running.

A catch-all avoids an unmatched expression but can still encode the wrong rule. Mapping every unexpected delivery token to the standard fee hides invalid input and produces a misleading quote. The guided repair rejects the unknown token before the fee output instead.

For each selector, test every documented case, every alias, blank or missing text when applicable, and at least one unsupported value. State what success actually does. The export-request lab chooses and prints a filename; it does not create a file or complete a download.

Guided repair: reject an unsupported option

An unknown overnight option silently receives the standard-delivery fee. Reject unsupported tokens before output, while still quoting the two supported choices. Use the structure that makes the rejection path clear.

using System;

string option = "overnight";
decimal fee = option switch
{
    "standard" => 4m,
    "express" => 9m,
    _ => 4m
};
Console.WriteLine($"Delivery fee: {fee:F2}");

Select Run code to compile and execute this program.

Delivery fee: 4.00

Repair checkpoints

1. standard must quote 4.00 and express must quote 9.00.
2. overnight and an empty present token must print the supported-choice message.
3. The rejected path must not print a delivery fee.
4. Every continuing accepted path must assign fee.
5. Do not treat exhaustive matching as proof that the fallback policy is correct.

using System;

string option = "overnight";
decimal fee;
switch (option)
{
    case "standard":
        fee = 4m;
        break;
    case "express":
        fee = 9m;
        break;
    default:
        Console.WriteLine("Choose standard or express.");
        return;
}
Console.WriteLine($"Delivery fee: {fee:F2}");

Select Run code to compile and execute this program.

Choose standard or express.

Independent lab: an export request selector

Choose an export filename from a required format token. Support md/markdown and txt/text aliases after the stated trimming and casing policy. Missing and unsupported choices must produce feedback without a successful filename.

Acceptance checklist

• Keep rawFormat = " Markdown " and fileStem = "lesson-notes" for the reference run.
• Reject null, empty and whitespace-only input before calling string instance methods.
• Trim and use invariant lowercase for this fixed ASCII token vocabulary.
• Use shared case labels for md/markdown and txt/text.
• Return after unknown-input feedback so no filename is printed.
• Print Export file: lesson-notes.md for the reference input.
• Explain that the filename is a display result; no file is created and the fixed stem is not a general filename-validation implementation.

using System;

string? rawFormat = "  Markdown  ";
string fileStem = "lesson-notes";
string extension = rawFormat switch
{
    "md" => ".md",
    "txt" => ".txt",
    _ => ".txt"
};
Console.WriteLine($"Export file: {fileStem}{extension}");

Select Run code to compile and execute this program.

Export file: lesson-notes.txt

using System;

string? rawFormat = "  Markdown  ";
string fileStem = "lesson-notes";
if (string.IsNullOrWhiteSpace(rawFormat))
{
    Console.WriteLine("Choose an export format.");
    return;
}
string format = rawFormat.Trim().ToLowerInvariant();
string extension;
switch (format)
{
    case "md":
    case "markdown":
        extension = ".md";
        break;
    case "txt":
    case "text":
        extension = ".txt";
        break;
    default:
        Console.WriteLine("Supported formats: md, markdown, txt, text.");
        return;
}
Console.WriteLine($"Export file: {fileStem}{extension}");

Select Run code to compile and execute this program.

Export file: lesson-notes.md

Changed-input checks

• md, markdown, MD and surrounding-space Markdown select .md.
• txt and TEXT select .txt.
• pdf reports the supported formats and prints no export filename.
• null, an empty string and whitespace-only text report a required-format message.
• Changing the fixed stem to practice changes only the printed filename.

Recap: match the syntax to the selection

Use a statement for selected statements and an expression for one returned value. Check known cases, aliases and the fallback separately.

switch (input)

Select a section of statements by matching one input.

case value:

Introduce a matching section; adjacent labels can share a body.

break / return

Exit the switch versus exit the current method or top-level run.

default:

Handle an unmatched statement input with a deliberate fallback.

input switch { pattern => result }

Return the selected arm’s value in an expression.

_ => result

Catch remaining expression inputs; put this arm last.

pattern when condition

Require both the pattern match and a Boolean guard.

"md" or "markdown"

Match either alias within one pattern arm.

Frequently asked questions

Next step and references

A switch organizes alternatives around one input. Keep statement and expression syntax distinct, share documented aliases clearly, and choose an honest fallback. Coverage and domain validity are separate questions.

Next is C# While and Do-While Loops. You will repeat work with a condition, trace the state changes and make sure a loop has a clear way to stop.

Official references

Original SovranCode explanations, examples and exercises. Technical details were checked against these references.

• Microsoft Learn: switch statements
• Microsoft Learn: switch expressions

Last updated: 26 October 2026.