10 Essential Patterns For c# and .NET Programmers With Examples.

By using the Command pattern, we can decouple the object that sends a request from the object that receives and executes it, which makes the code more flexible and easier to maintain. In this example, the client does not need to know anything about the Car object, it only needs to know about the commands and the invoker.

6. Adapter Pattern

The Adapter pattern is used when we want to convert the interface of one class into the interface expected by another class. This pattern is useful when we have two classes that cannot communicate directly due to incompatible interfaces.

Here’s an example of the Adapter pattern in C#:

using System;

// The Target interface defines the operations that the client can perform.
public interface ITarget
{
    void Request();
}

// The Adaptee is the existing interface that needs to be adapted to the Target interface.
public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee: SpecificRequest called.");
    }
}

// The Adapter implements the Target interface and adapts the Adaptee to it.
public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public void Request()
    {
        _adaptee.SpecificRequest();
    }
}

// The Client interacts with the Target interface.
public class Client
{
    public void Main()
    {
        Adaptee adaptee = new Adaptee();
        ITarget target = new Adapter(adaptee);

        target.Request();
    }
}

In this example, we have defined an Adaptee class that has a method called SpecificRequest. We want to adapt this interface to a Target interface that has a method called Request. To do this, we have defined an Adapter class that implements the Target interface and adapts the Adaptee to it.

The Adapter constructor takes an Adaptee object as a parameter, and the Request method of the Adapter class calls the SpecificRequest method of the Adaptee object. This way, we can use the Adaptee object through the Adapter object as if it were a Target object.

We have also defined a Client class that creates an Adaptee object, creates an Adapter object with the Adaptee object as its parameter, and uses the Target interface to call the Request method of the Adapter object.

By using the Adapter pattern, we can adapt an existing interface to a new interface without changing the existing interface or the code that uses it. This allows us to reuse existing code and makes the code more flexible and easier to maintain.

Here’s another example of the Adapter pattern in C#:

using System;

// The Target interface defines the operations that the client can perform.
public interface ITarget
{
    void Send(string message);
}

// The Adaptee is the existing interface that needs to be adapted to the Target interface.
public class LegacyMessenger
{
    public void SendMessage(string message)
    {
        Console.WriteLine($"LegacyMessenger: Sending message '{message}'");
    }
}

// The Adapter implements the Target interface and adapts the Adaptee to it.
public class MessengerAdapter : ITarget
{
    private readonly LegacyMessenger _legacyMessenger;

    public MessengerAdapter(LegacyMessenger legacyMessenger)
    {
        _legacyMessenger = legacyMessenger;
    }

    public void Send(string message)
    {
        _legacyMessenger.SendMessage(message);
    }
}

// The Client interacts with the Target interface.
public class Client
{
    public void Main()
    {
        LegacyMessenger legacyMessenger = new LegacyMessenger();
        ITarget target = new MessengerAdapter(legacyMessenger);

        target.Send("Hello, world!");
    }
}

In this example, we have a LegacyMessenger class that has a method called SendMessage, and we want to adapt this interface to a Target interface that has a method called Send. We have defined a MessengerAdapter class that implements the Target interface and adapts the LegacyMessenger to it.

The MessengerAdapter constructor takes a LegacyMessenger object as a parameter, and the Send method of the MessengerAdapter class calls the SendMessage method of the LegacyMessenger object. This way, we can use the LegacyMessenger object through the MessengerAdapter object as if it were a Target object.

We have also defined a Client class that creates a LegacyMessenger object, creates a MessengerAdapter object with the LegacyMessenger object as its parameter, and uses the Target interface to call the Send method of the MessengerAdapter object.

By using the Adapter pattern, we can adapt an existing interface to a new interface without changing the existing interface or the code that uses it. This allows us to reuse existing code and makes the code more flexible and easier to maintain.

7. Strategy Pattern

The Strategy pattern is used when we want to encapsulate different algorithms and allow the client to choose which algorithm to use at runtime. This pattern is useful when we have multiple algorithms that can be used to solve a problem, and we want to select the appropriate algorithm based on a specific condition.

Here’s an example of the Strategy pattern in C#:

using System;

// The Strategy interface defines the operations that each strategy must implement.
public interface IStrategy
{
    void Execute(int[] data);
}

// The ConcreteStrategyA class implements a strategy that sorts an array in ascending order.
public class ConcreteStrategyA : IStrategy
{
    public void Execute(int[] data)
    {
        Array.Sort(data);
        Console.WriteLine("Sorted data in ascending order:");
        foreach (int item in data)
        {
            Console.Write($"{item} ");
        }
        Console.WriteLine();
    }
}

// The ConcreteStrategyB class implements a strategy that sorts an array in descending order.
public class ConcreteStrategyB : IStrategy
{
    public void Execute(int[] data)
    {
        Array.Sort(data);
        Array.Reverse(data);
        Console.WriteLine("Sorted data in descending order:");
        foreach (int item in data)
        {
            Console.Write($"{item} ");
        }
        Console.WriteLine();
    }
}

// The Context class maintains a reference to a Strategy object and provides an interface to interact with it.
public class Context
{
    private readonly IStrategy _strategy;

    public Context(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void SetStrategy(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void SortData(int[] data)
    {
        _strategy.Execute(data);
    }
}

// The Client interacts with the Context class to use a specific strategy.
public class Client
{
    public void Main()
    {
        int[] data = { 4, 2, 1, 5, 3 };

        Context context = new Context(new ConcreteStrategyA());
        context.SortData(data);

        context.SetStrategy(new ConcreteStrategyB());
        context.SortData(data);
    }
}

In this example, we have defined two strategies: ConcreteStrategyA and ConcreteStrategyB. ConcreteStrategyA sorts an array in ascending order, and ConcreteStrategyB sorts an array in descending order. Both strategies implement the IStrategy interface.

We have also defined a Context class that maintains a reference to a Strategy object and provides an interface to interact with it. The Context class has a method called SortData that calls the Execute method of the current strategy object.

We have defined a Client class that creates an array of integers, creates a Context object with a ConcreteStrategyA object as its parameter, and calls the SortData method of the Context object. We then set the strategy of the Context object to a ConcreteStrategyB object and call the SortData method again.

By using the Strategy pattern, we can encapsulate different algorithms and make them interchangeable without changing the code that uses them. This allows us to reuse existing code and makes the code more flexible and easier to maintain.

Here’s another example of the Strategy pattern in C#:

using System;

// The Strategy interface defines the operations that each strategy must implement.
public interface IShippingStrategy
{
    decimal CalculateShippingCost(decimal weight, decimal distance);
}

// The ConcreteStrategyA class implements a strategy for ground shipping.
public class GroundShippingStrategy : IShippingStrategy
{
    public decimal CalculateShippingCost(decimal weight, decimal distance)
    {
        decimal cost = 0;

        // Calculate shipping cost based on weight and distance for ground shipping
        // ...

        return cost;
    }
}

// The ConcreteStrategyB class implements a strategy for air shipping.
public class AirShippingStrategy : IShippingStrategy
{
    public decimal CalculateShippingCost(decimal weight, decimal distance)
    {
        decimal cost = 0;

        // Calculate shipping cost based on weight and distance for air shipping
        // ...

        return cost;
    }
}

// The Context class maintains a reference to a ShippingStrategy object and provides an interface to interact with it.
public class ShippingContext
{
    private readonly IShippingStrategy _shippingStrategy;

    public ShippingContext(IShippingStrategy shippingStrategy)
    {
        _shippingStrategy = shippingStrategy;
    }

    public void SetShippingStrategy(IShippingStrategy shippingStrategy)
    {
        _shippingStrategy = shippingStrategy;
    }

    public decimal CalculateShippingCost(decimal weight, decimal distance)
    {
        return _shippingStrategy.CalculateShippingCost(weight, distance);
    }
}

// The Client interacts with the ShippingContext class to calculate the shipping cost using a specific strategy.
public class Client
{
    public void Main()
    {
        decimal weight = 10;
        decimal distance = 100;

        ShippingContext context = new ShippingContext(new GroundShippingStrategy());
        decimal groundShippingCost = context.CalculateShippingCost(weight, distance);

        context.SetShippingStrategy(new AirShippingStrategy());
        decimal airShippingCost = context.CalculateShippingCost(weight, distance);

        Console.WriteLine($"Ground shipping cost: {groundShippingCost}");
        Console.WriteLine($"Air shipping cost: {airShippingCost}");
    }
}

In this example, we have defined two strategies: GroundShippingStrategy and AirShippingStrategy. GroundShippingStrategy calculates the shipping cost for ground shipping based on weight and distance, and AirShippingStrategy calculates the shipping cost for air shipping based on weight and distance. Both strategies implement the IShippingStrategy interface.

We have also defined a ShippingContext class that maintains a reference to a ShippingStrategy object and provides an interface to interact with it. The ShippingContext class has a method called CalculateShippingCost that calls the CalculateShippingCost method of the current strategy object.

We have defined a Client class that creates two decimal variables, creates a ShippingContext object with a GroundShippingStrategy object as its parameter, and calls the CalculateShippingCost method of the ShippingContext object with the two decimal variables as parameters. We then set the strategy of the ShippingContext object to an AirShippingStrategy object and call the CalculateShippingCost method again with the same decimal variables.

By using the Strategy pattern, we can encapsulate different algorithms for calculating the shipping cost and make them interchangeable without changing the code that uses them. This allows us to reuse existing code and makes the code more flexible and easier to maintain.

8. Template Method Pattern

The Template Method pattern is used when we want to define the outline of an algorithm in a base class and allow the derived classes to implement the details. This pattern is useful when we have a set of steps that need to be followed in a specific order, but some of the steps can be implemented in different ways.

Here’s an example of the Template Method pattern in C#:

using System;

// The AbstractClass defines the template method that contains a series of method calls that define the algorithm.
public abstract class AbstractClass
{
    public void TemplateMethod()
    {
        Operation1();
        Operation2();
        Operation3();
    }

    // The primitive operations are abstract methods that must be implemented by the subclasses.
    protected abstract void Operation1();
    protected abstract void Operation2();

    // The hook operation is an optional method that can be overridden by the subclasses.
    protected virtual void Operation3()
    {
        Console.WriteLine("AbstractClass.Operation3() called");
    }
}

// The ConcreteClassA implements the primitive operations to carry out the algorithm defined in the AbstractClass.
public class ConcreteClassA : AbstractClass
{
    protected override void Operation1()
    {
        Console.WriteLine("ConcreteClassA.Operation1() called");
    }

    protected override void Operation2()
    {
        Console.WriteLine("ConcreteClassA.Operation2() called");
    }
}

// The ConcreteClassB implements the primitive operations to carry out a different algorithm defined in the AbstractClass.
public class ConcreteClassB : AbstractClass
{
    protected override void Operation1()
    {
        Console.WriteLine("ConcreteClassB.Operation1() called");
    }

    protected override void Operation2()
    {
        Console.WriteLine("ConcreteClassB.Operation2() called");
    }

    protected override void Operation3()
    {
        Console.WriteLine("ConcreteClassB.Operation3() called");
    }
}

// The Client uses the TemplateMethod to carry out the algorithm defined in the AbstractClass using a ConcreteClass object.
public class Client
{
    public void Main()
    {
        AbstractClass abstractClass = new ConcreteClassA();
        abstractClass.TemplateMethod();

        Console.WriteLine();

        abstractClass = new ConcreteClassB();
        abstractClass.TemplateMethod();
    }
}

In this example, we have defined an abstract class that defines a template method called TemplateMethod. TemplateMethod contains a series of method calls that define the algorithm. We have also defined two primitive operations, Operation1 and Operation2, that must be implemented by the subclasses, and a hook operation, Operation3, that is an optional method that can be overridden by the subclasses.

We have defined two concrete classes, ConcreteClassA and ConcreteClassB, that implement the primitive operations to carry out different algorithms defined in the AbstractClass.

We have also defined a Client class that creates an AbstractClass object using a ConcreteClassA object and calls the TemplateMethod to carry out the algorithm defined in the AbstractClass. We then create an AbstractClass object using a ConcreteClassB object and call the TemplateMethod again to carry out a different algorithm defined in the AbstractClass.

By using the Template Method pattern, we can define the skeleton of an algorithm in a base class and let the subclasses implement the details of the algorithm by implementing the primitive operations. This allows us to reuse existing code and makes the code more flexible and easier to maintain.

Another example of the Template Method pattern applied to a user model in C#:

using System;

// The AbstractUser class defines a template method called AuthenticateUser that contains a series of method calls that define the authentication process.
public abstract class AbstractUser
{
    public void AuthenticateUser(string username, string password)
    {
        if (IsValidUsername(username))
        {
            if (IsValidPassword(password))
            {
                Console.WriteLine($"User {username} authenticated successfully.");
            }
            else
            {
                Console.WriteLine($"Invalid password for user {username}.");
            }
        }
        else
        {
            Console.WriteLine($"Invalid username: {username}.");
        }
    }

    // The IsValidUsername and IsValidPassword methods are abstract methods that must be implemented by the subclasses.
    protected abstract bool IsValidUsername(string username);
    protected abstract bool IsValidPassword(string password);
}

// The BasicUser class implements the IsValidUsername and IsValidPassword methods to define the authentication process for basic users.
public class BasicUser : AbstractUser
{
    protected override bool IsValidUsername(string username)
    {
        // Basic users have usernames that are between 5 and 10 characters long.
        return username.Length >= 5 && username.Length <= 10;
    }

    protected override bool IsValidPassword(string password)
    {
        // Basic users have passwords that are at least 8 characters long.
        return password.Length >= 8;
    }
}

// The AdminUser class implements the IsValidUsername and IsValidPassword methods to define the authentication process for admin users.
public class AdminUser : AbstractUser
{
    protected override bool IsValidUsername(string username)
    {
        // Admin users have usernames that are between 8 and 15 characters long and start with "admin_".
        return username.StartsWith("admin_") && username.Length >= 8 && username.Length <= 15;
    }

    protected override bool IsValidPassword(string password)
    {
        // Admin users have passwords that are at least 10 characters long and contain at least one digit and one uppercase letter.
        bool hasDigit = false;
        bool hasUppercase = false;

        foreach (char c in password)
        {
            if (Char.IsDigit(c))
            {
                hasDigit = true;
            }
            else if (Char.IsUpper(c))
            {
                hasUppercase = true;
            }

            if (hasDigit && hasUppercase)
            {
                return true;
            }
        }

        return false;
    }
}

// The Client uses the AuthenticateUser method to authenticate a user.
public class Client
{
    public void Main()
    {
        AbstractUser basicUser = new BasicUser();
        basicUser.AuthenticateUser("johndoe", "password123");

        Console.WriteLine();

        AbstractUser adminUser = new AdminUser();
        adminUser.AuthenticateUser("admin_jane", "Password123");
    }
}

In this example, we have defined an AbstractUser class that defines a template method called AuthenticateUser that contains a series of method calls that define the authentication process. We have also defined two abstract methods, IsValidUsername and IsValidPassword, that must be implemented by the subclasses to define the validation rules for usernames and passwords.

We have defined two concrete classes, BasicUser and AdminUser, that implement the IsValidUsername and IsValidPassword methods to define the authentication process for basic users and admin users, respectively.

We have also defined a Client class that creates a BasicUser object and an AdminUser object and calls the AuthenticateUser method to authenticate the users using their usernames and passwords. The authentication process is defined by the template method in the AbstractUser class, which calls the IsValidUsername and IsValidPassword methods in the concrete classes to validate the input.

By using the Template Method pattern, we can encapsulate the common authentication process in the AbstractUser class and allow the concrete subclasses to define their own validation rules for usernames and passwords.

In this example, the BasicUser class defines validation rules that require a username to be between 5 and 10 characters long and a password to be at least 8 characters long. The AdminUser class defines validation rules that require a username to start with “admin_”, be between 8 and 15 characters long, and a password to be at least 10 characters long and contain at least one digit and one uppercase letter.

This approach allows us to reuse the common authentication process across multiple user types while still allowing each user type to have its own specific validation rules. It also makes it easy to add new user types in the future by simply creating a new concrete subclass that implements the IsValidUsername and IsValidPassword methods.

Overall, the Template Method pattern is a useful pattern for situations where we want to define a common algorithm or process that can be customized by subclasses while still maintaining the same basic structure.

9. State Pattern

The State pattern is used when we want to change the behavior of an object based on its state. This pattern is useful when we have an object that can be in multiple states, and we want to define the behavior of the object based on its state.

The State pattern is a behavioral design pattern that allows an object to change its behavior when its internal state changes. It does this by encapsulating each possible state of an object as a separate class that implements a common interface. When the object’s state changes, it switches to a new state class, which then defines its behavior.

One example of the State pattern in C# is a traffic light controller. In this example, we’ll create a TrafficLight class that can be in one of three states: Red, Yellow, or Green. Each state will be represented by a separate class that implements the ITrafficLightState interface.

Here’s how the TrafficLight class might look:

public class TrafficLight
{
    private ITrafficLightState currentState;

    public TrafficLight()
    {
        currentState = new RedState();
    }

    public void ChangeState(ITrafficLightState newState)
    {
        currentState = newState;
    }

    public void Request()
    {
        currentState.HandleRequest(this);
    }
}

The TrafficLight class has a currentState field that holds the current state of the traffic light. It has a constructor that initializes the state to Red, and two methods: ChangeState, which allows the state to be changed, and Request, which delegates the request to the current state.

Next, we’ll create the ITrafficLightState interface, which defines the methods that each state class must implement:

public interface ITrafficLightState
{
    void HandleRequest(TrafficLight light);
}

Each state class will implement this interface and define its own implementation of the HandleRequest method.

Here’s an example of the RedState class:

public class RedState : ITrafficLightState
{
    public void HandleRequest(TrafficLight light)
    {
        Console.WriteLine("Traffic light is red");
        light.ChangeState(new GreenState());
    }
}

The RedState class implements the HandleRequest method by printing out that the traffic light is red and then changing the state to GreenState.

Here’s an example of the GreenState class:

public class GreenState : ITrafficLightState
{
    public void HandleRequest(TrafficLight light)
    {
        Console.WriteLine("Traffic light is green");
        light.ChangeState(new YellowState());
    }
}

The GreenState class implements the HandleRequest method by printing out that the traffic light is green and then changing the state to YellowState.

Finally, here’s an example of the YellowState class:

public class YellowState : ITrafficLightState
{
    public void HandleRequest(TrafficLight light)
    {
        Console.WriteLine("Traffic light is yellow");
        light.ChangeState(new RedState());
    }
}

The YellowState class implements the HandleRequest method by printing out that the traffic light is yellow and then changing the state to RedState.

With this implementation, we can create a TrafficLight object and change its state by calling its ChangeState method. When we call the Request method, it will delegate the request to the current state, which will handle it based on its specific behavior. This allows us to easily implement a traffic light controller that changes its behavior based on its internal state.

Another example of the State pattern in C# is a video player that can be in one of three states: Playing, Paused, or Stopped. Each state will be represented by a separate class that implements the IVideoPlayerState interface.

Here’s how the VideoPlayer class might look:

public class VideoPlayer
{
    private IVideoPlayerState currentState;
    private string currentVideo;

    public VideoPlayer()
    {
        currentState = new StoppedState();
    }

    public void ChangeState(IVideoPlayerState newState)
    {
        currentState = newState;
    }

    public void Play(string video)
    {
        currentVideo = video;
        currentState.Play(this);
    }

    public void Pause()
    {
        currentState.Pause(this);
    }

    public void Stop()
    {
        currentState.Stop(this);
    }

    public string GetCurrentVideo()
    {
        return currentVideo;
    }
}

The VideoPlayer class has a currentState field that holds the current state of the video player. It has a constructor that initializes the state to Stopped, and four methods: ChangeState, which allows the state to be changed, Play, which starts playing a video, Pause, which pauses the currently playing video, Stop, which stops the currently playing video, and GetCurrentVideo, which returns the name of the currently playing video.

Next, we’ll create the IVideoPlayerState interface, which defines the methods that each state class must implement:

public interface IVideoPlayerState
{
    void Play(VideoPlayer player);
    void Pause(VideoPlayer player);
    void Stop(VideoPlayer player);
}
//Each state class will implement this interface and define its own implementation of the Play, Pause, and Stop methods.

//Here's an example of the PlayingState class:
public class PlayingState : IVideoPlayerState
{
    public void Play(VideoPlayer player)
    {
        Console.WriteLine("Video is already playing");
    }

    public void Pause(VideoPlayer player)
    {
        Console.WriteLine("Pausing video");
        player.ChangeState(new PausedState());
    }

    public void Stop(VideoPlayer player)
    {
        Console.WriteLine("Stopping video");
        player.ChangeState(new StoppedState());
    }
}

The PlayingState class implements the Play, Pause, and Stop methods. When the Play method is called, it prints out that the video is already playing. When the Pause method is called, it prints out that it is pausing the video and changes the state to PausedState. When the Stop method is called, it prints out that it is stopping the video and changes the state to StoppedState.

Here’s an example of the PausedState class:

public class PausedState : IVideoPlayerState
{
    public void Play(VideoPlayer player)
    {
        Console.WriteLine("Resuming video");
        player.ChangeState(new PlayingState());
    }

    public void Pause(VideoPlayer player)
    {
        Console.WriteLine("Video is already paused");
    }

    public void Stop(VideoPlayer player)
    {
        Console.WriteLine("Stopping video");
        player.ChangeState(new StoppedState());
    }
}

10. Facade Pattern

The Facade pattern is used when we want to provide a simplified interface to a complex system. This pattern is useful when we have a complex system that consists of multiple subsystems, and we want to provide a simple interface to the client.

The Facade pattern is a structural design pattern that provides a simple interface to a complex system of classes, making it easier to use. It is often used to simplify the use of a library or framework by providing a high-level interface that abstracts away the details of the underlying implementation.

Let’s take an example of a car engine. A car engine consists of many complex parts such as the piston, crankshaft, cylinder, fuel injection system, and so on. To start the engine, you need to follow a complex set of steps such as turning the key in the ignition, pressing the accelerator pedal, and so on. The Facade pattern can be used to simplify the process of starting the engine by providing a simple interface that abstracts away the details of the underlying implementation.

In this example, we will create a CarEngineFacade class that provides a simple interface for starting and stopping the engine. The CarEngineFacade class will internally use the complex system of classes to start and stop the engine.

// Complex system of classes
class Piston
{
    public void Move() { /* Move piston */ }
}

class Crankshaft
{
    public void Rotate() { /* Rotate crankshaft */ }
}

class FuelInjectionSystem
{
    public void InjectFuel() { /* Inject fuel */ }
}

// Facade class
class CarEngineFacade
{
    private readonly Piston piston;
    private readonly Crankshaft crankshaft;
    private readonly FuelInjectionSystem fuelInjectionSystem;

    public CarEngineFacade()
    {
        piston = new Piston();
        crankshaft = new Crankshaft();
        fuelInjectionSystem = new FuelInjectionSystem();
    }

    public void Start()
    {
        piston.Move();
        crankshaft.Rotate();
        fuelInjectionSystem.InjectFuel();
        Console.WriteLine("Engine started");
    }

    public void Stop()
    {
        Console.WriteLine("Stopping engine");
    }
}

In the above code, we have created a CarEngineFacade class that provides a Start method to start the engine and a Stop method to stop the engine. The CarEngineFacade class internally uses the complex system of classes such as Piston, Crankshaft, and FuelInjectionSystem to start and stop the engine.

To start the engine using the CarEngineFacade class, we can do:

CarEngineFacade engine = new CarEngineFacade();
engine.Start();

This will print out “Engine started” and internally start the engine by moving the piston, rotating the crankshaft, and injecting fuel using the FuelInjectionSystem.

To stop the engine, we can do:

engine.Stop();

This will print out “Stopping engine”.

Overall, the Facade pattern is useful when you want to simplify the use of a complex system of classes by providing a simple interface that abstracts away the details of the underlying implementation. By encapsulating the complexity of the system behind a simple facade, the Facade pattern can help make your code more modular and easier to maintain.

In conclusion, these ten essential patterns are crucial for C# and .NET programmers to master. Design patterns help in creating code that is maintainable, scalable, and efficient. By understanding and implementing these patterns, you can create high-quality software that meets the requirements of your clients and end-users.