简单工厂、工厂模式、抽象工厂模式

简单工厂模式

public class Operation{
    private double numberA=0;
    private double numberB=0;
    public double NumberA{
        get{return numberA;}
        set{numberA=value;}
    }
    public double NumberB{
        get{return numberB;}
        set{numberB=value;}
    }
    public virtual double GetResult(){
        double result=0;
        return result;  
    }
}

//加减乘除类
class OperationAdd:Operation{
    public override double GetResult(){
        double result=0;
        result=NumberA+NumberB;
        return result;
    }
}

class OperationSub:Operation{
    public override double GetResult(){
        double result=0;
        result=NumberA-NumberB;
        return result;
    }
}

class OperationMul:Operation{
    public override double GetResult(){
        double result=0;
        result=NumberA*NumberB;
        return result;
    }
}

class OperationDiv:Operation{
    public override double GetResult(){
        double result=0;
        result=NumberA/NumberB;
        return result;
    }
}

public class OperationFactory{

    public static Operation createOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
            case "+":
                {
                oper = new OperationAdd();
                break;
                }
            case "-":
                {
                oper = new OperationSub();
                break;
                }
            case "*":
                {
                oper = new OperationMul();
                break;
                }
            case "/":
                {
                oper = new OperationDiv();
                break;
                }
        }
        return oper;
    }
}


//客户端代码
Operation oper;
oper=OperationFactory.createOperate("+");
oper.NumberA=1;
oper.NumberB=2;
double result=oper.GetResult;
//只需输入运算符号，工厂就实例化合适的对象，通过多态，
返回父类的方式实现了计算器结果

---

工厂模式

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

    public class Operation
    {
        private double numberA = 0;
        private double numberB = 0;
        public double NumberA
        {
            get { return numberA; }
            set { numberA = value; }
        }
        public double NumberB
        {
            get { return numberB; }
            set { numberB = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

    //加减乘除类
    class OperationAdd : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperationSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    //先构建工厂接口
    interface IFactory
    {
        Operation CreateOperation();
    }
    //加减乘除各建一个具体工厂去实现这个接口
    class AddFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }
    class SubFactory : IFactory
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IFactory operFactory = new AddFactory();
            Operation oper = operFactory.CreateOperation();
            oper.NumberA = 1;
            oper.NumberB = 2;
            double result = oper.GetResult();
            Console.WriteLine(result);
            Console.Read();
        }
    }

---

抽象工厂模式

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

    class Department
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }
        private string deptName;
        public string DeptName
        {
            get { return deptName; }
            set { deptName = value; }
        }
    }

    interface IDepartment
    {
        void Insert(Department department);

        Department GetDepartment(int id);
    }

    class SqlserverDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在SQL Server中给Department表增加一条记录");
        }

        public Department GetDepartment(int id)
        {
            Console.WriteLine("在SQL Server中根据ID得到Department表增加一条记录");
            return null;
        }    
    }

    class AccessDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在Access中给Department表增加一条记录");
        }

        public Department GetDepartment(int id)
        {
            Console.WriteLine("在Access中根据ID得到Department表增加一条记录");
            return null;
        }
    }

    class User
    {
        private int id;
        private string name;

        public int Id
        {
            get{ return id;}
            set{ id = value;}
        }

        public string Name
        {
            get{ return name;}
            set{ name = value;}
        }
    }

    interface IUser
    {
        void Insert(User user);

        User GetUser(int id); 
    }

    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;
        }
    }

    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 CreateUser();
        IDepartment CreateDepartment();
    }

    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlServerUser();
        }
        public IDepartment CreateDepartment()
        {
            return new SqlserverDepartment();
        }
    }

    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            User user=new User();
            Department dept = new Department();

            //IFactory factory=new SqlServerFactory();
            IFactory factory = new AccessFactory();//只需确定实例化哪一个数据库访问对象给factory

            IUser iu = factory.CreateUser();//此时已与具体数据库访问解除了依赖
            iu.Insert(user);
            iu.GetUser(1);

            IDepartment id = factory.CreateDepartment();//此时已与具体数据库访问解除了依赖
            id.Insert(dept);
            id.GetDepartment(1);

            Console.Read();
        }
    }

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。