Adapter pattern in C#

 Hello, C# lovers! 😍

Today, I want to talk about one of the most useful and versatile design patterns in C#: the Adapter pattern. 🙌

The Adapter pattern is a structural pattern that allows two incompatible interfaces to work together by providing a common interface between them. 🤝

This pattern is very helpful when you want to reuse some existing classes or libraries that have different interfaces than what your project expects. For example, you may want to use a third-party library that provides some functionality that you need, but its interface is different from the one you have defined in your project. Or, you may want to use some legacy code that has a different interface than the new code you are writing. 😊

The Adapter pattern solves this problem by introducing an additional class called the Adapter, which implements the expected interface and delegates the calls to the existing class. This way, you can use the existing class without changing its interface or modifying your code. 🙌

Let’s see how this pattern works with a simple example. Suppose you have an interface called ITarget that defines some methods that your project expects:


// The 'Target' interface
public interface ITarget
{
  void Request();
}


Now, suppose you have a class called Adaptee that provides some functionality that you want to use, but its interface is different from ITarget:


// The 'Adaptee' class
public class Adaptee
{
  public void SpecificRequest()
  {
    Console.WriteLine("Called SpecificRequest()");
  }
}


To use the Adaptee class in your project, you need to create an Adapter class that implements ITarget and wraps an instance of Adaptee:


// The 'Adapter' class
public class Adapter : ITarget
{
  private readonly Adaptee _adaptee = new Adaptee();

  public void Request()
  {
    // Possibly do some other work
    // and then call SpecificRequest
    _adaptee.SpecificRequest();
  }
}


Now, you can use the Adapter class as if it was an ITarget:


// The 'Client' class
public class Client
{
  static void Main(string[] args)
  {
    // Create adapter and place a request
    ITarget target = new Adapter();
    target.Request();

    // Wait for user
    Console.ReadKey();
  }
}


The output of this program is:


Called SpecificRequest()

As you can see, the Adapter pattern allows you to use the Adaptee class without changing its interface or modifying your code. You can also easily switch to a different Adaptee class by changing the Adapter implementation. 😎

The Adapter pattern is widely used in C# and .NET Framework. For example, the System.Data.IDataReader interface is an adapter for various data sources, such as SQL Server, Oracle, ODBC, etc. The System.IO.StreamReader and System.IO.StreamWriter classes are adapters for reading and writing text from different streams, such as files, network sockets, memory buffers, etc. The System.Collections.IEnumerator interface is an adapter for iterating over different collections, such as arrays, lists, dictionaries, etc. 😍

If you want to learn more about the Adapter pattern and see some real-world examples in C#, I recommend you to check out these resources:

I hope you enjoyed this article and learned something new about the Adapter pattern. If you have any questions or feedback, please leave a comment below. And don’t forget to share this article with your friends and colleagues who love C#. 😊


You can find the code examples here: source code


Stay tuned for more articles on C# design patterns. Happy coding! 😊

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! 😊 In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? 🤔 GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. 📚 These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. 😍 But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. 😮 So, which GOF patterns are good for C#?  Creational patterns...
Read more

Proxy pattern in C#

Hi! Today, I’m going to talk about the Proxy pattern and how it can be used in C# 😊. The Proxy pattern is a structural design pattern that provides a surrogate or placeholder for another object. A proxy controls access to the original object, allowing you to perform something either before or after the request gets through to the original object. Why would you want to use a proxy? Well, there are several reasons, such as: Lazy initialization : You can create a proxy to delay the creation of a heavy object until it’s actually needed. Remote access : You can create a proxy to represent a remote object and handle network communication behind the scenes. Access control : You can create a proxy to check the permissions of clients before allowing them to access the original object. Logging : You can create a proxy to log the requests and responses of the original object. In C#, you can implement the Proxy pattern by creating an interface that defines the common methods for both the original...
Read more

Bridge pattern in C#

  Hello, C# enthusiasts! 😍 Today, I want to share with you a very useful design pattern that can help you separate the business logic from the data access layer in your applications. This pattern is called the Bridge pattern, and it is one of the structural design patterns that deal with how classes and objects are composed to form larger structures. 🏗️ The Bridge pattern allows you to decouple an abstraction (such as an interface or an abstract class) from its implementation (such as a concrete class that implements the interface or inherits from the abstract class) so that the two can vary independently. This means that you can change the data access layer without affecting the business logic layer, and vice versa. 🙌 But why would you want to do that? Well, there are many scenarios where you might have more than one version of an abstraction, or more than one way of implementing an abstraction. For example, suppose you are developing a financial application that needs to perfo...
Read more