Clean Code for .NET

Boolean flags in method parameters often indicate that a method has more than one responsibility. Instead of using a flag to toggle behavior, split the method into two distinct, single-purpose methods.

// Good: Split into two specific methods
public void CreateFile(string name)
{
    Touch(name);
}

public void CreateTempFile(string name)
{
    Touch("./temp/" + name);
}

The Dependency Inversion Principle states that high-level modules should not depend on low-level modules; both should depend on abstractions. Additionally, abstractions should not depend on details; details should depend on abstractions. In .NET, this is often implemented via Dependency Injection (DI) to reduce coupling between modules, making code easier to refactor.

public interface IEmployee
{
    void Work();
}

public class Human : IEmployee
{
    public void Work() { /* ... */ }
}

public class Robot : IEmployee
{
    public void Work() { /* ... */ }
}

public class Manager(IEnumerable<IEmployee> employees)
{
    public void Manage()
    {
        foreach (var employee in employees)
        {
            employee.Work();
        }
    }
}

Function names should clearly communicate their intent. Avoid vague names like Handle() when a more descriptive name like Send() or Process() would clarify what the function actually does.

// Good: Clear and obvious
public class Email
{
    public void Send()
    {
        SendMail(this._to, this._subject, this._body);
    }
}

var message = new Email(...);
message.Send();

Instead of using large switch statements or multiple if blocks to handle different types within a single function, use polymorphism. Define an interface and implement specific logic in separate classes for each type. This ensures each function does only one thing and adheres to the Single Responsibility Principle.

interface IAirplane
{
    double GetCruisingAltitude();
}

class Boeing777 : IAirplane
{
    public double GetCruisingAltitude() => GetMaxAltitude() - GetPassengerCount();
}

class AirForceOne : IAirplane
{
    public double GetCruisingAltitude() => GetMaxAltitude();
}

Function names should clearly state their purpose. Avoid vague names like Handle() when a more descriptive name like Send() or Process() better communicates the action being performed.

// Good: Clear and obvious
public class Email
{
    public void Send()
    {
        SendMail(this._to, this._subject, this._body);
    }
}

var message = new Email(...);
message.Send();

Boolean flags passed as parameters indicate that a function has more than one responsibility. Instead of using a flag to toggle behavior, split the function into two distinct, single-responsibility functions.

// Good: Split into two specific functions
public void CreateFile(string name)
{
    Touch(name);
}

public void CreateTempFile(string name)
{
    Touch("./temp/" + name);
}

The Open/Closed Principle states that software entities should be open for extension but closed for modification. You should be able to add new functionality without changing existing code. This is typically achieved by using interfaces or abstract classes instead of checking types or names (e.g., using if (adapterName == "...")) within a consumer class.

interface IAdapter
{
    bool Request(string url);
}

class AjaxAdapter : IAdapter
{
    public bool Request(string url)
    {
        // request and return promise
    }
}

class HttpRequester
{
    private readonly IAdapter Adapter;

    public HttpRequester(IAdapter adapter)
    {
        Adapter = adapter;
    }

    public bool Fetch(string url)
    {
        return Adapter.Request(url);
    }
}

Instead of manually checking if a parameter is null or empty to assign a default value inside the method body, use C# default parameter values in the method signature.

// Good
public void CreateMicrobrewery(string breweryName = "Hipster Brew Co.")
{
    // ...
}