How to Implement Switch Expressions in Csharp

Switch expressions in C# bring simplicity and conciseness to conditional logic. By replacing traditional switch statements, you can avoid lengthy code while boosting readability. If you’ve found yourself dealing with repetitive or complex conditions, switch expressions can transform how you write and maintain your code.

Let’s unravel how you can implement them effectively.

---

What Are Switch Expressions?

Switch expressions are a streamlined version of the traditional switch statement. Introduced in C# 8.0, they allow you to map conditions directly to their outcomes without writing extensive boilerplate code. Unlike older switch statements, switch expressions return a value and don’t require break keywords.

Here’s the key difference:

• Traditional switch: verbose, with explicit keywords like case and break.
• Switch expressions: concise and focused on returning results.

---

Why Use Switch Expressions?

Before diving into implementation, let’s break down the advantages:

• Cleaner Code: Say goodbye to excessive lines of code found in traditional switch statements.
• Readability: Focus on the results of conditions rather than the control flow.
• Reduction of Bugs: Automatically handle fall-through scenarios since each condition requires explicit handling.

If you’ve used enums in C#, you’ve likely worked with switch statements. This guide on C# Enums explains how enums pair beautifully with switch expressions.

---

A Simple Switch Expression in Action

Here’s a simple example to introduce the syntax:

int number = 5;

string result = number switch
{
    1 => "One",
    2 => "Two",
    3 => "Three",
    _ => "Number not covered"
};

Console.WriteLine(result);

Breakdown:

1. Input Expression (number): This value is checked against various conditions.
2. Cases (1, 2, 3): Each number corresponds to a specific string.
3. Default Handling (_): The _ placeholder covers any unmatched input.

---

Handling Complex Scenarios with Switch Expressions

Switch expressions don’t just handle simple values—they work for patterns, enums, and more.

Example: Using Enums

Enums provide named constants, and switch expressions enhance their utility:

enum Day { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday }

Day today = Day.Wednesday;

string activity = today switch
{
    Day.Monday => "Start the week strong!",
    Day.Friday => "Prepare for the weekend.",
    Day.Sunday => "Relax and recharge.",
    _ => "It's just another day."
};

Console.WriteLine(activity);

Explanation:

• Enums like Day simplify category handling, making your code more descriptive.
• The _ covers days not explicitly mentioned.

For a deeper dive into enums, explore C# Enums: A Comprehensive Guide.

---

Adding Filters with When Clauses

The when clause adds granularity, enabling checks beyond direct matches.

Example: Filtering with Conditions

int speed = 85;

string status = speed switch
{
    <= 30 => "Slow",
    <= 70 => "Safe",
    > 70 => "Speeding",
    _ => "Invalid speed"
};

Console.WriteLine(status);

Explanation:

• Conditions Directly in Switch: Avoid extra if-else logic for each case.
• Automatic Fall-Through Prevention: Each case provides unique handling without overlapping.

---

Combining Pattern Matching and Switch Expressions

Pattern matching adds power to switch expressions, letting you evaluate object properties directly.

Example: Inspecting Object Types

object shape = new { Type = "Circle", Radius = 5 };

string description = shape switch
{
    { Type: "Circle", Radius: > 4 } => "Large circle",
    { Type: "Square" } => "Square shape identified",
    _ => "Unknown shape"
};

Console.WriteLine(description);

Key Insights:

1. Object Destructuring: Evaluate properties within an object.
2. Match and Condition Together: Pair precision with flexibility.

---

Think Beyond Basic Operations

C# switch expressions allow nested logic and even invoke methods. Here’s a unique example:

Example: Calling Methods

int sales = 50;

void Reward(int amount) => Console.WriteLine($"Reward: {amount} points");

Action reward = sales switch
{
    <= 20 => () => Reward(10),
    <= 50 => () => Reward(25),
    _ => () => Reward(50)
};

reward.Invoke();

Explanation:

• Method Invocation: Dynamically determine actions using expressions.
• Flexibility: Easily scale cases for complex scenarios.

---

Conclusion

Switch expressions in C# modernize your coding experience, focusing on results without unnecessary clutter. From basic operations to complex evaluations, the concise syntax simplifies logic and reduces errors.

Start experimenting with switch expressions today to see the difference. If you work closely with enums or data filtering, they’ll quickly become an essential tool in your developer arsenal.

Looking for more tips to enhance your programming? Check out how various C# concepts elevate development.