设计模式知我所见。。。

一，桥连模式

二，桥连模式

外观模式提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。使用外观模式时，我们创建了一个统一的类，用来包装子系统中一个或多个复杂的类，客户端可以直接通过外观类来调用内部子系统中方法，从而外观模式让客户和子系统之间避免了紧耦合。

三，策略模式

策略模式适用情形：
　　◊ 如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。
　　◊ 一个系统需要动态地在几种算法中选择一种。这些具体算法类均有统一的接口，由于多态性原则，客户端可以选择使用任何一个具体算法类，并只持有一个数据类型是抽象算法类的对象。
　　◊ 一个系统的算法使用的数据不可以让客户端知道。策略模式可以避免让客户端涉及到不必要接触到的复杂的和只与算法有关的数据。
　　◊ 如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。此时，使用策略模式，把这些行为转移到相应的具体策略类里面，可以避免使用难以维护的多重条件选择语句。

策略模式优点：
　　◊ 策略模式恰当使用继承可以把公共的代码移到父类里面，从而避免重复的代码。
　　◊ 策略模式提供了可以替换继承关系的办法。继承可以处理多种算法或行为。如果不是用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是，这样一来算法或行为的使用者就和算法或行为本身混在一起。决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。继承使得动态改变算法或行为变得不可能。
　　◊ 使用策略模式可以避免使用多重条件判断语句。

　　策略模式缺点：
　　◊ 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。策略模式只适用于客户端知道所有的算法或行为的情况。
　　◊ 策略模式造成很多的策略类。

Strategy

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace StrategyPattern.Structural
 7 {
 8     public abstract class Strategy
 9     {
10         public abstract void AlgorithmInterface();
11     }
12 }

ConcreteStrategyA

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace StrategyPattern.Structural
 7 {
 8     public class ConcreteStrategyA : Strategy
 9     {
10         public override void AlgorithmInterface()
11         {
12             Console.WriteLine("Called ConcreteStrategyA.AlgorithmInterface()");
13         }
14     }
15 }

ConcreteStrategyB

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace StrategyPattern.Structural
 7 {
 8     public class ConcreteStrategyB : Strategy
 9     {
10         public override void AlgorithmInterface()
11         {
12             Console.WriteLine("Called ConcreteStrategyB.AlgorithmInterface()");
13         }
14     }
15 }

ConcreteStrategyC


 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace StrategyPattern.Structural
 7 {
 8     public class ConcreteStrategyC : Strategy
 9     {
10         public override void AlgorithmInterface()
11         {
12             Console.WriteLine("Called ConcreteStrategyC.AlgorithmInterface()");
13         }
14     }
15 }

Context

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace StrategyPattern.Structural
 7 {
 8     public class Context
 9     {
10         private Strategy _strategy;
11 
12         public Context(Strategy strategy)
13         {
14             this._strategy = strategy;
15         }
16 
17         public void ContextInterface()
18         {
19             _strategy.AlgorithmInterface();
20         }
21     }
22 }

Program

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 
 6 namespace StrategyPattern.Structural
 7 {
 8     class Program
 9     {
10         static void Main(string[] args)
11         {
12             Context context;
13 
14             context = new Context(new ConcreteStrategyA());
15             context.ContextInterface();
16 
17             context = new Context(new ConcreteStrategyB());
18             context.ContextInterface();
19 
20             context = new Context(new ConcreteStrategyC());
21             context.ContextInterface();
22         }
23     }
24 }