Design Patterns

---

工厂模式

工厂模式，定义一个创建对象的接口，让子类决定实现哪一个类

使一个类的实例化延迟到其子类

/// 
/// Factory Pattern/// 工厂模式，定义一个创建对象的接口，让子类决定实现哪一个类/// 使一个类的实例化延迟到其子类/// 简单工厂模式不符合开放封闭原则，即对拓展开放，对修改封闭/// 
namespace _02_FactoryPattern{    /// 
    /// Opreation Class 运算类    /// 
    class Operation    {        private double _optionA;        private double _optionB;        public double OptionA        {            get { return _optionA; }            set { _optionA = value; }        }        public double OptionB        {            get { return _optionB; }            set { _optionB = value; }        }        /// 
        /// Calculations        /// 
        public virtual double GetResult()        {            double result = 0;            return result;        }    }    /// 
    /// Addtion Class    /// 
    class OperationAdd : Operation    {        public override double GetResult()        {            double result = OptionA + OptionB;            return result;        }    }    /// 
    /// Sub Class    /// 
    class OperationSub : Operation    {        public override double GetResult()        {            double result = 0;            result =  OptionA - OptionB;            return result;        }    }    /// 
    /// Factory Interface    /// 
    interface IFactory    {        Operation CreateOperation();    }    /// 
    /// Add Factory    /// 
    class AddFactory : IFactory    {        public Operation CreateOperation()        {            return new OperationAdd();        }    }    /// 
    /// Sub Factory    /// 
    class SubFactory : IFactory    {        public Operation CreateOperation()        {            return new OperationSub();        }    }    class Program    {        static void Main(string[] args)        {            //生成一个减的工厂            IFactory factory = new SubFactory();            //拿到这个工厂的实例            Operation oper = factory.CreateOperation();            //计算            oper.OptionA = 1;            oper.OptionB = 3;            double result = oper.GetResult();            WriteLine(result.ToString());            ReadKey();        }    }}

　

抽象工厂模式

提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类

/// 
/// 抽象工厂模式/// 提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类/// 
namespace _04_AbstractFactoryPattern{    /// 
    /// 用户类    /// 
    class User    {        private int _id;        private string _name;        public int Id { get => _id; set => _id = value; }        public string Name { get => _name; set => _name = value; }    }    /// 
    /// IUser接口，用于客户端的访问，解除与具体数据库访问的耦合    /// 
    interface IUser    {        void Insert(User user);        User GetUser(int id);    }    /// 
    /// Sql Server类    /// 
    class SqlServerUser : IUser    {        public void Insert(User user)        {            Console.WriteLine("在Sql Server数据库中添加了一个user");        }        public User GetUser(int id)        {            Console.WriteLine("在Sql Server数据库中根据ID拿到了一个User");            return null;        }    }    /// 
    /// 修改程序为Access数据库访问    /// 
    class AccessUser : IUser    {        public void Insert(User user)        {            Console.WriteLine("Access数据库中添加了一个user");        }        public User GetUser(int id)        {            Console.WriteLine("Access数据库中根据ID拿到了一个User");            return null;        }    }    interface IFactory    {        IUser CreaterUser();    }    class SqlFactory : IFactory    {        public IUser CreaterUser()        {            return new SqlServerUser();        }    }    class AccessFactory : IFactory    {        public IUser CreaterUser()        {            return new AccessUser();        }    }    class Program    {        static void Main(string[] args)        {            User user = new User();            IFactory factory = new AccessFactory();            IUser iUser = factory.CreaterUser();            iUser.Insert(user);            iUser.GetUser(1);            Console.ReadKey();        }    }}