C# 理解适配器模式

Understanding Adapter Pattern

提问by pradeeptp

I am trying to understand Adapter pattern and its use in real world. After going through various articles on internet and www.dofactory.com, I created this sample code. I just want to know whether my understanding is correct. In the example below I have created MSDAO object in the Adaptor class. Later I changed it to OracleDAO.

我试图了解适配器模式及其在现实世界中的使用。在浏览了 Internet 和 www.dofactory.com 上的各种文章后，我创建了此示例代码。我只是想知道我的理解是否正确。在下面的示例中，我在 Adapter 类中创建了 MSDAO 对象。后来我把它改成了OracleDAO。

class Client
{
  static void Main(string[] args)
  {
    ITarget objAdapter = new Adapter();
    object dummyObject = objAdapter.GetData();
  }
}

Interface ITarget
{
  public void GetData();
}

//Decision to use MSDAO

class Adapter : ITarget
{
  public void GetData()
  {
    MSDAO objmsdao = new MSDAO();
    objmsdao.GetData();
  }
}

//After a month, the decision to use OracaleDAO was taken, so the code change

class Adapter : ITarget
{
  public void GetData()
  {
    OracleDAO objoracledao = new OracleDAO();
    objoracledao.GetData();
  }
}

采纳答案by tvanfosson

Generally the adapter pattern transforms one interface into another, but it can simply wrap the behavior to isolate your class from the underlying implementation. In your case, you are using an adapter, but you could just as easily have defined the DAO objects to simply implement the interface and programmed against the interface. The adapter pattern is usually used when you don't have control over the target class. My primary use of the adapter pattern would be to create wrappers for a framework class that doesn't implement an interface.

通常，适配器模式将一个接口转换为另一个接口，但它可以简单地包装行为以将您的类与底层实现隔离。在您的情况下，您使用的是适配器，但您可以轻松定义 DAO 对象以简单地实现接口并针对接口进行编程。当您无法控制目标类时，通常会使用适配器模式。我对适配器模式的主要用途是为没有实现接口的框架类创建包装器。

Say I want to mock out a framework class which doesn't implement an interface (and doesn't have virtual methods). With many mocking apis this is hard or impossible to do. What I will do, then, is define my own interface as a subset of the signature of the class I'm targeting. I implement a wrapper class that implements this interface and simply delegates the calls to the wrapped framework class. This wrapper class works as an adapter for the framework class. My classes use this adapter instead of the framework class, but get the framework class' behavior.

假设我想模拟一个没有实现接口（并且没有虚拟方法）的框架类。对于许多模拟 API，这很难或不可能做到。然后，我要做的是将我自己的接口定义为我所针对的类的签名的子集。我实现了一个包装类，它实现了这个接口，并简单地将调用委托给包装的框架类。这个包装类用作框架类的适配器。我的类使用此适配器而不是框架类，但获取框架类的行为。

 public interface IFoo
 {
     void Bar();
 }

 public class FooWrapper : IFoo
 {
      private FrameworkFoo Foo { get; set; }

      public FooWrapper( FrameworkFoo foo )
      {
           this.Foo = foo;
      }

      public void Bar()
      {
           this.Foo.Bar();
      }
 }

Consider also the case where you have a couple of different classes that have basically the same functionality, but different signatures and you want to be able to use them interchangeably. If you can't transform these (or don't want to for other reasons), you may want to write an adapter class that defines a common interface and translates between that interface's methods and the methods available on the target classes.

还要考虑这样一种情况：您有几个不同的类，它们具有基本相同的功能，但具有不同的签名，并且您希望能够互换使用它们。如果您不能转换这些（或由于其他原因不想转换），您可能需要编写一个适配器类来定义一个公共接口并在该接口的方法和目标类上可用的方法之间进行转换。

Framework classes:

框架类：

public class TargetA
{
    public void Start() { ... }
    public void End() { ... }
}

public class TargetB
{
    public void Begin() { ... }
    public void Terminate() { ... }
}

An adapter for them

他们的适配器

public interface ITargetAdapter
{
    void Open();
    void Close();
}

public class AdapterA : ITargetAdapter
{
     private TargetA A { get; set; }

     public AdapterA( TargetA a )
     {
           this.A = a;
     }

     public void Open() { this.A.Start(); }
     public void Close() { this.A.End(); }
}

public class AdapterB : ITargetAdapter
{
     private TargetB B { get; set; }

     public AdapterB( TargetB a )
     {
           this.B = a;
     }

     public void Open() { this.B.Begin(); }
     public void Close() { this.B.Terminate(); }
}

Then used as:

然后用作：

ITargetAdapter adapter = new AdapterA( new TargetA() );
adapter.Open();
adapter.Close();     

回答by Ian Boyd

A canonical example inside the .NET framework exists in the System.Drawing.Bitmapclass.

.NET 框架内的规范示例存在于System.Drawing.Bitmap该类中。

This Bitmap has a constructor that lets you load an image from a Stream:

此位图有一个构造函数，可让您从以下位置加载图像Stream：

public Bitmap(
    Stream stream
)

what you don't know, is that internally the .NET Bitmapclass is a wrapper around the GDI+ Bitmapclass, and its constructor that takes an IStream:

您不知道的是，.NETBitmap类在内部是 GDI+Bitmap类的包装器，其构造函数采用IStream：

Bitmap(
  [in]  IStream *stream,
  [in]  BOOL useIcm
);

So in the C# world, when i call:

所以在 C# 世界中，当我调用：

new Bitmap(stream);

it has to turn around and call:

它必须转身并调用：

IStream stm;
IntPtr gpBitmap;
GdipCreateBitmapFromStream(stm, out gpBitmap);

The question is how to present a .NET Streamobject to a method that expects a COM IStreaminterface.

问题是如何将 .NET Stream对象呈现给需要 COM IStream接口的方法。

Hence the internal GPStreamclass:

因此内部GPStream类：

internal class GPStream : IStream
{
   GPStream(Stream stream) { ... }
}

You need to present an IStreaminterface to your Streamobject:

您需要为IStream您的Stream对象提供一个接口：

IStream                                     Stream
=======================================     =====================================
int Read(IntPtr buf, int len);          --> int Read(byte[] buffer, int offset, int count)
int Write(IntPtr buf, int len);         --> void Write(byte[] buffer, int offset, int count);
long Seek(long dlibMove, int dwOrigin); --> long Seek(long offset, SeekOrigin orgin)
...                                         ...

So now you have an adapter:

所以现在你有一个适配器：

And the code is something like:

代码是这样的：

IStream stm = new GPStream(stream); //adapter to convert Stream --> IStream
IntPtr gpBitmap;

GdipCreateBitmapFromStream(stm, out gpBitmap);

回答by BKSpurgeon

I've added comments which will hopefully help you get your head around the whole adaptor/adaptee/client/Itarget jargon - which is a little confusing :

我已经添加了一些评论，希望能帮助您了解整个适配器/adaptee/client/Itarget 行话——这有点令人困惑：

internal class Program
{
    private static void Main(string[] args)
    {
        // Brian and freddie know only how to say Greetings. But when they tour
        // internationally, they will need a translator so when they say Greetings()
        // the appropriate non-English response comes out of their mouth.
        // they need to make use of the adapter pattern:

        // When in Japan:
        ITarget translator = new JapaneseTranslator(new JapaneseSpeaker());
        EnglishMan freddie = new EnglishMan(translator);

        // Freddie greets Tokyo, though he doesn't know a word of Japanese
        Console.WriteLine(freddie.Greetings()); //  "teo torriatte!"

        // when in France:
        ITarget translator2 = new FrenchTranslator(new FrenchSpeaker());
        EnglishMan brian = new EnglishMan(translator2);

        // Brian greets the crowd in Paris, though he doesn't know a word in French
        Console.WriteLine(brian.Greetings()); 
          // "So très charmant my dear! Bonjour"

        // alternatively, the translators can also do the greeting:
        Console.WriteLine(translator.Greetings());  //  "Konichiwa, hisashiburi!"
        Console.WriteLine(translator2.Greetings()); // "Bonjour!"
    }

    /// <summary>
    /// This is the client.
    /// </summary>
    public class EnglishMan : ITarget
    {
        private ITarget target;

        public EnglishMan(ITarget target)
        {
            this.target = target;
        }

        public string Greetings()
        {
            return target.Greetings();
        }
    }

    /// <summary>
    /// The target interface
    /// </summary>
    public interface ITarget
    {
        string Greetings();
    }

    /// <summary>
    /// This is the adaptor
    /// </summary>
    public class JapaneseTranslator : ITarget
    {
        private JapaneseSpeaker japanese;

        public JapaneseTranslator(JapaneseSpeaker japanese)
        {
            this.japanese = japanese;
        }

        public string Greetings()
        {
            return japanese.Konnichiwa();
        }
    }

    /// <summary>
    /// This is the adaptee
    /// </summary>
    public class JapaneseSpeaker
    {
        public JapaneseSpeaker()
        {
        }

        public string Konnichiwa()
        {
            return "Konichiwa, hisashiburi!";
        }
    }

    /// <summary>
    /// This is the adaptor
    /// </summary>
    public class FrenchTranslator : ITarget
    {
        private FrenchSpeaker french;

        public FrenchTranslator(FrenchSpeaker french)
        {
            this.french = french;
        }

        public string Greetings()
        {
            return french.Bonjour();
        }
    }

    /// <summary>
    /// This is the adaptee
    /// </summary>
    public class FrenchSpeaker
    {
        public string Bonjour()
        {
            return "Bonjour!!";
        }
    }
}

回答by Neeraj Singh Chouhan

A very simple example...

一个非常简单的例子...

 interface ITarget
    {
      List<string> GetProducts();
    }


    public class VendorAdaptee
    {
       public List<string> GetListOfProducts()
       {
          List<string> products = new List<string>();
          products.Add("Gaming Consoles");
          products.Add("Television");
          products.Add("Books");
          products.Add("Musical Instruments");
          return products;
       }
    }


    class VendorAdapter:ITarget
    {
       public List<string> GetProducts()
       {
          VendorAdaptee adaptee = new VendorAdaptee();
          return adaptee.GetListOfProducts();
       }
    }


    class ShoppingPortalClient
    {
       static void Main(string[] args)
       {
          ITarget adapter = new  VendorAdapter();
          foreach (string product in adapter.GetProducts())
          {
            Console.WriteLine(product);
          }
          Console.ReadLine();
       }
    }