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

1.DoFactory.GangOfFour.Abstract.Structural






Code
using System;

namespace DoFactory.GangOfFour.Abstract.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Abstract Factory Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;

namespace DoFactory.GangOfFour.Adapter.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Adapter Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;

namespace DoFactory.GangOfFour.Bridge.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Bridge Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;
using System.Collections;

namespace DoFactory.GangOfFour.Builder.Structural
{
/// <summary>
/// MainApp startup class for Real-World
/// Builder Design Pattern.
/// </summary>
public class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;

namespace DoFactory.GangOfFour.Chain.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Chain of Responsibility Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;

namespace DoFactory.GangOfFour.Command.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Command Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;
using System.Collections;

namespace DoFactory.GangOfFour.Composite.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Composite Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;

namespace DoFactory.GangOfFour.Decorator.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Decorator Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;

namespace DoFactory.GangOfFour.Facade.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Facade Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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






Code
using System;
using System.Collections;

namespace DoFactory.GangOfFour.Factory.Structural
{
/// <summary>
/// MainApp startup class for Structural
/// Factory Method Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
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();
}
}
}