Introduction to SOLID Principles in C#

Imagine you're building the most epic castle using C#. Each stone is a piece of your code, painstakingly placed to create something magnificent. But as your castle grows, you notice it starting to lean, cracks appearing in the walls with bugs living inside. That's where the SOLID principles come in - think of them as the master craftsmen of old, guiding you in the art of castle building. They teach you the secrets to constructing strong, resilient structures that stand the test of time.

Let's see what each letter represents.

S - Single Responsibility Principle (SRP)

The Single Responsibility Principle advocates that a class should have one reason to change. This principle simplifies maintenance and ensures that each class in a C# project has a clear purpose. For example, consider a C# class initially handling both user data management and user interface logic. By refactoring this into two classes, each with a single responsibility, we adhere to SRP, leading to cleaner, more modular code.

// Violates SRP
public class User
{
    public void AddUser(string userName)
    {
        // Add user to the database
    }

    public void SendEmail(string email)
    {
        // Send an email to the user
    }
}

// Adheres to SRP
public class User
{
    public void AddUser(string userName)
    {
        // Add user to the database
    }
}

public class EmailService
{
    public void SendEmail(string email)
    {
        // Send an email
    }
}

O - Open/Closed Principle (OCP)

The Open/Closed Principle is about extending functionality without modifying existing code. In C#, this can be achieved through the use of interfaces and abstract classes. By designing our classes to interact with interfaces or base classes, we can introduce new functionality by adding new classes that implement these interfaces without altering the existing classes.

// Violates OCP
public class ReportGenerator
{
    public void GenerateReport(string reportType)
    {
        if (reportType == "PDF")
        {
            // Generate PDF report
        }
        else if (reportType == "Excel")
        {
            // Generate Excel report
        }
    }
}

// Adheres to OCP
public abstract class ReportGenerator
{
    public abstract void GenerateReport();
}

public class PdfReportGenerator : ReportGenerator
{
    public override void GenerateReport()
    {
        // Generate PDF report
    }
}

public class ExcelReportGenerator : ReportGenerator
{
    public override void GenerateReport()
    {
        // Generate Excel report
    }
}

L - Liskov Substitution Principle (LSP)

This principle ensures that a subclass can stand in for its superclass without breaking the application. In C#, violating LSP can lead to unexpected behavior, especially when using polymorphism. A proper understanding of inheritance and interface implementation is crucial to adhere to LSP. Providing examples of LSP violations and corrections can help illustrate the importance of this principle.

// Violates LSP
public class Bird
{
    public virtual void Fly()
    {
        // Implementation to fly
    }
}

public class Ostrich : Bird
{
    public override void Fly()
    {
        throw new NotImplementedException("Ostriches cannot fly.");
    }
}

// Adheres to LSP
public abstract class Bird
{
}

public class FlyingBird : Bird
{
    public virtual void Fly()
    {
        // Implementation to fly
    }
}

public class Ostrich : Bird
{
    // Ostrich does not inherit Fly() method
}

I - Interface Segregation Principle (ISP)

The Interface Segregation Principle in C# encourages the creation of specific interfaces rather than general-purpose ones. This principle can be illustrated by refactoring a C# interface that serves multiple types of clients into multiple, more specific interfaces. Each client then only needs to know about the interface relevant to its needs, promoting cleaner, more focused class designs.

// Violates ISP
public interface IWorker
{
    void Work();
    void Eat();
}

public class HumanWorker : IWorker
{
    public void Work()
    {
        // Working
    }

    public void Eat()
    {
        // Eating in the break
    }
}

public class RobotWorker : IWorker
{
    public void Work()
    {
        // Working much more efficiently
    }

    public void Eat()
    {
        // Robots do not eat, so this method is not applicable
    }
}

// Adheres to ISP
public interface IWork
{
    void Work();
}

public interface IEat
{
    void Eat();
}

public class HumanWorker : IWork, IEat
{
    public void Work()
    {
        // Working
    }

    public void Eat()
    {
        // Eating in the break
    }
}

public class RobotWorker : IWork
{
    public void Work()
    {
        // Working much more efficiently
    }
}

D - Dependency Inversion Principle (DIP)

Dependency Inversion is fundamental in creating a flexible C# application architecture. By relying on abstractions rather than concrete implementations, C# developers can achieve a decoupled architecture. Demonstrating the use of dependency injection, perhaps through a popular C# library like Autofac, can provide practical insights into how DIP can be implemented in real-world projects.

// Violates DIP
public class User
{
    private SqlContext _context;

    public User(SqlContext context)
    {
        _context = context;
    }

    public void Add(string userName)
    {
        _context.AddUser(userName);
    }
}

// Adheres to DIP
public interface IContext
{
    void AddUser(string userName);
}

public class SqlContext : IContext
{
    public void AddUser(string userName)
    {
        // Add user to SQL database
    }
}

public class User
{
    private IContext _context;

    public User(IContext context)
    {
        _context = context;
    }

    public void Add(string userName)
    {
        _context.AddUser(userName);
    }
}

Conclusion

The SOLID principles offer a roadmap for building software that is robust, understandable, and adaptable. For C# developers, these principles are not just theoretical concepts but practical tools that, when applied, can significantly improve the quality of their code. As we continue to embrace these principles, we lay the groundwork for software that not only meets the needs of today but is also ready for the challenges of tomorrow. If you want to master the SOLID principles you can check out the course "From Zero to Hero: SOLID Principles for C# Developers". By buying this course you will learn how to use each principle based on many practical examples. Also, it has some added bonus at the end of the course.