FactoryPattern-工厂模式

在C#中，工厂模式（Factory Pattern）是一种常用的设计模式，它属于创建型模式。在C#中，工厂模式用于创建对象，而不需要直接使用构造函数来实例化对象。它通过一个工厂类来封装对象的创建逻辑，使得客户端只需要与工厂类交互，而无需关心具体的对象创建过程。

1.简单工厂

简单工厂模式（Simple Factory Pattern）是工厂模式的一种简化形式，通常包含以下几个核心角色：

产品接口（Product Interface）：定义了产品对象的接口，即产品所具有的方法和属性。

具体产品（Concrete Product）：实现产品接口的具体产品类，它是工厂模式所创建的对象。

简单工厂（Simple Factory）：负责创建具体产品对象的工厂类，根据不同的参数或条件来创建不同的具体产品对象。

        //产品接口(汽车)
        interface ICar
        {
            void Produce();
        }
        //具体产品(A型轿车)
        public class CarA : ICar
        {
            public void Produce()
            {
                Console.WriteLine("produce CarA");
            }
        }
        //具体产品(B型轿车)
        public class CarB : ICar
        {
            public void Produce()
            {
                Console.WriteLine("produce CarB");
            }
        }
        //简单工厂(汽车制造工厂)
        class SimpleFactory
        {
            public static ICar CreateProduct(string type)
            {
                switch (type)
                {
                    case "A":
                        return new CarA();
                    case "B":
                        return new CarB();
                    default:
                        throw new ArgumentException("Invalid product type");
                }
            }
        }
        //客户端代码
        static void Main(string[] args)
        {
            //需要A型号汽车
            ICar productA = SimpleFactory.CreateProduct("A");
            productA.Produce();

            //需要B型号汽车
            ICar productB = SimpleFactory.CreateProduct("B");
            productB.Produce();
        }

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。当需要增加产品CraC(C型轿车)时，需要增加工厂的Swith分支。不修改代码的话，是无法扩展的，不符合开闭原则。

2.工厂方法

工厂方法模式（Factory Method Pattern）的核心思想是将对象的创建过程交给子类来完成，从而提供了一种扩展的方式，使得新的子类可以根据需要创建不同的产品对象，而不影响客户端代码。通常包含以下几个核心角色：

产品接口（Product Interface）：定义了产品对象的接口，即产品所具有的方法和属性。

具体产品（Concrete Product）：实现产品接口的具体产品类，它是工厂方法模式所创建的对象。

抽象工厂（Abstract Factory）：定义了一个创建产品对象的抽象方法，让具体工厂子类来实现。

具体工厂（Concrete Factory）：继承抽象工厂类，实现抽象工厂中的抽象方法，负责创建具体的产品对象。

//具体产品(C型轿车)
        public class Carc : ICar
        {
            public void Produce()
            {
                Console.WriteLine("produce CarC");
            }
        }        
        // 抽象工厂
        abstract class Factory
        {
            public abstract ICar CreateProduct();
        }
        // 具体工厂A
        class ConcreteFactoryA : Factory
        {
            public override ICar CreateProduct()
            {
                return new CarA();
            }
        }
        // 具体工厂B
        class ConcreteFactoryB : Factory
        {
            public override ICar CreateProduct()
            {
                return new CarB();
            }
        }
        // 具体工厂C
        class ConcreteFactoryC : Factory
        {
            public override ICar CreateProduct()
            {
                return new CarC();
            }
        }
        //客户端代码
        static void Main(string[] args)
        {
            Factory factoryA = new ConcreteFactoryA();
            ICar productA = factoryA.CreateProduct();
            productA.Produce();

            Factory factoryB = new ConcreteFactoryB();
            ICar productB = factoryB.CreateProduct();
            productB.Produce();

            Factory factoryC = new ConcreteFactoryC();
            ICar productC = factoryC.CreateProduct();
            productC.Produce();
        }

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。符合开闭原则，但随着产品类的增加，对应的工厂也会随之增多。

 3.工厂模式

工厂模式（Factory Pattern）用于创建对象，而不需要直接使用构造函数来实例化对象。它通过一个工厂类来封装对象的创建逻辑，使得客户端只需要与工厂类交互，而无需关心具体的对象创建过程。

工厂模式和工厂方法模式的主要区别在于角色的不同以及使用的场景。

角色的不同：

工厂模式中，通常包含一个抽象工厂类和多个具体工厂类，抽象工厂类定义了一个或多个创建产品对象的抽象方法，而具体工厂类继承抽象工厂类并实现这些抽象方法，负责具体的产品对象的创建。

工厂方法中，通常包含一个抽象工厂类和多个具体工厂类，抽象工厂类定义了创建产品对象的抽象方法，而具体工厂类继承抽象工厂类并实现这个抽象方法，负责具体产品对象的创建。每个具体工厂类对应一个具体的产品类。

 使用的场景：

工厂模式适用于需要创建一族相关或相互依赖的对象的场景。它提供一个抽象的工厂类，通过子类化这个工厂类来创建不同的产品族，具体的产品族由不同的具体工厂类来创建。

工厂方法适用于需要创建单一对象的场景。它将对象的创建延迟到子类中进行实现，使得每个具体工厂类负责创建特定的产品对象。

 创建两个产品系列类，Car和Bus

    public class Car
    {
        public abstract class AbstractCar
        {
            public abstract void Produce();
        }
        public class CarA : AbstractCar
        {
            public override void Produce()
            {
                Console.WriteLine("produce CarA");
            }
        }
        public class CarB : AbstractCar
        {
            public override void Produce()
            {
                Console.WriteLine("produce CarB");
            }
        }
    }

    public class Bus
    {
        public abstract class AbstractBus
        {
            public abstract void Produce();
        }
        public class BusA : AbstractBus
        {
            public override void Produce()
            {
                Console.WriteLine("produce BusA");
            }
        }
        public class BusB : AbstractBus
        {
            public override void Produce()
            {
                Console.WriteLine("produce BusB");
            }
        }
    }

定义产品线，具体工厂宝马和比亚迪分别生产不同系列的Car与Bus

    public interface IAbstractFactoryA
    {
        AbstractCar CreateCar();
        AbstractBus CreateBus();
    }
    public class BMFactory : IAbstractFactoryA
    {
        public AbstractCar CreateCar()
        {
            return new CarA();
        }

        public AbstractBus CreateBus()
        {
            return new BusA();
        }
    }
    public class BYDFactory : IAbstractFactoryA
    {
        public AbstractCar CreateCar()
        {
            return new CarB();
        }

        public AbstractBus CreateBus()
        {
            return new BusB();
        }
    }

客户端代码

        static void Main(string[] args)
        {
            BMFactory bMFactory = new BMFactory();
            bMFactory.CreateCar();
            bMFactory.CreateBus();

            BYDFactory bYDFactory = new BYDFactory();
            bYDFactory.CreateCar();
            bYDFactory.CreateBus();
        }