3 Tips To Reduce Cyclomatic Complexity In C#

Complexity of 8 (1 for each CASE and 1 for method itself).

public void MethodDay(DayOfWeek day)  
{
    switch (day)  
    {  
        case DayOfWeek.Monday:  
            Console.WriteLine("Today is Monday!");  
            break;  
        case DayOfWeek.Tuesday:  
            Console.WriteLine("Today is Tuesday!");  
            break;  
        case DayOfWeek.Wednesday:  
            Console.WriteLine("Today is Wednesday!");  
            break;  
        case DayOfWeek.Thursday:  
            Console.WriteLine("Today is Thursday!");  
            break;  
        case DayOfWeek.Friday:  
            Console.WriteLine("Today is Friday!");  
            break;  
        case DayOfWeek.Saturday:  
            Console.WriteLine("Today is Saturday!");  
            break;  
        case DayOfWeek.Sunday:  
            Console.WriteLine("Today is Sunday!");  
            break;  
    }  
}

Refactoring using Factory design pattern and complexity changed to 1.

public void MethodDayReduce(DayOfWeek day)  
{  
    var factory = Activator.CreateInstance(Type.GetType($"{day.ToString()}DayFactory")) as IDayFactory;  
    factory.Write();  
}  
   
public interface IDayFactory  
{  
    void Write();  
}  
   
public class MondayDayFactory : IDayFactory  
{  
    public void Write()  
    {  
        Console.WriteLine("Today is Monday!");  
    }  
}

Tip #2 – IF Expressions

Reduce IF expressions in your code. Use the Single Responsibility principle for extracting a piece of code to other methods and make the method for just one responsibility. That change will reduce Cyclomatic Responsibility and improve maintainability for your code.

Original code

Complexity of 4 (1 for each expression and 1 for method itself).

public void Method(bool condition1, bool condition2)  
{  
    if (condition1 || condition2 && (!condition1))  
    {  
        Console.WriteLine("Hello World!");  
    }  
}

Refactoring to complexity of 2,

public void MethodReduce(bool condition1, bool condition2)  
{  
    var negative = (!condition1);  
    condition2 = condition2 && negative;  
    condition2 = condition2 || condition1;  
    if (condition2)  
    {  
        Console.WriteLine("Hello World!");  
    }  
}

Tip #3 – BE COOL

Don't kill yourself because of Cyclomatic Complexity.

It’s better to keep your code simple and follow single responsibility principles than refactoring all your code making it hard to understand.

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” Martin Fowler.

Adopt an acceptable metric of CC for your business and your daily life. This article is a guide for you, not a rule.

And about performance?

Can Cyclomatic Complexity affect the performance of an application? The answer is Yes and No. It will affect performance if the complexity value is more than 50 and still depends on the kind of commands you are using. You will need to run a performance benchmark in your code to check that.

I would say to you: Relax!

So, do you I need to reduce Cyclomatic Complexity?

Of course! Who likes to read a source code with a lot of chaining IF and SWITCH/CASE statements? Applying Cyclomatic Complexity reduces the use of those commands, helps maintainability and still you use design patterns! Isn’t that cool?

After reading this article, you should have no issues writing better code, right?

Thank you and good luck!