桥梁

1：概述
   将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化
   抽象化
       存在于多个实体中的共同的概念性联系，就是抽象化。作为一个过程，抽象化就是忽略一些信息，从而把不同的实体当做同样的实体对待。
   实现化
       抽象化给出的具体实现，就是实现化。
   脱耦
       所谓耦合，就是两个实体的行为的某种强关联。而将它们的强关联去掉，就是耦合的解脱，或称脱耦。在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。
      将两个角色之间的继承关系改为聚合关系，就是将它们之间的强关联改换成为弱关联。因此，桥梁模式中的所谓脱耦，就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以相对独立地变化。这就是桥梁模式的用意。
2：结构

抽象化(Abstraction)角色：抽象化给出的定义，并保存一个对实现化对象的引用。
修正抽象化(Refined Abstraction)角色：扩展抽象化角色，改变和修正父类对抽象化的定义。
实现化(Implementor)角色：这个角色给出实现化角色的接口，但不给出具体的实现。必须指出的是，这个接口不一定和抽象化角色的接口定义相同，实际上，这两个接口可以非常不一样。实现化角色应当只给出底层操作，而抽象化角色应当只给出基于底层操作的更高一层的操作。
具体实现化(Concrete Implementor)角色：这个角色给出实现化角色接口的具体实现。
3：代码

     /**/ /// <summary>
    /// 实现化(Implementor)角色
    /// </summary>
     public   abstract   class  EmailAction
     {
        public abstract void SendEmai();
        public abstract void ReveiveEmail();
    }
    
     /**/ /// <summary>
    /// 具体实现化(Concrete Implementor)角色
    /// </summary>
     public   class  ChinaEmail:EmailAction
     {
        public override void SendEmai()
        {
            throw new NotImplementedException();
        }

        public override void ReveiveEmail()
        {
            throw new NotImplementedException();
        }
    }

     public   class  AmericaEmail : EmailAction
     {
        public override void SendEmai()
        {
            throw new NotImplementedException();
        }

        public override void ReveiveEmail()
        {
            throw new NotImplementedException();
        }
    }

     /**/ /// <summary>
    /// 抽象化(Abstraction)角色
    /// </summary>
     public   abstract   class  Email
     {
        private EmailAction emial;

        public EmailAction EmailAction
        {
            get { return emial; }
            set { emial = value; }
        }

        public virtual void SendEmal()
        {
            emial.SendEmai();
        }

        public virtual void ReveiveEmail()
        {
            emial.ReveiveEmail();
        }
    }

     /**/ /// <summary>
    /// 修正抽象化(Refined Abstraction)角色
    /// </summary>
     public   class  MyEmail:Email
     {
        public override void SendEmal()
        {
            Console.WriteLine("更改了实现");
        }
    }
// 调用
            Bll.Bridge.MyEmail myEmail  =   new  Bll.Bridge.MyEmail();
            myEmail.EmailAction  =   new  Bll.Bridge.ChinaEmail();
            myEmail.SendEmal();
            myEmail.ReveiveEmail();

            myEmail.EmailAction  =   new  Bll.Bridge.AmericaEmail();
            myEmail.SendEmal();
            myEmail.ReveiveEmail();

4：使用场景
      如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。
      设计要求实现化角色的任何改变不应当影响客户端，或者说实现化角色的改变对客户端是完全透明的。
      一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。
     虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。