我读设计模式之Bridge模式

      实现系统可能有多角度分类，每一种分类都有可能变化，那么就把这种多角度分离出来让他们独立变化，减少他们之间的耦合。   
体现了：优先使用组合而不是继承的设计原则   
一般实现：

using System;   
  
namespace BridgePattern   
{   
    class Program   
    {   
        static void Main(string[] args)   
        {   
            ILog log = new DataBaseLog(new NetLog());   
            log.Write("logMsg");   
  
            ILog log2 = new DataBaseLog(new JavaLog());   
            log2.Write("logMsg");   
  
            Console.Read();   
        }   
    }   
  
    public interface ILog   
    {   
        void Write(string logMsg);   
    }   
  
    public class DataBaseLog : ILog   
    {   
        IPlatform plat;   
  
        public DataBaseLog(IPlatform p)   
        {   
            this.plat = p;   
        }   
  
        public void Write(string logMsg)   
        {   
            plat.ExecuteLog(logMsg);   
        }   
    }   
  
    public class FileLog : ILog   
    {   
          IPlatform plat;   
  
          public FileLog(IPlatform p)   
        {   
            this.plat = p;   
        }   
  
        public void Write(string logMsg)   
        {   
             plat.ExecuteLog(logMsg);   
        }   
    }   
  
    public interface IPlatform   
    {   
        void ExecuteLog(string log);   
    }   
  
    public class NetLog : IPlatform   
    {   
       public void ExecuteLog(string log)   
        {   
            Console.WriteLine("Net  Log");   
        }   
    }   
  
    public class JavaLog : IPlatform   
    {   
        public void ExecuteLog(string log)   
        {   
            Console.WriteLine("Java  Log");   
        }   
    }   
}  

实例：

using System;   
  
///实现系统可能有多角度分类，每一种分类都有可能变化，那么就   
///把这种多角度分离出来让他们独立变化，减少他们之间的耦合。   
///体现了：优先使用组合而不是继承的设计原则   
///-========================--   
///举例：   
///Tms入库作业：   
///1.入库作业可以分为cell,mod入库作业，而cell,mod又可分为良品和报废品入库；   
///2.其中可能增加【array入库】作业（前一种分类）；   
///3.也有可能增加【待测品】入库（后一种分类）   
///4.假设cell,mod的良品和报废品入库方式一致   
///   
namespace BridgePattern   
{   
    class Demo1   
    {   
        static void Main()   
        {   
            产品 p = new 良品入库();   
            产品入库 入库 = new Cell半成品入库();   
            入库.设置产品入库(p);   
  
            入库.执行入库();   
  
  
            p = new 待检品入库();   
            入库 = new Array品入库();   
            入库.设置产品入库(p);   
            入库.执行入库();   
  
            Console.Read();   
        }   
    }   
  
    public abstract class 产品入库   
    {   
        public 产品 product;   
  
        public void 设置产品入库(产品 p)   
        {   
            this.product = p;   
        }   
  
        public virtual void 执行入库()   
        {   
        }   
    }   
  
    public class Cell半成品入库 : 产品入库   
    {   
        public override void 执行入库()   
        {   
            product.执行产品入库("半成品cell入库");   
        }   
    }   
  
    public class Mod成品入库 : 产品入库   
    {   
        public override void 执行入库()   
        {   
            product.执行产品入库("Mod成品入库");   
        }   
    }   
  
    /// <summary>   
    /// 扩展   
    /// </summary>   
    public class Array品入库 : 产品入库   
    {   
        public override void 执行入库()   
        {   
            product.执行产品入库("Array品入库");   
        }   
    }   
  
    public abstract class 产品   
    {   
        public virtual void 执行产品入库(string goodsMsg)   
        {   
        }   
    }   
  
    public class 良品入库 : 产品   
    {   
        public override void 执行产品入库(string goodsMsg)   
        {   
            Console.WriteLine("良品入库:" + goodsMsg);   
        }   
    }   
  
    public class 报废品入库 : 产品   
    {   
        public override void 执行产品入库(string goodsMsg)   
        {   
            Console.WriteLine("报废品入库:" + goodsMsg);   
        }   
    }   
  
    /// <summary>   
    /// 扩展   
    /// </summary>   
    public class 待检品入库 : 产品   
    {   
        public override void 执行产品入库(string goodsMsg)   
        {   
            Console.WriteLine("待检品入库:" + goodsMsg);   
        }   
    }   
  
  
}