C#设计模式——简单工厂模式、工厂模式和抽象工厂模式

一：简单工厂模式

　　1：描述：简单工厂模式是由一个工厂对象根据接收到的消息决定要创建哪一个类的对象事例。

　　2：优点：工厂类中有相关逻辑判断，可以根据需要动态创建相关的对象事例，而客户端只需要告诉工厂类创建什么对象事例，而不关心怎么创建，当需要引入新产品就不需要修改客户端的代码，只需要添加相应的产品类并修改工厂类就可以，所以从产品的角度上简单工厂模式是符合“开-闭”原则的。

　　3：缺点：很容易违反高内聚低耦合的原则，一旦添加新产品就不得不修改工厂逻辑，当产品类型较多时，有可能造成工厂逻辑比较复杂，不利于系统的扩展和维护，所以从工厂的角度来说简单工厂模式是不符合“开-闭”原则的。

　　4：例子：

namespace SimpleFactoryDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            ShapeFactory shapeFactory = new ShapeFactory();
            shapeFactory.getShape("circle").draw();
            shapeFactory.getShape("rectangle").draw();
            shapeFactory.getShape("square").draw();
            Console.ReadKey();
        }
    }
    public interface IShape
    {
        void draw();//默认公共方法
    }
    public class Circle : IShape
    {
        public void draw()
        {
            Console.WriteLine("画个圆");
        }
    }
    public class Rectangle : IShape
    {
        public void draw()
        {
            Console.WriteLine("画个长方形");
        }
    }
    public class Square : IShape
    {
        public void draw()
        {
            Console.WriteLine("画个正方形");
        }
    }
    public class ShapeFactory//形状工厂
    {
        public IShape getShape(string type)
        {
            if ("circle".Equals(type))
            {
                return new Circle();
            }
            else if ("rectangle".Equals(type))
            {
                return new Rectangle();
            }
            else if ("square".Equals(type))
            {
                return new Square();
            }
            else
            {
                return null;
            }
        }
    }
}

二：工厂模式

　　1：描述：定义一个创建对象的工厂接口，让子类决定实例化哪个类，将实际创建工作推迟到子类中。

　　2：优点：创建对象的接口，让子类决定具体实例化的对象，把简单的内部逻辑移动到客户端，工厂方法克服了简单工厂所违背的的开闭原则的缺点，扩展性高，易于维护，想要增加一个产品，只需要增加一个工厂类即可。

　　3：例子：

namespace FactoryDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            IShapeFactory circleFactory = new CircleFactory();
            circleFactory.getShape().draw();
            IShapeFactory rectangleFactory = new RectangleFactory();
            rectangleFactory.getShape().draw();
            IShapeFactory squareFactory = new SquareFactory();
            squareFactory.getShape().draw();
            Console.ReadKey();
        }
    }
    public interface IShape
    {
        void draw();//默认公共方法
    }
    public class Circle : IShape
    {
        public void draw()
        {
            Console.WriteLine("画个圆");
        }
    }
    public class Rectangle : IShape
    {
        public void draw()
        {
            Console.WriteLine("画个长方形");
        }
    }
    public class Square : IShape
    {
        public void draw()
        {
            Console.WriteLine("画个正方形");
        }
    }
    public interface IShapeFactory//形状工厂接口
    {
        IShape getShape();
    }
    public class CircleFactory : IShapeFactory
    {
        public IShape getShape()
        {
            return new Circle();
        }
    }
    public class RectangleFactory : IShapeFactory
    {
        public IShape getShape()
        {
            return new Rectangle();
        }
    }
    public class SquareFactory : IShapeFactory
    {
        public IShape getShape()
        {
            return new Square();
        }
    }
}

三：抽象工厂模式

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

　　2：优点：（1）：当一个产品族中的多个对象被设计在一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

　　　　　　  （2）：具有工厂方法模式解耦的优点。

　　　　　　  （3）：工厂方法模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构，最主要的是可以在类的内部对产品族的关联关系进行定义和描述。

　　3：例子：以生产两款车子为例，一个工厂生产宝马和比亚迪两款汽车，同时生产国产和进口两种发动机。

namespace AbstractFactoryDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            IFactory carAFactory = new CarA();
            carAFactory.ProductCar().ProductCar();
            carAFactory.ProductEngine().ProductEngine();

            IFactory carBFactory = new CarB();
            carBFactory.ProductCar().ProductCar();
            carBFactory.ProductEngine().ProductEngine();

            Console.ReadKey();

        }
    }
    public interface ICarFactory
    {
        void ProductCar();
    }
    public class BMWCar : ICarFactory
    {
        public void ProductCar()
        {
            Console.Write("宝马汽车:");
        }
    }
    public class BYDCar : ICarFactory
    {
        public void ProductCar()
        {
            Console.Write("比亚迪汽车:");
        }
    }
    public interface IEngineFactory
    {
        void ProductEngine();
    }
    public class DomesticEngine : IEngineFactory
    {
        public void ProductEngine()
        {
            Console.WriteLine("国产发动机");
        }
    }
    public class ImportEngine : IEngineFactory
    {
        public void ProductEngine()
        {
            Console.WriteLine("进口发动机");
        }
    }
    public interface IFactory
    {
        ICarFactory ProductCar();
        IEngineFactory ProductEngine();
    }
    public class CarA : IFactory//宝马汽车，进口发电机
    {
        public ICarFactory ProductCar()
        {
            return new BMWCar();
        }
        public IEngineFactory ProductEngine()
        {
            return new ImportEngine();
        }
    }
    public class CarB : IFactory//比亚迪汽车，国产发电机
    {
        public ICarFactory ProductCar()
        {
            return new BYDCar();
        }
        public IEngineFactory ProductEngine()
        {
            return new DomesticEngine();
        }
    }
}

四：总结

1：无论是简单工厂模式，工厂模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上都极为相似，他们的最终目的都是为了解耦，所以在实际开发中灵活运用工厂模式，达到降低耦合度的目的。