Bridge 把一个抽象与其抽象操作的实现进行分离，这样，抽象与其抽象操作的实现可以独立进行改变

操作上的抽象
1using System;
2
3namespace Gof.Test.Bridge
4{
5    public interface ITankAction
6    {
7        string Shot(string tankNO);
8    }
9}

操作具体实现1
 1using System;
 2
 3namespace Gof.Test.Bridge
 4{
 5    public class PCActionDriver:ITankAction
 6    {
 7        public PCActionDriver()
 8        {
 9        }
10
11        ITankAction 成员#region ITankAction 成员
12
13        public string Shot(string tankNO)
14        {
15            return tankNO + " Shot in PC";
16        }
17
18        #endregion
19    }
20}
21

操作具体实现2
 1using System;
 2
 3namespace Gof.Test.Bridge
 4{
 5    public class TVActionDriver:ITankAction
 6    {
 7        public TVActionDriver()
 8        {
 9        }
10        ITankAction 成员#region ITankAction 成员
11
12        public string Shot(string tankNO)
13        {
14            return tankNO + " Shot in TV";
15        }
16
17        #endregion
18    }
19}
20

我们想要的抽象
 1using System;
 2
 3namespace Gof.Test.Bridge
 4{
 5    public abstract class Tank
 6    {
 7        public Tank(ITankAction action)
 8        {
 9            _action = action;
10        }
11        public ITankAction Action
12        {
13            get
14            {
15                return _action;
16            }
17            set
18            {
19                _action = value;
20            }
21        }
22        private ITankAction _action;
23
24        public abstract string Shot();
25    }
26}

抽象上的类型方向变化１
 1using System;
 2
 3namespace Gof.Test.Bridge
 4{
 5    public class Tank97:Tank
 6    {
 7        public Tank97(ITankAction action):base(action)
 8        {}
 9        public override string Shot()
10        {
11            return Action.Shot("Tank97");
12        }
13    }
14}

抽象在类型上的变化２
 1using System;
 2
 3namespace Gof.Test.Bridge
 4{
 5    public class Tank98:Tank
 6    {
 7        public Tank98(ITankAction action):base(action)
 8        {}
 9        public override string Shot()
10        {
11            return Action.Shot("Tank98");
12        }
13    }
14}

结论：一个抽象是一个类，它依赖于抽象方法。最简单的抽象例子是一个抽象层次结构，其中，超类中的具体方法依赖于其他抽象方法。当我们按照原有的层次结构，沿着另外的方向，继续派生子类时，我们可能不得不把这些抽象方法移入其他层次结构。这时，我们可以使用桥接模式，从而将一个抽象与这个抽象中的抽象方法的实现分离开来。