Beginner's CSharp Switch Statement Tutorial: How To Properly Use A Switch Statement

The C# switch statement is one of our basic logical building blocks, allowing developers to select a path based on the value of a given expression. Understanding how to use it properly is important, and this tutorial aims to provide just that. I've put together this CSharp switch statement tutorial to help you understand its usage so you can start incorporating it into your code!

Through a series of practical examples and best practices, you'll gain the knowledge and skills necessary to master the switch statement. Whether you're a novice programmer or an experienced developer, the principles taught here in this CSharp switch statement tutorial will help you write more efficient, effective code. So buckle up and let's dive in!

---

Understanding Switch Statements

Switch statements are a fundamental tool that developers use to control program flow. They allow us to evaluate expressions against a set of possible values and execute code blocks depending on which value matches the expression. By using switch statements, developers can write code that is more efficient and easier to read than using a series of if/else statements.

To use a switch statement, we first specify the variable or expression that we want to evaluate. The switch statement then evaluates this expression and looks for the matching value in the case statements. Each case statement is associated with a value. If a matching value is found, then the code block associated with that case statement is executed.

While it's not required, it's important to note that every switch statement could benefit from a default case. This default case is executed if none of the other cases match the expression -- sort of like having an else block on a big if/else chain.

---

CSharp Switch Statement Tutorial - Examples

Let's take a look at a few variations for this CSharp switch statement tutorial to see these in action!

Example 1: A Simple Switch Statement

The following example is a straightforward usage of the switch statement. Let's check it out:

int number = 5;

switch (number)
{
    case 1:
        Console.WriteLine("The number is 1");
        break;
    case 2:
        Console.WriteLine("The number is 2");
        break;
    case 3:
        Console.WriteLine("The number is 3");
        break;
    default:
        Console.WriteLine("The number is neither 1, 2, nor 3");
        break;
}

In this example, we declare an integer variable called number and initialize it to 5. We then use a switch statement to evaluate the value of number against the case statements. Since number is not equal to 1, 2, or 3, the default case is executed, so the code will output "The number is neither 1, 2, nor 3" to the console.

Example 2: A Switch Statement with Multiple Cases

The next example is a slightly more advanced usage of a switch statement. Omitting the break keyword allows you to combine conditions. So either this situation is slightly more advanced or someone introduced a bug because they forgot a break! Let's see below:

string dayOfWeek = "Tuesday";

switch (dayOfWeek)
{
    case "Monday":
    case "Tuesday":
    case "Wednesday":
    case "Thursday":
    case "Friday":
        Console.WriteLine("It's a weekday");
        break;
    case "Saturday":
    case "Sunday":
        Console.WriteLine("It's the weekend");
        break;
    default:
        Console.WriteLine("Invalid day of the week");
        break;
}

In this example, we declare a string variable called "dayOfWeek" and initialize it to "Tuesday". We then use a switch statement to evaluate the value of "dayOfWeek" against the case statements. Since "dayOfWeek" matches the first case statement, the code block associated with that case statement is executed, outputting "It's a weekday" to the console.

This is possible because there is no break keyword between this case and the others stacked up with it. This allows the execution to match the first statement body. Follow along in this video for more examples:

Example 3: Incorporating Switch Statements into Code with Enums

One common use case for switch statements is with enums. Enums are data types that allow us to specify particular named values. Because there is a fixed set of states for an enum, they can work nicely with a switch statement -- especially for readability!

enum UserType { Admin, Moderator, User };

UserType userType = UserType.User;

switch (userType)
{
    case UserType.Admin:
        // code for an admin user here
        break;
    case UserType.Moderator:
        // code for a moderator here
        break;
    case UserType.User:
        // code for a regular user here
        break;
    default:
        throw new Exception("Invalid user type");
}

In this example, we define an enumeration called UserType that includes the values Admin, Moderator, and User. We then declare a variable of the UserType type called userType and initialize it to UserType.User. We use a switch statement to evaluate the value of userType against the case statements. Since userType matches the third case statement, the code block associated with that case statement is executed, which contains code for a regular user.

Now that we've seen some examples of switch statements in action, it's important to understand the syntax used in switch statements. By understanding the syntax, we can write more efficient and effective code that uses switch statements to their full potential.

---

Advanced Features of Switch Statements

Switch statements are an essential element of C# programming and can be used in conjunction with some advanced features in C# to improve application performance. Two advanced features of switch statements are the fall-through feature and the switch expression introduced in C# 8.0.

The Fall-Through Feature

The fall-through feature allows for the execution of code in multiple cases. In other words, if a case is matched, all cases beneath it will be executed. This feature can be beneficial in certain circumstances, such as when dealing with data that requires multiple actions.

Consider the example below:

case 3:
case 4:
   DoSomething();
   break;

In this example, if the input value is either 3 or 4, the DoSomething() method will execute. Understanding how to use this feature appropriately can lead to more efficient and clear code. We saw a similar example of this above in the article.

The Switch Expression

The switch expression is a coalescent expression introduced in C# 8.0. It differs from the switch statement in that it supports a more concise syntax, can be used in more varied contexts, and can return a value.

Consider the example below:

string result = value switch
{
     "first" => "The first value",
     "second" => "The second value",
     _ => "The default value",
};

In this example, the switch expression accepts the input value, evaluates it, and assigns the appropriate response to the variable result. This feature can be very useful when the return value is a key aspect of the code.

Benefits and Drawbacks of Advanced Switch Features

There are benefits and drawbacks to using advanced switch features like the fall-through feature and switch expressions in your code. Just as with anything else, we have pros and cons for every tool available to us. Here's a short list of ones that I've considered:

Pros of Using Fall-Through and Switch Expressions

The fall-through feature can lead to more concise and readable code, and the switch expression can provide a more concise and expressive way to perform tests and return values. Both features can help improve performance and code clarity in appropriate situations. Again, it's situational, so sometimes this can be a benefit.

Cons of Using Fall-Through and Switch Expressions

The fall-through feature can lead to unintended code execution and can make the code difficult to debug. Similarly, the switch expression can be difficult to troubleshoot if not used correctly. It's important to use these features appropriately and follow best practices when incorporating them into your code.

Easy-to-Forget Default Cases

When working with switch expressions, it's common to forget the default case, which can result in unexpected behavior when unhandled values are passed in. The same argument could be made for if/else chains, of course, but anecdotally I find it more common that a default case is omitted with a switch. It's not required to compile properly, but it can be especially problematic when handling enum values or expecting data of particular values. If these change as a codebase evolves, switch statements need to be updated accordingly!

Limited to Constant Values

As you may have noticed, switch statements are limited to constant value comparisons. Furthermore, they're limited to a single comparison per case, where an if-statement could have more complex logic. That doesn't mean it's "worse", it just means that a switch statement has particular usage scenarios.

Potential Performance Improvements

Switch statements can be handled by the compiler differently when generating IL code and result in better performance than if/else statements. While this isn't always true, I wouldn't necessarily suggest you rely on using a switch over an if/else strictly to drive performance improvements. However, if you were trying to squeeze every bit of performance out of a hot path, a switch could be an option. You can use Benchmarkdotnet to prove your performance is better or worse!

---

Best Practices for Using Switch Statements

Switch statements are a powerful tool in the C# programming language, but like any programming language construct, there are best practices to follow to ensure efficient and effective code.

Guidelines for Using Switch Statements Efficiently and Effectively

The following are guidelines to keep in mind when using switch statements:

• Use switch statements when you have multiple constant conditions to compare against a single variable.
• Keep switch statements to a reasonable size. If you find yourself writing a long switch statement, consider breaking it up into smaller, more manageable sections. A super-long switch starts to become as unwieldy as a super-long if/else statement.
• Consider the use of enums instead of constants or strings in switch statements. This could help with readability and maintainability (but it's not a hard rule, of course)
• Don't forget to add a default case! Forgetting this might mean silently missing conditions.
• However... Rely on default cases sparingly, as they can lead to unexpected behavior.

Strategies for Minimizing Redundant Code When Implementing Switch Statements

Although switch statements can be efficient, they are not always the most readable code. The following are strategies to minimize redundant code when implementing switch statements:

• Use helper methods to simplify switch statements.
• Combine cases with similar logic into a single case statement. This is where we can take advantage of the fall-through behavior.
• Consider the use of a dictionary or switch expression when a switch statement becomes too complex. This moves the complexity to creating the mapping, but simplicity when reading the lookup code.

Tips for Debugging Code That Contains Switch Statements

Debugging code that contains switch statements can be challenging. The following tips can help make this process more efficient:

• Verify that the switch statement's syntax is correct.
• Check if you have a default case being hit - or did you forget to add one?!
• Ensure that each case statement is properly terminated with a break or return statement.
• Consider your test coverage and test scenarios to ensure your switch is properly handling known inputs as well as unexpected ones.

Following these best practices can help to make your code more efficient and easier to debug, improving both the maintainability and readability of your codebase.

---

Wrapping Up Our CSharp Switch Statement Tutorial

After reviewing this CSharp switch statement tutorial, you should have a better understanding of how to leverage the CSharp switch statement! Key takeaways include understanding the syntax and basic functionality of switch statements, exploring the advanced features of fall-through and switch expressions, and following best practices for implementing switch statements in code.

While switch statements can be incredibly useful, it is important to keep in mind that they do have pros and cons, and errors can easily arise if not used correctly. As software engineers, it is our responsibility to use this tool efficiently and effectively. Don't forget your default cases!

Overall, mastering the C# Switch statement is just one step in becoming a skilled C# software engineer. Keep learning and exploring new concepts and technologies to continue growing in your field. Don't forget to subscribe to the Dev Leader Weekly newsletter and check out my YouTube channel for more programming tips and tutorials.