设计模式网上资料整合理解——结构型模式（二）

适配器模式（Adapter）

意图：
      将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
结构图

      

图1 类的Adapter模式结构图

      

图2 对象的Adapter模式结构图

代码：

using System;

namespace DoFactory.GangOfFour.Adapter.Structural
{

  // Mainapp test application 

  class MainApp
  {
    static void Main()
    {
      // Create adapter and place a request 
      Target target = new Adapter();
      target.Request();

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

  // "Target" 

  class Target
  {
    public virtual void Request()
    {
      Console.WriteLine("Called Target Request()");
    }
  }

  // "Adapter" 

  class Adapter : Target
  {
    private Adaptee adaptee = new Adaptee();

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

  // "Adaptee" 

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

装饰模式（Decorator)   

意图：
      动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。[GOF 《设计模式》]
结构图：

      
生活中的例子：
      假想要制作一系列CoolButton，首先定义一个普通的Button（ConcreteComponent),定义一个Decorator类作为装饰Button的基类，然后从Decorator派生多个特定的Decorator（ConcreteDecoratorA），每个Decorator完成一种特定的装饰。（C#设计模式）
代码：

using System;

namespace DoFactory.GangOfFour.Decorator.Structural
{

  // MainApp test application 

  class MainApp
  {
    static void Main()
    {
      // Create ConcreteComponent and two Decorators 
      ConcreteComponent c = new ConcreteComponent();
      ConcreteDecoratorA d1 = new ConcreteDecoratorA();
      ConcreteDecoratorB d2 = new ConcreteDecoratorB();

      // Link decorators 
      d1.SetComponent(c);
      d2.SetComponent(d1);

      d2.Operation();

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

  // "Component" 

  abstract class Component
  {
    public abstract void Operation();
  }

  // "ConcreteComponent" 

  class ConcreteComponent : Component
  {
    public override void Operation()
    {
      Console.WriteLine("ConcreteComponent.Operation()");
    }
  }

  // "Decorator" 

  abstract class Decorator : Component
  {
    protected Component component;

    public void SetComponent(Component component)
    {
      this.component = component;
    }

    public override void Operation()
    {
      if (component != null)
      {
        component.Operation();
      }
    }
  }

  // "ConcreteDecoratorA" 

  class ConcreteDecoratorA : Decorator
  {
    private string addedState;

    public override void Operation()
    {
      base.Operation();
      addedState = "New State";
      Console.WriteLine("ConcreteDecoratorA.Operation()");
    }
  }

  // "ConcreteDecoratorB" 

  class ConcreteDecoratorB : Decorator
  {
    public override void Operation()
    {
      base.Operation();
      AddedBehavior();
      Console.WriteLine("ConcreteDecoratorB.Operation()");
    }

    void AddedBehavior()
    {
    }
  }
}

外观模式（Facade）

意图：
      为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。[GOF 《设计模式》]

示意图
      门面模式没有一个一般化的类图描述，下面是一个示意性的对象图：

图1 Façade模式示意性对象图

生活中的例子
      外观模式为子系统中的接口定义了一个统一的更高层次的界面，以便于使用。当消费者按照目录采购时，则体现了一个外观模式。消费者拨打一个号码与客服代表联系，客服代表则扮演了这个"外观"，他包含了与订货部、收银部和送货部的接口。

            图2使用电话订货例子的外观模式对象图
代码：

using System;

namespace DoFactory.GangOfFour.Facade.Structural
{

  // Mainapp test application 

  class MainApp
  {
    public static void Main()
    {
      Facade facade = new Facade();

      facade.MethodA();
      facade.MethodB();

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

  // "Subsystem ClassA" 

  class SubSystemOne
  {
    public void MethodOne()
    {
      Console.WriteLine(" SubSystemOne Method");
    }
  }

  // Subsystem ClassB" 

  class SubSystemTwo
  {
    public void MethodTwo()
    {
      Console.WriteLine(" SubSystemTwo Method");
    }
  }

  // Subsystem ClassC" 

  class SubSystemThree
  {
    public void MethodThree()
    {
      Console.WriteLine(" SubSystemThree Method");
    }
  }

  // Subsystem ClassD" 

  class SubSystemFour
  {
    public void MethodFour()
    {
      Console.WriteLine(" SubSystemFour Method");
    }
  }

  // "Facade" 

  class Facade
  {
    SubSystemOne one;
    SubSystemTwo two;
    SubSystemThree three;
    SubSystemFour four;

    public Facade()
    {
      one = new SubSystemOne();
      two = new SubSystemTwo();
      three = new SubSystemThree();
      four = new SubSystemFour();
    }

    public void MethodA()
    {
      Console.WriteLine("\nMethodA() ---- ");
      one.MethodOne();
      two.MethodTwo();
      four.MethodFour();
    }

    public void MethodB()
    {
      Console.WriteLine("\nMethodB() ---- ");
      two.MethodTwo();
      three.MethodThree();
    }
  }
}