设计模式 桥接模式(Bridge Pattern)

　　桥接模式有点像适配器模式，都是用一个类将一种接口转换成另一种接口。但是适配器模式的意图是：是一个或多个类的接口看起来像一个特定的接口。桥接模式将类的接口和它的实现分离，无需修改客户端代码就可以改变或替换实现过程。
　　桥接模式的参与这又Abstraction，他定义类的接口，Refined Abstraction，他扩展实现由Abstraction定义的接口；Implementor，它定义实现 的接口；
ConcreteImplementor，他是实现类。
　　假设我们有一个程序，要在窗口中显示一系列的产品。最简单的就是用ListBox，但在售出大量产品后，我们希望在产品中显示产品名称以及销售数目。桥接接接口 我们定义一个简单的接口，他保留着相同的部分而不管实际实现类的类型和复杂性。先定义Bridger接口，该类只接收数据ArrayList，并将其传递给现实类。

using System;
using System.Collections ;
namespace BasicBridge
{
    /// <summary>
    /// Summary description for Bridger.
    /// </summary>
    //Bridge interface to display list classes
    public interface Bridger     {
        void addData(ArrayList col);
    }
}

　　还要定义一个Product类，它包含产品的名字，数量，并分析来自于数据文件输入串。

using System;

namespace BasicBridge
{
    /// <summary>
/// Summary description for Product.
/// </summary>
    public class Product : IComparable     {
        private string quantity;
        private string name;
        //-----
        public Product(string line)         {
            int i = line.IndexOf ("--");
            name =line.Substring (0, i).Trim ();
            quantity = line.Substring (i+2).Trim ();
            }
        //-----
        public string getQuantity() {
            return quantity;
        }
        //-----
        public string getName() {
            return name;
        }
        //-----
        public int CompareTo(object p) {
            Product prod =(Product) p;
            return name.CompareTo (prod.getName ());
        }
    }
}

　　桥接模式的另一部分是实现类，他们常常都有一个更灵活，低层次的接口。这里让实现类向显示屏幕添加数据行，一次添加一行数据。

using System;

namespace BasicBridge
{
    /// <summary>
/// Summary description for VisList.
/// </summary>
    public interface VisList     {
        //add a line to the display
        void addLine(Product p);
        //remove a line from the display
        void removeLine(int num);
    }
}

　　左边的接口和右边的实现之间的桥梁ListBridge类，他实例化其中一个列表信息。注意，他实现了Bridger接口供应用程序使用。

using System;
using System.Collections ;
namespace BasicBridge
{
    /// <summary>
/// Summary description for ListBridge.
/// </summary>
    public class ListBridge : Bridger     {
        protected VisList vis;
        //------
        public ListBridge(VisList v)        {
            vis = v;
        }
        //-----
        public virtual void addData(ArrayList ar) {
            for(int i=0; i< ar.Count ; i++) {
                Product p = (Product)ar[i];
                vis.addLine (p);
            }
        }
    }
}

　　注意，我们把VisList的变量设为保护的，把addData方法声明为虚函数，这样以后就可以扩展这个类了。在程序设计顶层，只是用ListBridge类创建一个表实例和一个列表实例。

        private void init() {
            products = new ArrayList ();
            readFile(products);    //read in the data file
　　　　　　　//create the product list 
            prodList = new ProductList (lsProd);
            //Bridge to product VisList
            Bridger lbr = new SortBridge (prodList);
            //put the data into the product list
            lbr.addData (products);
            //create the grid VisList
            gridList = new GridList(grdProd);
            //Bridge to the grid list
            Bridger gbr = new SortBridge (gridList);
            //put the data into the grid display
            gbr.addData (products);
        }

 VisList类

　　两个VisList实际上非常类似，消费者版本是类对ListBox操作，并将名字加入其中。

using System;
using System.Windows.Forms;
namespace BasicBridge
{
    /// <summary>
/// Summary description for ProductList.
/// </summary>
    //A VisList class for the ListBox
    public class ProductList : VisList     {
        private ListBox list;
        //-----
        public ProductList(ListBox lst)         {
            list = lst;
        }
        //-----
        public void addLine(Product p) {
            list.Items.Add (p.getName() );
        }
        //-----
        public void removeLine(int num) {
            if(num >=0 && num < list.Items.Count ){
                list.Items.Remove (num);
            }
        }
    }
}

　　除了要向表中的两个列表添加产品名称和数量外，VisList的GridList版本与上面的类似。

using System;
using System.Windows.Forms;
using System.Data;
namespace BasicBridge
{
    /// <summary>
/// Summary description for GridList.
/// </summary>
    public class GridList:VisList     {
        private DataGrid grid;
        private DataTable dtable;
        private GridAdapter gAdapter;
        //-----
        public GridList(DataGrid grd) {
            grid = grd;
            dtable = new DataTable("Products");
            DataColumn column = new DataColumn("ProdName");
            dtable.Columns.Add(column);
            column = new DataColumn("Qty");
            dtable.Columns.Add(column);
            grid.DataSource = dtable;
            gAdapter = new GridAdapter (grid);
        }
        //-----
        public void addLine(Product p) {
            gAdapter.Add (p);
        }
        //-----
        public void removeLine(int num) {
            
        }
    }
}

扩展Bridge

　　现在假设，需要在列表显示数据的方式做了修改。例如以字母顺序显示产品。读者可能会想修改子列表和表格类，这很容易导致不易维护，特别是如果在某个时候需要两个以上这样的显示时。我们换中做法，派生一个类似于ListBridge的心类SortBridge。为了对Product对象进行排序，让Product类是实现IComparable接口，木的事让他拥有CompareTo方法。

using System;

namespace BasicBridge
{
    /// <summary>
/// Summary description for Product.
/// </summary>
    public class Product : IComparable     {
        private string quantity;
        private string name;
        //-----
        public Product(string line)         {
            int i = line.IndexOf ("--");
            name =line.Substring (0, i).Trim ();
            quantity = line.Substring (i+2).Trim ();
            }
        //-----
        public string getQuantity() {
            return quantity;
        }
        //-----
        public string getName() {
            return name;
        }
        //-----
        public int CompareTo(object p) {
            Product prod =(Product) p;
            return name.CompareTo (prod.getName ());
        }
    }
}

　　有了上述改动之后，Product对象的排序就很简单了。

using System;
using System.Collections ;
namespace BasicBridge
{
    /// <summary>
/// Summary description for SortBridge.
/// </summary>
    public class SortBridge:ListBridge     {
        //-----
        public SortBridge(VisList v):base(v){
        }
        //-----
        public override void addData(ArrayList ar) {
            int max = ar.Count ;
            Product[] prod = new Product[max];
            for(int i=0; i< max ; i++) {
                prod[i] = (Product)ar[i];
            }
            for(int i=0; i < max ; i++) {
                for (int j=i; j < max; j++) {
                    if(prod[i].CompareTo (prod[j])>0)  {
                        Product pt = prod[i];
                        prod[i]= prod[j];
                        prod[j] = pt;
                    }
                }
            }
            for(int i = 0; i< max; i++) {
                vis.addLine (prod[i]);
            }
        }
    }
}

　　排序结果如下图

　　这清楚的表明，不用修改实现就能改变接口，反过来也一样。例如创建一个其他类型的类表显示类并替换当前的显示，只要新的列表也实现了VisList接口，就不需要改变其他程序了。下面是TreeList类。

using System;
using System.Windows.Forms;
using System.Data;
namespace BasicBridge
{
    /// <summary>
/// Summary description for GridList.
/// </summary>
    public class TreeList:VisList     {
        private TreeView tree;
        private TreeAdapter gAdapter;
        //-----
        public TreeList(TreeView tre) {
            tree = tre;
            gAdapter = new TreeAdapter (tree);
        }
        //-----
        public void addLine(Product p) {
            gAdapter.Add (p);
        }
        //-----
        public void removeLine(int num) {
        }
    }
}

　　注意，我们利用前一张编写的TreeAdapter类，并修改它使之能对Product对象操作。创建一个树形列表组件，他实现了VisList接口，并替换原来的列表而没有修改类的公共接口。

using System;
using System.Windows.Forms;
namespace BasicBridge
{
    /// <summary>
/// Summary description for TreeAdapter.
/// </summary>
    public class TreeAdapter     {
        private TreeView tree;
        //------
        public TreeAdapter(TreeView tr)         {
            tree=tr;
        }
        //------
        public void Add(Product p) {
            TreeNode nod;
        //add a root node  
            nod = tree.Nodes.Add(p.getName());
        //add a child node to it
        nod.Nodes.Add(p.getQuantity ());
        tree.ExpandAll ();
        }
        //------
        public int SelectedIndex() {
            return tree.SelectedNode.Index ;
        }
        //------
        public void Clear() {
        TreeNode nod;
            for (int i=0; i< tree.Nodes.Count ; i++) {
                nod = tree.Nodes [i];
                nod.Remove ();
            }
        }
        //------
        public void clearSelection() {}
    }
}

效果如下图

桥接模式的效果
1.桥接模式可以保持客户端程序接口不变，而允许读者修改显示类，或要使用的类。可以防止重新编译一系列复杂的用户接口模块，只需要重新编译Bridge和实际的最终显示类。
2.可以分别扩展实现类和Bridge类，二者之间通常不会有相互作用。
3.对客户端程序很容易隐藏实现细节。