[C#]设计模式 之 工厂模式

void Main()
{
  TestSimpleFactory();
}
/// <summary>
/// 测试简单工厂模式
/// </summary>
private static void TestSimpleFactory()
{
  Console.WriteLine("简单工厂模式：");
  var productA = SimpleFactory.Create(ProductEnum.ConcreateProductA);
  productA.GetInfo();
  Console.ReadLine();
}
/// <summary>
    /// 产品枚举
    /// </summary>
    public enum ProductEnum
    {
        ConcreateProductA,
        ConcreateProductB
    }
public class ConcreateCarA:AbstractCar
{
  
}
public class ConcreateCarB:AbstractCar
{

}
public class AbstractCar
{
  internal void GetInfo()
  {
    Console.WriteLine(  DateTime.Now);
  }
}
/// <summary>
/// 简单工厂模式：
/// 简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。
/// 不修改代码的话，是无法扩展的。（如果增加新的产品，需要增加工厂的Swith分支）
/// 不符合【开放封闭原则】
/// </summary>
public static class SimpleFactory
{
  public static AbstractCar Create(ProductEnum productType)
  {
    switch (productType)
    {
      case ProductEnum.ConcreateProductA:
        return new ConcreateCarA();
      case ProductEnum.ConcreateProductB:
        return new ConcreateCarB();
      default:
        return null;
    }
  }
}

简单工厂模式运行结果

void Main()
{
  TestReflectFactory();
}
namespace FactoryPattern
{

  public class ConcreateCarA : AbstractCar
  {
    public override void GetInfo()
    {
      Console.WriteLine("ConcreateCarA" + "\r\n" + DateTime.Now);
    }
  }
  public class ConcreateCarB : AbstractCar
  {
    public override void GetInfo()
    {
      Console.WriteLine("ConcreateCarB" + "\r\n" + DateTime.Now);
    }
  }
  public class AbstractCar
  {
    public virtual void GetInfo()
    {
      Console.WriteLine(DateTime.Now);
    }
  }
}
/// <summary>
/// 反射工厂模式
/// 是针对简单工厂模式的一种改进
/// </summary>
public static class ReflectFactory
{
  public static AbstractCar Create(string typeName)
  {
    Type type = Type.GetType(typeName);
    var instance = type?.Assembly.CreateInstance(typeName) as AbstractCar;
    return instance;
  }
}
/// <summary>
        /// 测试反射工厂模式
        /// </summary>
 static void TestReflectFactory()
{
  Console.WriteLine("反射工厂模式：");
  var productB = ReflectFactory.Create("FactoryPattern.ConcreateCarB");
  productB.GetInfo();
  Console.ReadLine();
}

    /// <summary>
    /// 工厂方法模式：
    /// 工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。
    /// 在同一等级结构中，支持增加任意产品。
    /// 符合【开放封闭原则】，但随着产品类的增加，对应的工厂也会随之增多
    /// </summary>
    public interface IFactoryMethod
    {
        AbstractCar Create();
    }

    public class ConcreateFactoryA:IFactoryMethod
    {
        public AbstractCar Create()
        {
            return new ConcreateCarA();
        }
    }

    public class ConcreateFactoryB : IFactoryMethod
    {
        public AbstractCar Create()
        {
            return new ConcreateCarB();
        }
    }

        /// <summary>
        /// 测试工厂方法模式
        /// </summary>
        private static void TestFactoryMethod()
        {
            Console.WriteLine("工厂方法模式：");
            IFactoryMethod factoryB =new ConcreateFactoryB();
            var productB = factoryB.Create();
            productB.GetInfo();

            Console.ReadLine();
        }

    /// <summary>
    /// 抽象工厂模式：
    /// 抽象工厂是应对产品族概念的，比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
    /// 应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
    /// </summary>
    public interface IAbstractFactory
    {
        AbstractCar CreateCar();
        AbstractBus CreateBus();
    }

    /// <summary>
    /// 宝马工厂
    /// </summary>
    public class BMWFactory:IAbstractFactory
    {
        public AbstractCar CreateCar()
        {
            return new ConcreateCarA();
        }

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

    /// <summary>
    /// 比亚迪工厂
    /// </summary>
    public class BYDFactory : IAbstractFactory
    {
        public AbstractCar CreateCar()
        {
            return new ConcreateCarB();
        }

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

        /// <summary>
        /// 测试抽象工厂模式
        /// </summary>
        private static void TestAbstractFactory()
        {
            Console.WriteLine("抽象工厂模式：");

            var bmwFactory = new BMWFactory();
            bmwFactory.CreateCar().GetInfo();
            bmwFactory.CreateBus().GetInfo();

            var bydFactory = new BYDFactory();
            bydFactory.CreateCar().GetInfo();
            bydFactory.CreateBus().GetInfo();

            Console.ReadLine();
        }