Skip to main content
Learn to code

Properly Formatting IF Statements in Your C# Code

— Christian Schou

formatting if statements, properly code formatting, if formatting, c#
Developer looking at nicely formatted code

Welcome to this blog post on properly formatting if statements in your code. If statements are a fundamental component of any programming language and are essential to making decisions within your code. They allow you to create conditional logic and execute specific blocks of code based on the conditions set.

However, writing if statements that are readable, maintainable, and efficient can be a challenge. Poorly formatted if statements can lead to bugs, confusion, and unnecessary complexity in your code. I think all developers can nod in recognition of this problem. 😅

Introduction 🚀

Often when I start writing code I encounter one single problem. I know that my code is akin to a developing child that matures and expands with time. Code does the exact same thing... I think I can talk on behalf of every developer when I say that we would like our code to develop in a positive direction, at all times. By that I mean the following:

  • Simplify the process of testing and refactoring our code.
  • Make sure the code is written in a nice, clean, and well-documented way, making it easier for other developers to adopt it in order to extend and maintain it.
  • Making sure that we can scale a solution without having to touch some of the existing logic that performs well, handles big or complex tasks, etc...
Code that is akin to a developing child
Code that is akin to a developing child - Created using DALL-E 2

Imagine a method that got 20 if/else if statements... I would get tired even before I started reading the code. If you would go down that road, one thing would happen, you would fall short on my points above. It would require additional effort from you and your team to make up for these shortcomings.

An example of the issue

Reading is one way to get to know things, but I like to show the problem to cut it out and give you a better understanding of the problem/issue. For this post, let's consider the following scenario: You have an online library (written in C#/.NET of course) where a user is renting a few books online and would like the books delivered at home, instead of dropping by and picking them up.

Your library got a few rules for where the lenders can be located. Before a lender can fulfill an order for the rental of the books, we have to go through a few location rules. Let's refer to this as lending rules.

using System;

class OnlineLibrary
{
    // List of permitted lender locations
    private string[] permittedLocations = { "LocationA", "LocationB", "LocationC" };

    // Method to process book rental orders
    public void ProcessBookRental(string lenderLocation)
    {
        // Check if lender's location is permitted
        if (IsLocationPermitted(lenderLocation))
        {
            // Process the book rental order
            Console.WriteLine("Book rental order processed successfully.");
        }
        else
        {
            // Lender's location is not permitted
            Console.WriteLine("Error: Lender's location is not permitted for book delivery.");
        }
    }

    // Method to check if a location is permitted
    private bool IsLocationPermitted(string location)
    {
        // Loop through permitted locations and check if location is in the list
        foreach (string permittedLocation in permittedLocations)
        {
            if (permittedLocation == location)
            {
                return true;
            }
        }
        return false;
    }
}

class Program
{
    static void Main()
    {
        OnlineLibrary library = new OnlineLibrary();

        // Scenario 1: Lender's location is permitted
        string lenderLocation1 = "LocationA";
        library.ProcessBookRental(lenderLocation1); // Output: Book rental order processed successfully.

        // Scenario 2: Lender's location is not permitted
        string lenderLocation2 = "LocationD";
        library.ProcessBookRental(lenderLocation2); // Output: Error: Lender's location is not permitted for book delivery.
    }
}

In the code example above, the OnlineLibrary class has a ProcessBookRental method that takes the lender's location as input and checks if it is permitted based on the permittedLocations list. If the lender's location is in the list of permitted locations, the book rental order is processed successfully; otherwise, an error message is displayed.

Writing code is not just about getting it to work, but also about making it readable and maintainable for yourself and other developers. Properly formatted if statements can greatly contribute to the overall quality of your codebase. - Christian Schou

The complexity of the code can increase depending on the lending rules and their implementation. For example, if the lending rules involve multiple criteria such as geographical regions, time zones, availability of delivery services, or other factors, the code may need to include additional logic to handle these conditions. Additionally, if the lending rules change frequently or need to be updated dynamically, the code may require further modifications to accommodate such changes.

This can result in complex conditional statements, data structures, or algorithms to manage the lending rules effectively, making the codebase more intricate and challenging to maintain over time.

Here's an example of how the lending rules for book delivery in the online library system can be implemented in a more organized and scalable way using object-oriented programming principles

using System;
using System.Collections.Generic;

// Enum to represent the permitted locations
enum Location
{
    LocationA,
    LocationB,
    LocationC
}

// Class to represent a lender
class Lender
{
    public string Name { get; set; }
    public Location Location { get; set; }

    public Lender(string name, Location location)
    {
        Name = name;
        Location = location;
    }
}

// Class to represent the online library
class OnlineLibrary
{
    private List<Location> permittedLocations = new List<Location>
    {
        Location.LocationA,
        Location.LocationB,
        Location.LocationC
    };

    // Method to process book rental orders
    public void ProcessBookRental(Lender lender)
    {
        // Check if lender's location is permitted
        if (IsLocationPermitted(lender.Location))
        {
            // Process the book rental order
            Console.WriteLine($"Book rental order for {lender.Name} from {lender.Location} processed successfully.");
        }
        else
        {
            // Lender's location is not permitted
            Console.WriteLine($"Error: {lender.Name}'s location {lender.Location} is not permitted for book delivery.");
        }
    }

    // Method to check if a location is permitted
    private bool IsLocationPermitted(Location location)
    {
        return permittedLocations.Contains(location);
    }
}

class Program
{
    static void Main()
    {
        OnlineLibrary library = new OnlineLibrary();

        // Create lenders with different locations
        Lender lender1 = new Lender("Lender1", Location.LocationA);
        Lender lender2 = new Lender("Lender2", Location.LocationD);

        // Process book rental orders
        library.ProcessBookRental(lender1); // Output: Book rental order for Lender1 from LocationA processed successfully.
        library.ProcessBookRental(lender2); // Output: Error: Lender2's location LocationD is not permitted for book delivery.
    }
}

In this solution, the Lender class represents a lender with properties like Name and Location. The OnlineLibrary class encapsulates the logic for processing book rental orders, including the permitted locations and the method ProcessBookRental that takes a Lender object as input. The IsLocationPermitted method checks if a location is permitted based on the list of permitted locations. The code uses the Location enum to represent the permitted locations, which provides a scalable and extensible way to manage the locations.

The solution I have created above follows object-oriented programming principles, such as encapsulation, abstraction, and separation of concerns, which can make the codebase more organized, maintainable, and extensible. It also allows for easy modifications to the lending rules, such as adding or removing permitted locations, without needing to modify the code logic extensively.

Enough about that, I think you get the point. Let's have a look at how we should format our if statements in our code.

Basic If Statement Format

Syntax of a basic if statement in C#

In C#, a basic if statement follows the syntax:

if (condition)
{
    // Code to be executed if the condition is true
}

The condition is a boolean expression that determines whether the code block inside the if statement should be executed or not. If the condition evaluates to true, the code block will be executed; otherwise, it will be skipped.

Proper placement of parentheses, braces, and indentation

Proper placement of parentheses, braces, and indentation is essential for a well-formatted if statement in C#. Here are some best practices:

  1. Parentheses - The condition should be enclosed in parentheses ( ) immediately following the if keyword.
  2. Braces - The code block to be executed should be enclosed in curly braces { }. Even if the code block has only one statement, it is recommended to use braces to avoid potential issues with code maintenance and readability.
  3. Indentation - The code block inside the if statement should be indented with consistent spacing to visually separate it from the surrounding code.

Example of a properly formatted basic if statement

Here's an example of a properly formatted basic if statement in C#:

int age = 25;
if (age >= 18)
{
    Console.WriteLine("You are an adult.");
}

In the code example above, the condition age >= 18 is enclosed in parentheses, and the code block Console.WriteLine("You are an adult."); is enclosed in curly braces. The code block is indented with proper spacing for readability. Following these formatting practices ensures that the if statement is easy to read and understand, making the code more maintainable.

Nested If Statements

Nested if statements are if statements that are placed within another if statement's code block. They are used when multiple conditions need to be checked sequentially. Proper formatting of nested if statements are essential to ensure that the code remains readable and maintainable.

Syntax of nested if statements in C#

In C#, the syntax of a nested if statement is similar to a basic if statement, with additional levels of indentation for each nested level. Here's an example:

if (condition1)
{
    // Code block for condition1

    if (condition2)
    {
        // Code block for condition2

        if (condition3)
        {
            // Code block for condition3
        }
    }
}

Proper placement of parentheses, braces, and indentation

Proper placement of parentheses, braces, and indentation is crucial for well-formatted nested if statements. Here are some best practices:

  1. Parentheses - Each if statement should have its own set of parentheses for its condition, and they should be properly nested within each other.
  2. Braces - Each if statement should have its own set of curly braces { } for its code block, even if the code block has only one statement.
  3. Indentation - Each nested level of if statement should be indented with consistent spacing to visually separate it from the outer levels of if statements.

C. Example of properly formatted nested if statements Here's an example of properly formatted nested if statements in C#:

int num = 10;

if (num > 0)
{
    Console.WriteLine("Number is positive.");

    if (num > 5)
    {
        Console.WriteLine("Number is greater than 5.");

        if (num > 7)
        {
            Console.WriteLine("Number is greater than 7.");
        }
    }
}

In the code example above, we have three levels of nested if statements, each properly indented with consistent spacing and enclosed in their own set of parentheses and braces. Following these formatting practices ensures that the nested if statements are easy to read and understand, making the code more maintainable.

If-Else Statements

If-else statements are used when we want to execute different blocks of code based on whether a condition is true or false. Proper formatting of if-else statements is important to ensure that the code remains readable and understandable.

Syntax of if-else statements in C#

In C#, the syntax of an if-else statement is as follows:

if (condition)
{
    // Code block to be executed if the condition is true
}
else
{
    // Code block to be executed if the condition is false
}

The condition is a boolean expression that determines which code block should be executed. If the condition evaluates to true, the code block inside the if statement will be executed; otherwise, the code block inside the else block will be executed.

Proper placement of parentheses, braces, and indentation

Proper placement of parentheses, braces, and indentation is crucial for well-formatted if-else statements. Here are some best practices:

  1. Parentheses - The condition should be enclosed in parentheses immediately following the if keyword.
  2. Braces - Each code block (both the if block and the else block) should be enclosed in curly braces { }, even if the code block has only one statement.
  3. Indentation - Both the if block and the else block should be indented with consistent spacing to visually separate them from the surrounding code.

Example of properly formatted if-else statement

Here's an example of a properly formatted if-else statement in C#:

int age = 16;

if (age >= 18)
{
    Console.WriteLine("You are an adult.");
}
else
{
    Console.WriteLine("You are not an adult.");
}

In the code example, the condition age >= 18 is enclosed in parentheses, and the code blocks inside both the if and else blocks are enclosed in curly braces. The code blocks are indented with proper spacing for readability. Following these formatting practices ensures that the if-else statement is easy to read and understand, making the code more maintainable.

If-Else-If Statements

If-else if statements, also known as "else if" statements, are used when we have multiple conditions to check sequentially and execute different blocks of code based on which condition is true. Proper formatting of if-else-if statements is important to ensure the code remains readable and maintainable.

Syntax of if-else if statements in C#

In C#, the syntax of an if-else if statement is as follows:

if (condition1)
{
    // Code block to be executed if condition1 is true
}
else if (condition2)
{
    // Code block to be executed if condition1 is false and condition2 is true
}
else if (condition3)
{
    // Code block to be executed if condition1 and condition2 are false and condition3 is true
}
// More else if blocks can be added as needed
else
{
    // Code block to be executed if none of the above conditions are true
}

The conditions are boolean expressions that determine which code block should be executed. The else if blocks are optional, and you can have as many of them as needed.

Proper placement of parentheses, braces, and indentation

Proper placement of parentheses, braces, and indentation is crucial for well-formatted if-else if statements. Here are some best practices:

  1. Parentheses - Each condition should be enclosed in parentheses immediately following the if or else if keyword.
  2. Braces - Each code block (both the if and else if blocks) should be enclosed in curly braces { }, even if the code block has only one statement.
  3. Indentation - Both the if and else if blocks should be indented with consistent spacing to visually separate them from the surrounding code.

Example of properly formatted if-else if statement

Here's an example of a properly formatted if-else if statement in C#:

int score = 85;

if (score >= 90)
{
    Console.WriteLine("You got an A.");
}
else if (score >= 80)
{
    Console.WriteLine("You got a B.");
}
else if (score >= 70)
{
    Console.WriteLine("You got a C.");
}
else
{
    Console.WriteLine("You did not pass.");
}

In the code example above, we have multiple conditions to check using else if blocks, each properly indented with consistent spacing and enclosed in their own set of parentheses and braces. Following these formatting practices ensures that the if-else-if statement is easy to read and understand, making the code more maintainable.

Ternary Operators

Ternary operators, also known as conditional operators, are a concise way to write simple if-else statements in a single line of code. They can be useful when you need to assign a value to a variable based on a condition. Proper formatting of ternary operators is essential to ensure that the code remains readable and understandable.

Syntax of ternary operators in C#

In C#, the syntax of a ternary operator is as follows:

variable = (condition) ? valueIfTrue : valueIfFalse;

The condition is a boolean expression that is evaluated, and if it is true, valueIfTrue is assigned to the variable; otherwise, valueIfFalse is assigned.

Proper placement of parentheses and spacing

Proper placement of parentheses and spacing is crucial for well-formatted ternary operators. Here are some best practices:

  1. Parentheses: The condition should be enclosed in parentheses to clarify the order of evaluation, especially when combined with other operators.
  2. Spacing: There should be consistent spacing around the ternary operator to enhance readability. It's recommended to have a space before and after the ? and : operators.

Example of a properly formatted ternary operator

Here's an example of a properly formatted ternary operator in C#:

int age = 25;
string result = (age >= 18) ? "You are an adult" : "You are a minor";
Console.WriteLine(result);

In the code example above, we use a ternary operator to check if the age variable is greater than or equal to 18. If the condition is true, the string "You are an adult" is assigned to the result variable; otherwise, the string "You are a minor" is assigned. The ternary operator is properly enclosed in parentheses, and there are consistent spaces around the ? and : operators, making the code easy to read and understand.

Ternary operators can be a useful tool for writing concise and readable code in certain scenarios. However, it's important to use them judiciously and consider the readability and maintainability of the code, especially when dealing with complex conditions or multiple statements.

Best Practices for Formatting If Statements

Proper formatting of if statements is crucial for writing clean, readable, and maintainable code. Follow these best practices to ensure your if statements are well-formatted:

Use clear and descriptive variable and method names

Choosing descriptive variable and method names can significantly improve the readability of your if statements. Avoid generic names like x, y, or temp, and instead, use meaningful names that convey the purpose and meaning of the condition being checked. For example:

// Bad example
if (a < b)
{
    // ...
}

// Good example
if (speed < maxSpeed)
{
    // ...
}

Properly format the condition

The condition in the if statement should be written in a way that is easy to understand at a glance. Here are some best practices:

  1. Use parentheses - Always enclose the condition in parentheses to clarify the order of evaluation, especially when combining multiple conditions or using complex expressions.
  2. Avoid unnecessary negations - Instead of using != or ! operator to check for inequality, use the positive form of the condition. For example, use == instead of !=, and ! before the entire condition, not just one part of it.
// Bad example
if (!(x != y))
{
    // ...
}

// Good example
if (x == y)
{
    // ...
}

Properly format braces and indentation

The braces and indentation of your if statements play a crucial role in making your code readable and understandable. Here are some best practices:

  • Use braces for single-line and multi-line statements - Even though it's technically optional to use braces for single-line statements, it's recommended to always use them to avoid potential issues with future modifications.
// Bad example
if (x > y)
    Console.WriteLine("x is greater than y");

// Good example
if (x > y)
{
    Console.WriteLine("x is greater than y");
}
  • Indentation - Use consistent indentation to visually indicate the nesting level of your if statements. The standard indentation in C# is usually four spaces, but you can choose any indentation style that is consistent throughout your codebase.
// Bad example
if (condition1)
{
    if (condition2)
    {
    // ...
    }
}

// Good example
if (condition1)
{
    if (condition2)
    {
        // ...
    }
}

Keep if statements simple and concise

If statements should be kept simple and concise to improve the readability of the code. Avoid using complex conditions or multiple nested if statements, as they can make the code difficult to understand and maintain. If the condition or logic becomes too complex, consider refactoring the code into smaller, more manageable pieces.

// Bad example
if (a > b && c < d || e == f || !(g <= h))
{
    // ...
}

// Good example
bool condition1 = a > b;
bool condition2 = c < d;
bool condition3 = e == f;
bool condition4 = !(g <= h);

if (condition1 && condition2 || condition3 || condition4)
{
    // ...
}

Comment complex or non-obvious conditions

If you have complex or non-obvious conditions in your if statements, it's a good practice to add comments to explain the logic. This can help other developers, including your future self, to understand the purpose and meaning of the condition.

// Bad example
if (isAdministrator && (isOwner || hasPermission) && !isBlocked)
{
    // ...
}

// Good example
// Check if user is an administrator and has the necessary permissions
if (isAdministrator && (isOwner || hasPermission) && !isBlocked)
{
    // ...
}

Summary

Proper formatting of if statements in your code is essential for improving code readability, maintainability, and reducing the chances of introducing bugs. By following the best practices outlined in this blog post, you can ensure that your if statements are formatted in a clear and consistent manner.

In this blog post, I covered the basic syntax of if statements in C#, including the proper placement of parentheses, braces, and indentation. I also discussed nested if statements, if-else statements, if-else if statements, and ternary operators, along with their proper formatting.

Additionally, I highlighted common mistakes to avoid when formatting if statements, such as overusing nested if statements, omitting braces for single-line statements, not properly formatting conditions, ignoring indentation and inconsistent formatting, and not commenting on complex or non-obvious conditions.

Remember, writing code is not just about getting it to work, but also about making it readable and maintainable for yourself and other developers. Properly formatted if statements can greatly contribute to the overall quality of your codebase. By following best practices and avoiding common mistakes, you can write clean and readable code that is easy to understand and maintain.

I hope this blog post has provided you with valuable insights on how to properly format if statements in your C# code. By applying these principles in your development projects, you can enhance the quality of your code and become a more effective and efficient developer. Happy coding! ✌️