Menu
Article Design Patterns

Bridging the Gap: A Comprehensive Guide to the Adapter Pattern in C#

Casper

Casper

• 3 min read

The Adapter Pattern is a structural design pattern that allows incompatible interfaces to work together. It acts as a bridge between two incompatible interfaces by converting the interface of a class into another interface that a client expects. This pattern is particularly useful when integrating new features or components into an existing system without modifying its core structure. In this article, we will explore the Adapter Pattern in-depth, examining its structure, advantages, and providing practical examples in C#.

Understanding the Adapter Pattern

The Adapter Pattern involves the following key components:

  1. Target: The interface that the client code expects or relies on.
  2. Adaptee: The existing class or interface that needs to be adapted to meet the client's expectations.
  3. Adapter: The class that bridges the gap between the Target and the Adaptee. It implements the Target interface and delegates the actual implementation to the Adaptee.

Implementation in C#

Let's delve into a simple example of the Adapter Pattern in C#. Suppose we have an existing LegacyPrinter class that prints messages, and we want to adapt it to a new Printer interface that the client code expects.

// Step 1: Define the Target interface
public interface IPrinter
{
    void Print(string message);
}

// Step 2: Implement the Adaptee (existing class)
public class LegacyPrinter
{
    public void PrintMessage(string message)
    {
        Console.WriteLine($"Legacy Printer: {message}");
    }
}

// Step 3: Implement the Adapter class
public class LegacyPrinterAdapter : IPrinter
{
    private readonly LegacyPrinter _legacyPrinter;

    public LegacyPrinterAdapter(LegacyPrinter legacyPrinter)
    {
        _legacyPrinter = legacyPrinter;
    }

    public void Print(string message)
    {
        _legacyPrinter.PrintMessage(message);
    }
}

In this example, IPrinter is the target interface that the client code expects. LegacyPrinter is the existing class (adaptee) with a method PrintMessage. The LegacyPrinterAdapter is the adapter class that implements the IPrinter interface and delegates the actual printing to the LegacyPrinter class.

Advantages of the Adapter Pattern

1. Reusability: The Adapter Pattern allows the reuse of existing classes or components that have incompatible interfaces, making it easier to integrate new features into existing systems.

2. Flexibility: Adapters provide a flexible way to adapt existing code without modifying its core structure. This promotes the open/closed principle by allowing extension without modification.

3. Interoperability: The pattern enhances interoperability by allowing components with different interfaces to work together seamlessly.

4. Maintainability: Adapters encapsulate the details of adapting an interface, making it easier to maintain and update the code when changes are required.

Real-world Examples

1. Database Adapters

Consider a scenario where a system is designed to work with a specific database library, and a new database library with a different interface needs to be integrated. The Adapter Pattern can be applied to create a database adapter that converts the new library's interface into the interface expected by the existing system.

// Target interface
public interface IDatabaseAdapter
{
    void Connect();
    void ExecuteQuery(string query);
}

// Adaptee (existing class with a different interface)
public class NewDatabase
{
    public void EstablishConnection()
    {
        // Connect to the new database
    }

    public void ExecuteCommand(string command)
    {
        // Execute a command in the new database
    }
}

// Adapter class
public class NewDatabaseAdapter : IDatabaseAdapter
{
    private readonly NewDatabase _newDatabase;

    public NewDatabaseAdapter(NewDatabase newDatabase)
    {
        _newDatabase = newDatabase;
    }

    public void Connect()
    {
        _newDatabase.EstablishConnection();
    }

    public void ExecuteQuery(string query)
    {
        _newDatabase.ExecuteCommand(query);
    }
}

2. Logging Adapters

In a logging system, different logging libraries may have distinct interfaces. The Adapter Pattern can be employed to create adapters for various logging libraries, allowing the system to switch between different logging implementations without modifying the core logging code.

// Target interface
public interface ILogger
{
    void LogMessage(string message);
}

// Adaptee (existing class with a different interface)
public class ThirdPartyLogger
{
    public void Log(string info)
    {
        // Log information using the third-party logging library
    }
}

// Adapter class
public class ThirdPartyLoggerAdapter : ILogger
{
    private readonly ThirdPartyLogger _thirdPartyLogger;

    public ThirdPartyLoggerAdapter(ThirdPartyLogger thirdPartyLogger)
    {
        _thirdPartyLogger = thirdPartyLogger;
    }

    public void LogMessage(string message)
    {
        _thirdPartyLogger.Log(message);
    }
}

Conclusion

The Adapter Pattern is a versatile solution for bridging the gap between incompatible interfaces, allowing for greater reusability, flexibility, and interoperability. Through practical examples in C#, we have demonstrated how the Adapter Pattern can be applied to real-world scenarios, providing a blueprint for creating systems that can seamlessly integrate new components or features without disrupting existing code. Understanding and incorporating this pattern into your design practices can contribute to building modular, maintainable, and extensible software architectures, facilitating the smooth collaboration of diverse components within a system.

Share