Bridge Pattern using C#(转载)

Bridge Pattern（桥接模式）属于Structural Pattern（结构型模式），Bridge Pattern-将类的接口和它的实现分离，无需修改客户端代码就可以改变或替换实现过程。

This pattern is used for decoupling an abstraction from its implementation so that the two can very independently. The bridge pattern lets the abstraction and its implementation evolve separately.

 

1. UML class diagram

 

参与者：

Abstraction: 定义类的接口，同时保留一个对Implementor接口类型的引用。

RefinedAbstraction: 扩展并实现由Abstraction定义的接口。

Implementor: 定义实现类的接口。Implementor接口不必完全符合Abstraction接口，事实上，两个接口可以完全不一致。典型情况下，Implementator接口仅提供简单的方法（primitive operations），而Abstraction接口基于这些简单的方法（primitive operations）定义更高层次（higher-level）的方法。

ContreteImplementor: 实现类，实现Implementor接口。

 

对上述UML图说明：

Client通过Abstraction接口来交互，也就是说，Client直接通过Abstraction对象来发送请求，Client只需要了解的唯一接口。Abstraction对象也保留一个Implementor对象的引用。模式中对象之间的协作关系：Abstraction通过Implementor对象的引用，转发来自Client的请求到实际对象ConcreteImplementor。

RefinedAbstract是对Abstract接口的扩展和实现（显然，Client无法通过Abstraction接口来生成Abstraction实例对象，而只能通过RefinedAbstraction类来实现）。

Implementor是实现类的接口，所有ConcreteImplementor实现类均实现该接口。

 

显然，Client调用的Abstraction接口和Implementor或ConcreteImplementor实现了分离，这样Abstraction抽象接口和实现部分可以独立发展。

 

2. Sample code

上述UML class diagram的实现代码（from reference 1）：

using System;
// Abstraction接口－不一定是真正的接口interface或抽象类（其实，这里也可以定义abstract抽象类，并要相应修改virtual public void Operation()方法）
class Abstraction
{

// 保留对Implementor类型的引用
  protected Implementor implementor;

  public Implementor Implementor
 {
    set{ implementor = value; }
 }
 // 正是通过Implementor的引用来完成对ConcreteImplementor的调用
  virtual public void Operation()
 {
    implementor.Operation();
 }
}

// Implementor接口或抽象类
abstract class Implementor
{
 // Methods
  abstract public void Operation();
}

// RefinedAbstraction实现类，Client用来创建Abstraction对象实例
class RefinedAbstraction : Abstraction
{
 // Methods
  override public void Operation()
 {
    implementor.Operation();
 }
}

// ConcreteImplementorA具体实现，继承Implementor接口或抽象类
class ConcreteImplementorA : Implementor
{
 // Methods
  override public void Operation()
 {
    Console.WriteLine("ConcreteImplementorA Operation");
 }
}

// ConcreteImplementorB具体实现，继承Implementor接口或抽象类
class ConcreteImplementorB : Implementor
{
 // Methods
  override public void Operation()
 {
    Console.WriteLine("ConcreteImplementorB Operation");
 }
}

/// <summary>
/// Client test
/// </summary>
public class Client
{
  public static void Main( string[] args )
 {
    Abstraction abstraction = new RefinedAbstraction();

    // Set implementation and call
    abstraction.Implementor = new ConcreteImplementorA();
    abstraction.Operation();

    // Change implemention and call
    abstraction.Implementor = new ConcreteImplementorB();
    abstraction.Operation();
 }
}

Abstraction通过Implementor对象的引用，转发来自Client的请求Operation到实际对象ConcreteImplementor。

 

 

3. Appendix about the article

温故而知新，运用于无形。

 

【虚函数】

在父类中用virtual声明函数，并实现函数的定义；

public virtual bool SQLExe(bool b)

{

    return true;

}

在子类中用override覆盖此函数，可以实现动态联编。

 

【纯虚函数】

用关键字abstract声明的函数，并且不实现函数的定义，必须存在于抽象类中。

public abstract bool f();

在子类中用override覆盖此函数。

 

【抽象类】

用abstract声明，父类中可包含虚函数声明，并不实现虚函数的定义，只能作为基类。

public abstract class cl

{

    public cl(){}

    public abstract bool f();

}

 

 

References:

1. http://www.dofactory.com/Patterns/PatternBridge.aspx

2. Rajesh V. S., Bridge Patterns in C#, http://www.c-sharpcorner.com/Language/BridgePatternsinCSRVS.asp

3. Airhand, 各种语言多态性比较,  http://blog.csdn.net/airhand/archive/2004/10/28/156167.aspx