How to Use Switch Case in C# with Examples

Switch case is a branching statement used in C# to select one of many code blocks to be executed. This construct is particularly useful for comparing a single value against multiple candidates and executing the corresponding block of code based on the matching case. It provides a cleaner and more readable alternative to a long series of if-else statements, especially when dealing with multiple discrete values such as menu selections, operation codes, or specific number and character constants.

The C# switch statement works by evaluating an expression and then running the case clause that matches the expression’s value. If no case matches and a default clause is defined, the code in the default clause will execute. Each case is followed by the colon character (:) and an ensuing block of code, a single line or multiple lines of statements.

To demonstrate the utility of a switch case in C#, an example will be presented. It will illustrate the syntax, including how to declare a switch statement, define case clauses, and specify a default case, all of which will contribute to understanding the execution flow controlled by the switch case in C#. The example will also show proper case termination using the break statement and discuss patterns and other features introduced in recent versions of C# that enhance the versatility of switch statements.

Understanding the Switch Statement in C#

The switch statement in C# is a control flow construct used to select one of many code blocks to execute. A switch statement is a more efficient alternative to a long series of if-else statements when comparing a single variable against a series of constants.

Syntax of a Switch Case in C#

In a switch statement, the expression is evaluated once and compared with the values of each case label. The basic syntax is as follows:

switch (expression)
{
    case constant1:
        // Code to execute if expression equals constant1
        break;
    case constant2:
        // Code to execute if expression equals constant2
        break;
    ... // More cases can be added as needed
    default:
        // Code to execute if expression doesn't match any case
        break;
}

Key elements to consider in the syntax:

Each case must be labeled with case followed by a constant and a colon.
The break statement is crucial; it terminates the switch block.
The default case is optional, but it handles any value not explicitly handled by other case statements.

Flow of Control with C# Switch Case

When the switch statement is executed, the control flow follows these steps:

The expression is evaluated.
The value is compared with each case label, in order.
- If a match is found, the corresponding block of code runs.
- If no matches are found, and a default case exists, its block of code runs.
After the block for the matched case is executed, the break statement prevents the execution from falling through to the subsequent cases.

Example:

int number = 3;
switch (number)
{
    case 1:
        Console.WriteLine("One");
        break;
    case 2:
        Console.WriteLine("Two");
        break;
    case 3:
        Console.WriteLine("Three");
        break;
    default:
        Console.WriteLine("Default case");
        break;
}

In this example, the output will be “Three” because the value of number matches case 3.

Implementing Switch Case in C#

The switch statement in C# provides an efficient way to dispatch execution to different parts of code based on the value of a variable. It is a more structured and cleaner alternative to multiple if statements.

Basic Example

Here is a basic example of how to use the switch case in C#.

using System;

class SwitchCaseExample
{
    static void Main()
    {
        int number = 1;

        switch (number)
        {
            case 1:
                Console.WriteLine("One");
                break;
            case 2:
                Console.WriteLine("Two");
                break;
            default:
                Console.WriteLine("Default");
                break;
        }

        Console.WriteLine("Switch case example completed.");
    }
}

In this example, the switch statement evaluates the number variable. If it matches the value 1, it prints out “One”. If number is 2, it prints “Two”. If there is no match, the default case is executed printing “Default”.

You can see the output after I ran the code using the Visual Studio console application.

Using Enumerations

Here, you can see how to use a switch case in C# using an enum.

using System;

class EnumSwitchExample
{
    enum Color { Red, Green, Blue }

    static void Main()
    {
        Color color = Color.Red;

        switch (color)
        {
            case Color.Red:
                Console.WriteLine("Red");
                break;
            case Color.Green:
                Console.WriteLine("Green");
                break;
            case Color.Blue:
                Console.WriteLine("Blue");
                break;
        }

        Console.WriteLine("Switch statement with enum completed.");
    }
}

By utilizing an enumeration, the switch case provides clearer semantics for selecting discrete options. In the example provided, the enum Color is declared, and the switch operates on its values, outputting the name of the color.

Once you execute the code using a console application in C#, you can see the output in the screenshot below:

The switch statement evaluates the color variable.
Each case statement checks for a specific Color value and prints the corresponding color name.
The break statement is used to exit the switch block once a match is found and its associated code is executed.
After the switch statement, there’s an additional Console.WriteLine statement indicating the completion of the switch statement.

Multiple Case Labels

Here is another example of how to use multiple case labels in the C# switch case.

using System;

class GroupedSwitchCaseExample
{
    static void Main()
    {
        int number = 3;

        switch (number)
        {
            case 1:
            case 2:
            case 3:
                Console.WriteLine("One, Two, or Three");
                break;
            case 4:
            case 5:
            case 6:
                Console.WriteLine("Four, Five, or Six");
                break;
            default:
                Console.WriteLine("Any other");
                break;
        }

        Console.WriteLine("Switch case grouping example completed.");
    }
}

It’s possible to have multiple cases execute the same action. In this snippet, if number is 1, 2, or 3, the same line of code is executed. The same holds for values 4, 5, and 6. This reduces redundancy and creates a more concise switch statement.

Advanced Concepts of C# Switch Case

The advanced use of the switch case in C# enables complex decision-making with improved code readability and maintainability. These include pattern matching and conditional clauses that enhance the functionality of traditional switch statements.

Pattern Matching with Switch

In C#, pattern matching with switch has been augmented to support more sophisticated type checks and property evaluations. Here’s an example of how to use pattern matching in a switch case:

object obj = // ... some value
switch(obj)
{
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    case string s when s.Length > 0:
        Console.WriteLine($"Non-empty string: {s}");
        break;
    case string s:
        Console.WriteLine("Empty string");
        break;
    case null:
        throw new ArgumentNullException(nameof(obj));
    default:
        Console.WriteLine("Unknown type");
        break;
}

This code demonstrates the type pattern case int i and case string s. When obj matches the specified type, the corresponding block executes. The when keyword can further filter cases for strings with a length greater than 0.

Using When Clause for Conditions

The when clause allows for additional conditions to be appended to a case pattern. This provides more granular control over the switch case evaluation. Here’s how the when clause can be utilized for conditions:

int value = // ... some integer
switch(value)
{
    case var x when x < 0:
        Console.WriteLine("Negative");
        break;
    case var x when x >= 0 && x <= 10:
        Console.WriteLine("Between 0 and 10");
        break;
    case var x when x > 10:
        Console.WriteLine("Greater than 10");
        break;
    default:
        Console.WriteLine("Out of range");
        break;
}

In this snippet, var x matches any integer value, and the when clause applies further conditions to define more precise case blocks. Each condition is evaluated in order, allowing complex logic to be expressed cleanly.

Best Practices of using C# Switch Case

When implementing a switch case in C#, developers should follow certain best practices to ensure code clarity, maintainability, and the prevention of common errors.

Avoiding Fall-Through

Explicit Break Statements: Each case block in a switch statement should end with an explicit break statement to prevent accidental fall-through.
Use Comments: If a fall-through is intentional, it should be clearly documented with comments to communicate this to other developers.

Ensuring All Cases Are Covered

Default Case: Always include a default case to handle any unexpected values.
Comprehensive Cases: Review the logic to ensure all possible cases have been addressed.
Throw Exceptions: Consider throwing an exception in the default case if reaching it indicates an abnormal situation.

Common Pitfalls

When working with switch-case constructs in C#, developers commonly encounter a few challenges. Awareness and careful attention to detail can help avoid these issues.

Comparing Incorrect Types

In C#, the switch expression and case statements must be of the same type. If they are not, the compiler will raise an error.

Example: switch (variableOfTypeInt) { case "string": // This will cause an error // Code break; } The variableOfTypeInt is an integer, while the case is checking against a string.

Forgetting Break Statements

Each case block needs to end with a break statement, except for the ones ending with goto case, return, or similar control flow statements. Without a proper termination, the code execution may fall through to subsequent cases, causing unintended behavior.

Correct usage: switch (value) { case 1: // Code break; case 2: // Code break; }
Improper usage (leads to fall-through): switch (value) { case 1: // Code // Missing break or other terminating statement here case 2: // Code executed unintentionally when case 1 is true break; }

C# Switch Case Alternatives

In C#, developers sometimes need alternatives to switch case constructs for control flow. These alternatives can offer more suitable solutions depending on the complexity of the conditionals and the actions that need to be taken.

If-Else Statements

If-else statements are the most straightforward alternative. They work well for simple, linear decision-making scenarios where a few conditions need to be evaluated. For example:

int number = 3;
if (number == 1) {
    // Execute code block for condition 1
} else if (number == 2) {
    // Execute code block for condition 2
} else if (number == 3) {
    // Execute code block for condition 3
} else {
    // Execute code block if no conditions are met
}

This structure is most effective when dealing with a limited number of conditions, as it becomes harder to read with increased complexity.

Using Dictionaries for Function Mapping

Dictionaries can be used to map keys to functions, creating a cleaner alternative to a switch case when executing different logic paths based on key value. For example:

var functionMap = new Dictionary<int, Action> {
    { 1, () => { /* Execute code block for condition 1 */ } },
    { 2, () => { /* Execute code block for condition 2 */ } },
    { 3, () => { /* Execute code block for condition 3 */ } }
};

int number = 3;
if (functionMap.TryGetValue(number, out Action action)) {
    action();
} else {
    // Execute code block if no key is found
}

Using a dictionary is especially beneficial when actions are numerous or complex, improving maintainability and readability.

Conclusion

The switch case is a powerful control structure in C# that offers a clear and organized way to handle multiple conditional branches. By providing an alternative to lengthy if-else statements, it enhances code readability and maintainability. Users can implement switch cases efficiently by following the given guidelines:

Syntax: Each case represents a potential match and is followed by the code to execute if the case is true.
Break Statement: It is crucial to include a break statement at the end of each case to prevent fall-through.
Default Case: Including a default case ensures that there is a catch-all for scenarios where no cases match.

In practice, they have seen that switch cases can significantly streamline the decision-making process within a program. Efficient use of this construct requires one to carefully match case values with the expected types and to ensure all possible values are accounted for either explicitly or through the default case.

Beginners and seasoned developers alike should remember the unique benefits of switch cases for enhancing the logic and functionality of a C# application. The simplicity in syntax contrasted with the robustness in functionality makes the switch case an indispensable tool in a C# programmer’s toolkit.