23种设计模式UML类图及对应示例代码

605940864 贡献于2012-02-12

作者 china  创建于2011-10-13 14:21:00   修改者微软用户  修改于2011-10-13 14:21:00字数29437

文档摘要:23种设计模式UML类图及对应示例代码
关键词:

  23种设计模式 UML 类图及对应示例代码 (一) 收藏 1.DoFactory.GangOfFour.Abstract.Structural       Abstract Factory:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。     工厂模式:客户类和工厂类分开。消费者任何时候需要某种产品,只需向工厂请求即可。 消费者无须修改就可以接纳新产品。缺点是当产品修改时,工厂类也要做相应的修改。如:如何创建及如何向客户端提供。 using System; namespace DoFactory.GangOfFour.Abstract.Structural {     ///      /// MainApp startup class for Structural     /// Abstract Factory Design Pattern.     ///      class MainApp     {          ///          /// Entry point into console application.         ///          public static void Main()         {             // Abstract factory #1             AbstractFactory factory1 = new ConcreteFactory1();             Client client1 = new Client(factory1);             client1.Run();             // Abstract factory #2             AbstractFactory factory2 = new ConcreteFactory2();             Client client2 = new Client(factory2);             client2.Run();             // Wait for user input             Console.Read();         }     }     // "AbstractFactory"     abstract class AbstractFactory     {         public abstract AbstractProductA CreateProductA();         public abstract AbstractProductB CreateProductB();     }     // "ConcreteFactory1"     class ConcreteFactory1 : AbstractFactory     {         public override AbstractProductA CreateProductA()         {             return new ProductA1();         }         public override AbstractProductB CreateProductB()         {             return new ProductB1();         }     }     // "ConcreteFactory2"     class ConcreteFactory2 : AbstractFactory     {         public override AbstractProductA CreateProductA()         {             return new ProductA2();         }         public override AbstractProductB CreateProductB()         {             return new ProductB2();         }     }     // "AbstractProductA"     abstract class AbstractProductA     {     }     // "AbstractProductB"     abstract class AbstractProductB     {         public abstract void Interact(AbstractProductA a);     }     // "ProductA1"     class ProductA1 : AbstractProductA     {     }     // "ProductB1"     class ProductB1 : AbstractProductB     {         public override void Interact(AbstractProductA a)         {             Console.WriteLine(this.GetType().Name +                  " interacts with " + a.GetType().Name);         }     }     // "ProductA2"     class ProductA2 : AbstractProductA     {     }     // "ProductB2"     class ProductB2 : AbstractProductB     {         public override void Interact(AbstractProductA a)         {             Console.WriteLine(this.GetType().Name +                  " interacts with " + a.GetType().Name);         }     }     // "Client" - the interaction environment of the products     class Client     {         private AbstractProductA AbstractProductA;         private AbstractProductB AbstractProductB;         // Constructor         public Client(AbstractFactory factory)         {             AbstractProductB = factory.CreateProductB();             AbstractProductA = factory.CreateProductA();         }            public void Run()         {             AbstractProductB.Interact(AbstractProductA);         }     } } 2.DoFactory.GangOfFour.Adapter.Structural        Adapter:将一个类的接口转换成客户希望的另一个接口,使得原来由于接口不兼容而不能一起工作的那些类可以一起工作。        适配器(变压器)模式:把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。 using System; namespace DoFactory.GangOfFour.Adapter.Structural {     ///      /// MainApp startup class for Structural     /// Adapter Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          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()");         }     } } 3.DoFactory.GangOfFour.Bridge.Structural       Bridge:将抽象部分与它的实现部分分离,使之可以独立变化。       桥梁模式:将抽象化与实现化脱耦,使得二者可以独立的变化,也就是说将他们之间的强关联变成弱关联,也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系,从而使两者可以独立的变化。 using System; namespace DoFactory.GangOfFour.Bridge.Structural {     ///      /// MainApp startup class for Structural     /// Bridge Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             Abstraction ab = new RefinedAbstraction();             // Set implementation and call             ab.Implementor = new ConcreteImplementorA();             ab.Operation();             // Change implemention and call             ab.Implementor = new ConcreteImplementorB();             ab.Operation();              // Wait for user             Console.Read();         }     }     // "Abstraction"     class Abstraction     {         protected Implementor implementor;         // Property         public Implementor Implementor         {             set{ implementor = value; }         }         public virtual void Operation()         {             implementor.Operation();         }     }     // "Implementor"      abstract class Implementor     {         public abstract void Operation();     }     // "RefinedAbstraction"     class RefinedAbstraction : Abstraction     {         public override void Operation()         {             implementor.Operation();         }     }     // "ConcreteImplementorA"     class ConcreteImplementorA : Implementor     {          public override void Operation()         {             Console.WriteLine("ConcreteImplementorA Operation");         }     }     // "ConcreteImplementorB"     class ConcreteImplementorB : Implementor     {         public override void Operation()         {             Console.WriteLine("ConcreteImplementorB Operation");         }     } } 4.DoFactory.GangOfFour.Builder.Structural   Builder:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。   建造者模式:将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。 using System; using System.Collections; namespace DoFactory.GangOfFour.Builder.Structural {     ///      /// MainApp startup class for Real-World      /// Builder Design Pattern.     ///      public class MainApp     {         ///          /// Entry point into console application.         ///          public static void Main()         {              // Create director and builders             Director director = new Director();             Builder b1 = new ConcreteBuilder1();             Builder b2 =  new ConcreteBuilder2();             // Construct two products             director.Construct(b1);             Product p1 = b1.GetResult();             p1.Show();             director.Construct(b2);             Product p2 = b2.GetResult();             p2.Show();             // Wait for user             Console.Read();         }     }     // "Director"      class Director     {         // Builder uses a complex series of steps         public void Construct(Builder builder)         {             builder.BuildPartA();             builder.BuildPartB();         }     }     // "Builder"      abstract class Builder     {         public abstract void BuildPartA();         public abstract void BuildPartB();         public abstract Product GetResult();     }     // "ConcreteBuilder1"      class ConcreteBuilder1 : Builder     {         private Product product = new Product();         public override void BuildPartA()         {             product.Add( "PartA");         }         public override void BuildPartB()         {             product.Add("PartB");         }         public override Product GetResult()         {             return product;         }     }     // "ConcreteBuilder2"      class ConcreteBuilder2 : Builder     {         private Product product = new Product();         public override void BuildPartA()         {             product.Add("PartX");         }         public override void BuildPartB()         {             product.Add("PartY");         }         public override Product GetResult()         {             return product;         }     }     // "Product"      class Product     {         ArrayList parts = new ArrayList();            public void Add(string part)         {             parts.Add(part);         }          public void Show()         {             Console.WriteLine("\nProduct Parts -------");             foreach (string part in parts)                 Console.WriteLine(part);         }     } } 5.DoFactory.GangOfFour.Chain.Structural   Chain of Responsibility:为解除请求的发送者和接收者之间的耦合,而使多个对象有机会处 理这个请求。将这些请求连成一个链,并沿着这条链传递该请求,直到有个对象处理它。       责任链模式:在责任链模式中,很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递,直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求,系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择:承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。 using System; namespace DoFactory.GangOfFour.Chain.Structural {      ///      /// MainApp startup class for Structural     /// Chain of Responsibility Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Setup Chain of Responsibility             Handler h1 = new ConcreteHandler1();             Handler h2 = new ConcreteHandler2();             Handler h3 = new ConcreteHandler3();             h1.SetSuccessor(h2);             h2.SetSuccessor(h3);             // Generate and process request             int[] requests = {2, 5, 14, 22, 18, 3, 27, 20};             foreach (int request in requests)             {                 h1.HandleRequest(request);             }             // Wait for user             Console.Read();         }     }     // "Handler"      abstract class Handler      {         protected Handler successor;            public void SetSuccessor(Handler successor)         {             this.successor = successor;         }         public abstract void HandleRequest(int request);     }      // "ConcreteHandler1"     class ConcreteHandler1 : Handler     {         public override void HandleRequest(int request)         {             if (request >= 0 && request < 10)             {                 Console.WriteLine("{0} handled request {1}",                      this.GetType().Name, request);             }             else if (successor != null)             {                 successor.HandleRequest(request);             }         }     }     // "ConcreteHandler2"     class ConcreteHandler2 : Handler     {         public override void HandleRequest(int request)         {             if (request >= 10 && request < 20)             {                 Console.WriteLine("{0} handled request {1}",                      this.GetType().Name, request);             }             else if (successor != null)             {                 successor.HandleRequest(request);             }         }     }     // "ConcreteHandler3"     class ConcreteHandler3 : Handler     {         public override void HandleRequest(int request)         {              if (request >= 20 && request < 30)             {                 Console.WriteLine("{0} handled request {1}",                      this.GetType().Name, request);             }             else if (successor != null)             {                 successor.HandleRequest(request);             }         }     } } 6.DoFactory.GangOfFour.Command.Structural   Command:将一个请求封装为一个对象,从而使你可以用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可以取消的操作。       命令模式:命令模式把一个请求或者操作封装到一个对象中。命令模式把发出命令的责任和执行命令的责任分割开,委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求是怎么被接收,以及操作是否执行,何时被执行以及是怎么被执行的。系统支持命令的撤消。 using System; namespace DoFactory.GangOfFour.Command.Structural {      ///      /// MainApp startup class for Structural      /// Command Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Create receiver, command, and invoker             Receiver receiver = new Receiver();             Command  command  = new ConcreteCommand(receiver);             Invoker  invoker  = new Invoker();             // Set and execute command             invoker.SetCommand(command);             invoker.ExecuteCommand();             // Wait for user             Console.Read();         }     }     // "Command"      abstract class Command      {         protected Receiver receiver;         // Constructor         public Command(Receiver receiver)         {             this.receiver = receiver;         }         public abstract void Execute();     }     // "ConcreteCommand"      class ConcreteCommand : Command     {          // Constructor         public ConcreteCommand(Receiver receiver) :              base(receiver)          {             }         public override void Execute()         {             receiver.Action();         }     }     // "Receiver"     class Receiver      {         public void Action()         {             Console.WriteLine("Called Receiver.Action()");         }     }     // "Invoker"      class Invoker      {         private Command command;         public void SetCommand(Command command)         {             this.command = command;         }         public void ExecuteCommand()         {             command.Execute();         }             } } 7.DoFactory.GangOfFour.Composite.Structural   Composite:将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得客户对单个对象和复合对象的使用具有一致性。       合成模式:合成模式将对象组织到树结构中,可以用来描述整体与部分的关系。合成模式就是一个处理对象的树结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。   using System; using System.Collections; namespace DoFactory.GangOfFour.Composite.Structural {     ///      /// MainApp startup class for Structural      /// Composite Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Create a tree structure             Composite root = new Composite("root");             root.Add(new Leaf("Leaf A"));             root.Add( new Leaf("Leaf B"));             Composite comp = new Composite("Composite X");             comp.Add(new Leaf("Leaf XA"));             comp.Add(new Leaf("Leaf XB"));             root.Add(comp);             root.Add(new Leaf("Leaf C"));             // Add and remove a leaf             Leaf leaf = new Leaf("Leaf D");             root.Add(leaf);             root.Remove(leaf);             // Recursively display tree             root.Display(1);             // Wait for user             Console.Read();         }     }     // "Component"      abstract class Component     {         protected string name;         // Constructor         public Component(string name)         {             this.name = name;         }         public abstract void Add(Component c);         public abstract void Remove(Component c);         public abstract void Display(int depth);     }     // "Composite"      class Composite : Component     {         private ArrayList children = new ArrayList();          // Constructor         public Composite(string name) : base(name)          {             }         public override void Add(Component component)         {             children.Add(component);         }         public override void Remove(Component component)         {             children.Remove(component);         }         public override void Display(int depth)         {             Console.WriteLine(new String('-', depth) + name);             // Recursively display child nodes             foreach (Component component in children)             {                 component.Display(depth + 2);             }         }     }     // "Leaf"      class Leaf : Component     {         // Constructor         public Leaf(string name) : base(name)          {             }         public override void Add(Component c)         {             Console.WriteLine("Cannot add to a leaf");         }         public override void Remove(Component c)         {             Console.WriteLine( "Cannot remove from a leaf");         }         public override void Display(int depth)         {             Console.WriteLine(new String('-', depth) + name);         }     } } 8. DoFactory.GangOfFour.Decorator.Structural   Decorator:动态地给一个对象添加一些额外的职责。就扩展功能而言,Decorator模式比生成子类方式更加灵活。       装饰模式:装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案,提供比继承更多的灵活性。动态给一个对象增加功能,这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量的功能。 using System; namespace DoFactory.GangOfFour.Decorator.Structural {      ///      /// MainApp startup class for Structural      /// Decorator Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          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()         {         }     } } 9.DoFactory.GangOfFour.Facade.Structural   Facade:为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,使得这个子系统更加容易使用。          门面模式:外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口,使得子系统更易于使用。每一个子系统只有一个门面类,而且此门面类只有一个实例,也就是说它是一个单例模式。但整个系统可以有多个门面类。 using System; namespace DoFactory.GangOfFour.Facade.Structural {     ///      /// MainApp startup class for Structural     /// Facade Design Pattern.     ///      class MainApp     {          ///          /// Entry point into console application.         ///          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();         }     } }         10.DoFactory.GangOfFour.Factory.Structural   Factory Method:定义一个用于创建对象的接口,让子类决定将哪一个类实例化。Factory Method让一个类的实例化延迟到子类。       工厂方法模式:核心工厂类不再负责所有产品的创建,而是将具体创建的工作交给子类去做,成为一个抽象工厂角色,仅负责给出具体工厂类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。 using System; using System.Collections; namespace DoFactory.GangOfFour.Factory.Structural {     ///      /// MainApp startup class for Structural      /// Factory Method Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // An array of creators             Creator[] creators = new Creator[2];             creators[0] = new ConcreteCreatorA();             creators[ 1] = new ConcreteCreatorB();             // Iterate over creators and create products             foreach(Creator creator in creators)             {                 Product product = creator.FactoryMethod();                 Console.WriteLine("Created {0}",                      product.GetType().Name);             }             // Wait for user             Console.Read();         }     }     // "Product"      abstract class Product     {     }     // "ConcreteProductA"      class ConcreteProductA : Product     {     }     // "ConcreteProductB"      class ConcreteProductB : Product     {     }     // "Creator"     abstract class Creator     {         public abstract Product FactoryMethod();     }     // "ConcreteCreator"     class ConcreteCreatorA : Creator     {          public override Product FactoryMethod()         {             return new ConcreteProductA();         }     }     // "ConcreteCreator"     class ConcreteCreatorB : Creator     {         public override Product FactoryMethod()         {             return new ConcreteProductB();         }     } }   23种设计模式 UML 类图及对应示例代码 (二) 收藏 11.DoFactory.GangOfFour.Flyweight.Structural    Flyweight:运用共享技术有效的支持大量细粒度的对象。        享元模式:FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部,不会随环境的改变而有所不同。外蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态,它们是相互独立的。将可以共享的状态和不可以共享的状态从常规类中区分开来,将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象,而应当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。 using System; using System.Collections; namespace DoFactory.GangOfFour.Flyweight.Structural {     ///      /// MainApp startup class for Structural      /// Flyweight Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Arbitrary extrinsic state             int extrinsicstate = 22;                      FlyweightFactory factory = new FlyweightFactory();             // Work with different flyweight instances             Flyweight fx = factory.GetFlyweight("X");             fx.Operation(--extrinsicstate);             Flyweight fy = factory.GetFlyweight("Y");             fy.Operation(--extrinsicstate);             Flyweight fz = factory.GetFlyweight("Z");             fz.Operation(--extrinsicstate);             UnsharedConcreteFlyweight fu = new                  UnsharedConcreteFlyweight();             fu.Operation(--extrinsicstate);             // Wait for user             Console.Read();         }     }     // "FlyweightFactory"      class FlyweightFactory      {          private Hashtable flyweights = new Hashtable();         // Constructor         public FlyweightFactory()         {             flyweights.Add("X", new ConcreteFlyweight());                     flyweights.Add("Y", new ConcreteFlyweight());             flyweights.Add("Z", new ConcreteFlyweight());         }         public Flyweight GetFlyweight(string key)         {             return((Flyweight)flyweights[key]);          }     }     // "Flyweight"      abstract class Flyweight      {         public abstract void Operation(int extrinsicstate);     }     // "ConcreteFlyweight"      class ConcreteFlyweight : Flyweight     {         public override void Operation(int extrinsicstate)         {             Console.WriteLine("ConcreteFlyweight: " + extrinsicstate);         }     }     // "UnsharedConcreteFlyweight"      class UnsharedConcreteFlyweight : Flyweight     {         public override void Operation(int extrinsicstate)         {             Console.WriteLine("UnsharedConcreteFlyweight: " +                  extrinsicstate);         }     } } 12.DoFactory.GangOfFour.Interpreter.Structural   Interpreter:给定一个语言,定义它的文法的一种表示,并定义一个解释器用于解释特定文法。       解释器模式:给定一个语言后,解释器模式可以定义出其文法的一种表示,并同时提供一个解释器。客户端可以使用这个解释器来解释这个语言中的句子。解释器模式将描述怎样在有了一个简单的文法后,使用模式设计解释这些语句。在解释器模式里面提到的语言是指任何解释器对象能够解释的任何组合。在解释器模式中需要定义一个代表文法的命令类的等级结构,也就是一系列的组合规则。每一个命令对象都有一个解释方法,代表对命令对象的解释。命令对象的等级结构中的对象的任何排列组合都是一个语言。 using System; using System.Collections; namespace DoFactory.GangOfFour.Interpreter.Structural {     ///      /// MainApp startup class for Structural      /// Interpreter Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             Context context =  new Context();             // Usually a tree              ArrayList list = new ArrayList();              // Populate 'abstract syntax tree'              list.Add(new TerminalExpression());             list.Add(new NonterminalExpression());             list.Add(new TerminalExpression());             list.Add(new TerminalExpression());             // Interpret             foreach (AbstractExpression exp in list)             {                 exp.Interpret(context);             }             // Wait for user             Console.Read();         }     }     // "Context"      class Context      {     }     // "AbstractExpression"     abstract class AbstractExpression      {         public abstract void Interpret(Context context);     }     // "TerminalExpression"      class TerminalExpression : AbstractExpression     {         public override void Interpret(Context context)             {             Console.WriteLine("Called Terminal.Interpret()");         }     }      // "NonterminalExpression"      class NonterminalExpression : AbstractExpression     {         public override void Interpret(Context context)             {             Console.WriteLine("Called Nonterminal.Interpret()");         }         } } 13.DoFactory.GangOfFour.Iterator.Structural   Iterator:提供一种方法顺序访问一个聚合对象中的各种元素,而无需暴露该对象的内部表示。       迭代子模式:迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集,聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中,从而与聚集本身隔开。迭代子模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象,每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。 using System; using System.Collections; namespace DoFactory.GangOfFour.Iterator.Structural {     ///      /// MainApp startup class for Structural      /// Iterator Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             ConcreteAggregate a = new ConcreteAggregate();             a[0] = "Item A";             a[1] = "Item B";             a[2] = "Item C";             a[3] = "Item D";              // Create Iterator and provide aggregate             ConcreteIterator i = new ConcreteIterator(a);             Console.WriteLine("Iterating over collection:");                          object item = i.First();             while (item != null)             {                 Console.WriteLine(item);                 item = i.Next();             }              // Wait for user             Console.Read();         }     }     // "Aggregate"      abstract class Aggregate     {         public abstract Iterator CreateIterator();     }     // "ConcreteAggregate"      class ConcreteAggregate : Aggregate     {         private ArrayList items = new ArrayList();         public override Iterator CreateIterator()         {             return new ConcreteIterator(this);         }         // Property         public int Count         {             get{ return items.Count; }         }         // Indexer         public object this[int index]         {              get{ return items[index]; }             set{ items.Insert(index, value); }         }     }     // "Iterator"     abstract class Iterator     {         public abstract object First();         public abstract object Next();         public abstract bool IsDone();         public abstract object CurrentItem();     }     // "ConcreteIterator"      class ConcreteIterator : Iterator     {         private ConcreteAggregate aggregate;         private int current = 0;         // Constructor         public ConcreteIterator(ConcreteAggregate aggregate)         {             this.aggregate = aggregate;         }         public override object First()         {             return aggregate[0];         }         public override object Next()         {             object ret = null;             if (current < aggregate.Count - 1)             {                 ret = aggregate[++current];             }                          return ret;         }          public override object CurrentItem()         {             return aggregate[current];         }         public override bool IsDone()         {             return current >= aggregate.Count ? true : false ;         }     } } 14.DoFactory.GangOfFour.Mediator.Structural   Mediator:用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式相互引用,从而使得耦合松散,可以独立改变相互之间的交互。       调停者模式:调停者模式包装了一系列对象相互作用的方式,使得这些对象不必相互明显作用。从而使他们可以松散偶合。当某些对象之间的作用发生改变时,不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。调停者模式将多对多的相互作用转化为一对多的相互作用。调停者模式将对象的行为和协作抽象化,把对象在小尺度的行为上与其他对象的相互作用分开处理。 using System; using System.Collections; namespace DoFactory.GangOfFour.Mediator.Structural {     ///      /// MainApp startup class for Structural      /// Mediator Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             ConcreteMediator m = new ConcreteMediator();             ConcreteColleague1 c1 = new ConcreteColleague1(m);             ConcreteColleague2 c2 = new ConcreteColleague2(m);             m.Colleague1 = c1;             m.Colleague2 = c2;             c1.Send("How are you?");             c2.Send("Fine, thanks");             // Wait for user             Console.Read();         }     }     // "Mediator"      abstract class Mediator     {         public abstract void Send(string message,              Colleague colleague);     }     // "ConcreteMediator"      class ConcreteMediator : Mediator     {          private ConcreteColleague1 colleague1;         private ConcreteColleague2 colleague2;         public ConcreteColleague1 Colleague1         {             set{ colleague1 = value; }         }         public ConcreteColleague2 Colleague2         {             set{ colleague2 = value; }         }         public override void Send(string message,              Colleague colleague)         {             if (colleague == colleague1)             {                 colleague2.Notify(message);             }             else             {                 colleague1.Notify(message);             }         }     }     // "Colleague"      abstract class Colleague     {         protected Mediator mediator;         // Constructor         public Colleague(Mediator mediator)         {             this.mediator = mediator;         }     }     // "ConcreteColleague1"      class ConcreteColleague1 : Colleague     {          // Constructor         public ConcreteColleague1(Mediator mediator)              : base(mediator)          {          }         public void Send(string message)         {             mediator.Send(message, this);         }         public void Notify(string message)         {             Console.WriteLine("Colleague1 gets message: "                  + message);         }     }     // "ConcreteColleague2"      class ConcreteColleague2 : Colleague     {         // Constructor         public ConcreteColleague2(Mediator mediator)              : base(mediator)          {          }            public void Send(string message)         {             mediator.Send(message, this);         }         public void Notify(string message)         {             Console.WriteLine("Colleague2 gets message: "                  + message);         }     } } 15.DoFactory.GangOfFour.Memento.Structural   Memento:不破坏封装的前提下,捕获对象的内部状态,并在该对象之外保存这个状态。          备忘录模式:备忘录对象是一个用来存储另外一个对象内部状态的快照的对象。备忘录模式的用意是在不破坏封装的条件下,将一个对象的状态捉住,并外部化,存储起来,从而可以在将来合适的时候把这个对象还原到存储起来的状态。 using System; namespace DoFactory.GangOfFour.Memento.Structural {     ///      /// MainApp startup class for Structural      /// Memento Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             Originator o = new Originator();             o.State = "On";             // Store internal state             Caretaker c = new Caretaker();             c.Memento = o.CreateMemento();              // Continue changing originator             o.State = "Off";             // Restore saved state             o.SetMemento(c.Memento);             // Wait for user             Console.Read();         }     }     // "Originator"      class Originator     {         private string state;         // Property         public string State         {             get{ return state; }             set             {                  state = value;                  Console.WriteLine("State = " + state);             }         }         public Memento CreateMemento()         {             return (new Memento(state));         }         public void SetMemento(Memento memento)         {             Console.WriteLine("Restoring state");             State = memento.State;         }     }     // "Memento"     class Memento     {          private string state;         // Constructor         public Memento(string state)         {             this.state = state;         }         // Property         public string State         {             get{ return state; }         }     }     // "Caretaker"      class Caretaker     {         private Memento memento;         // Property         public Memento Memento         {             set{ memento = value; }             get{ return memento; }         }     } } 16.DoFactory.GangOfFour.Observer.Structural   Observer:定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生变化时依赖于它的所有的对象都得到通知和刷新。       观察者模式:观察者模式定义了一种一队多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使他们能够自动更新自己。 using System; using System.Collections; namespace DoFactory.GangOfFour.Observer.Structural {     ///      /// MainApp startup class for Structural      /// Observer Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Configure Observer pattern             ConcreteSubject s = new ConcreteSubject();             s.Attach(new ConcreteObserver(s,"X"));             s.Attach(new ConcreteObserver(s,"Y"));             s.Attach(new ConcreteObserver(s,"Z"));             // Change subject and notify observers             s.SubjectState = "ABC";             s.Notify();              // Wait for user             Console.Read();         }     }     // "Subject"      abstract class Subject     {         private ArrayList observers = new ArrayList();         public void Attach(Observer observer)         {             observers.Add(observer);         }         public void Detach(Observer observer)         {             observers.Remove(observer);         }         public void Notify()         {             foreach (Observer o in observers)             {                 o.Update();             }         }     }     // "ConcreteSubject"      class ConcreteSubject : Subject     {         private string subjectState;         // Property         public string SubjectState         {             get{ return subjectState; }             set{ subjectState = value; }         }     }      // "Observer"      abstract class Observer     {         public abstract void Update();     }     // "ConcreteObserver"      class ConcreteObserver : Observer     {         private string name;         private string observerState;         private ConcreteSubject subject;         // Constructor         public ConcreteObserver(             ConcreteSubject subject, string name)         {             this.subject = subject;             this.name = name;         }         public override void Update()         {             observerState = subject.SubjectState;             Console.WriteLine("Observer {0}'s new state is {1}",                 name, observerState);         }         // Property         public ConcreteSubject Subject         {             get { return subject; }             set { subject = value; }         }     } } 17.DoFactory.GangOfFour.Prototype.Structural    Prototype:用原型实例指定创建对象的种类,并且通过拷贝这个原型来创建新的对象。        原始模型模式:通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类,产品类不需要非得有任何事先确定的等级结构,原始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。 using System; namespace DoFactory.GangOfFour.Prototype.Structural {     ///      /// MainApp startup class for Structural     /// Prototype Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Create two instances and clone each             ConcretePrototype1 p1 = new ConcretePrototype1("I");             ConcretePrototype1 c1 = (ConcretePrototype1)p1.Clone();             Console.WriteLine ("Cloned: {0}", c1.Id);             ConcretePrototype2 p2 =  new ConcretePrototype2("II");             ConcretePrototype2 c2 = (ConcretePrototype2)p2.Clone();             Console.WriteLine ("Cloned: {0}", c2.Id);             // Wait for user             Console.Read();         }     }     // "Prototype"      abstract class Prototype     {         private string id;         // Constructor         public Prototype(string id)         {             this.id = id;         }         // Property         public string Id         {             get{ return id; }         }         public abstract Prototype Clone();     }     // "ConcretePrototype1"     class ConcretePrototype1 : Prototype     {         // Constructor         public ConcretePrototype1(string id) : base(id)          {         }         public override Prototype Clone()         {             // Shallow copy             return (Prototype)this.MemberwiseClone();         }     }      // "ConcretePrototype2"     class ConcretePrototype2 : Prototype     {         // Constructor         public ConcretePrototype2(string id) : base(id)          {         }         public override Prototype Clone()         {             // Shallow copy             return (Prototype)this.MemberwiseClone();         }     } } 18.DoFactory.GangOfFour.Proxy.Structural   Proxy:为其他对象提供一个代理以控制对这个对象的访问。       代理模式:代理模式给某一个对象提供一个代理对象,并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下,客户不想或者不能够直接引用一个对象,代理对象可以在客户和目标对象直接起到中介的作用。客户端分辨不出代理主题对象与真实主题对象。代理模式可以并不知道真正的被代理对象,而仅仅持有一个被代理对象的接口,这时候代理对象不能够创建被代理对象,被代理对象必须有系统的其他角色代为创建并传入。 using System; namespace DoFactory.GangOfFour.Proxy.Structural {     ///      /// MainApp startup class for Structural     /// Proxy Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Create proxy and request a service             Proxy proxy = new Proxy();             proxy.Request();             // Wait for user             Console.Read();         }     }     // "Subject"      abstract class Subject      {         public abstract void Request();             }     // "RealSubject"      class RealSubject : Subject     {         public override void Request()         {             Console.WriteLine("Called RealSubject.Request()");         }     }     // "Proxy"       class Proxy : Subject     {         RealSubject realSubject;         public override void Request()         {             // Use 'lazy initialization'             if (realSubject == null)             {                 realSubject = new RealSubject();             }             realSubject.Request();         }         } } 19.DoFactory.GangOfFour.Singleton.Structural    Singleton:保证一个类仅有一个实例,并提供一个访问它的全局点。        单例模式:单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例单例模式。单例模式只应在有真正的“单一实例”的需求时才可使用。 using System; namespace DoFactory.GangOfFour.Singleton.Structural {     ///      /// MainApp startup class for Structural     /// Singleton Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.          ///          static void Main()         {             // Constructor is protected -- cannot use new             Singleton s1 = Singleton.Instance();             Singleton s2 = Singleton.Instance();             if (s1 == s2)             {                 Console.WriteLine("Objects are the same instance");             }             // Wait for user             Console.Read();         }     }     // "Singleton"     class Singleton     {         private static Singleton instance;         // Note: Constructor is 'protected'         protected Singleton()          {         }         public static Singleton Instance()         {             // Uses lazy initialization             if (instance == null)             {                 instance = new Singleton();             }             return instance;         }     } } 20.DoFactory.GangOfFour.State.Structural   State:允许一个对象再内部状态改变的时候改变它的行为。对象看起来似乎修改了所属的类。          状态模式:状态模式允许一个对象在其内部状态改变的时候改变行为。这个对象看上去象是改变了它的类一样。状态模式把所研究的对象的行为包装在不同的状态对象里,每一个状态对象都属于一个抽象状态类的一个子类。状态模式的意图是让一个对象在其内部状态改变的时候,其行为也随之改变。状态模式需要对每一个系统可能取得的状态创立一个状态类的子类。当系统的状态变化时,系统便改变所选的子类。 using System; namespace DoFactory.GangOfFour.State.Structural {     ///      /// MainApp startup class for Structural     /// State Design Pattern.     ///      class MainApp     {         ///          /// Entry point into console application.         ///          static void Main()         {             // Setup context in a state             Context c = new Context(new ConcreteStateA());              // Issue requests, which toggles state             c.Request();             c.Request();             c.Request();             c.Request();             // Wait for user             Console.Read();         }     }     // "State"      abstract class State     {         public abstract void Handle(Context context);     }     // "ConcreteStateA"     class ConcreteStateA : State     {         public override void Handle(Context context)         {             context.State = new ConcreteStateB();         }     }     // "ConcreteStateB"      class ConcreteStateB : State     {         public override void Handle(Context context)         {             context.State = new ConcreteStateA();         }     }     // "Context"      class Context     {         private State state;          // Constructor         public Context(State state)         {             this.State = state;         }         // Property         public State State         {             get{ return state; }             set             {                  state = value;                  Console.WriteLine("State: " +                      state.GetType().Name);             }         }         public void Request()         {             state.Handle(this);         }     } }

下载文档到电脑,查找使用更方便

文档的实际排版效果,会与网站的显示效果略有不同!!

需要 15 金币 [ 分享文档获得金币 ] 26 人已下载

下载文档