工厂模式

工厂模式应该是用的频次最高的，他管理着对对象的创建。下面简单介绍下简单工厂、工厂方法、抽象工厂。

一、简单工厂应该是其中最简单最直接明了的，一个接口、N个实现，再一组装就好了。

 public interface ICalculator { decimal Calculator(params decimal[] items); }

    public class AddConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x + y);
        }
    }

    public class SubConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x - y);
        }
    }
    public class MulConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x * y);
        }
    }
    
    public class DivConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x / y);
        }
    }

    public enum Operator
    {
        Add,Sub,Mul,Div
    }

上面的代码应该是最底层的支柱，下面的代码就是简单工厂的精髓了，其中判断部分可以通过配置文件、反射或者其他的各种实现。

   public class SimpleFactory
    {
        public static decimal Calculator(Operator @operator,params decimal[] items)
        {
          
            switch (@operator)
            {
                case Operator.Add:
                    return new AddConcrete().Calculator(items);
                case Operator.Sub:
                    return new SubConcrete().Calculator(items);

                case Operator.Mul:
                    return new MulConcrete().Calculator(items);
                    
                case Operator.Div:
                    return new DivConcrete().Calculator(items);
                default:
                    throw new ArgumentNullException(nameof(Operator));
            }
        }
    }

客户端实现

SimpleFactory.Calculator(Operator.Add,1,2,3,4,5);

二、工厂方法

工厂方法应该是在抽象工厂这里重现包了一层，增加了代码的复杂度，三类工厂最大的区别应该是在于最高成模块的灵活性，也就是客户端上面的灵活扩展。

工厂方法代码如下，底层部分还是一样

 public interface ICalculator { decimal Calculator(params decimal[] items); }

    public class AddConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x + y);
        }
    }

    public class SubConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x - y);
        }
    }
    public class MulConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x * y);
        }
    }
    
    public class DivConcrete : ICalculator
    {
        public decimal Calculator(params decimal[] items)
        {
            return items.Aggregate((x, y) => x / y);
        }
    }

    public enum Operator
    {
        Add,Sub,Mul,Div
    }

下面就是工厂方法的关键代码，首先引入了一个工厂接口IFactory

   public interface IFactory { ICalculator Create(); }

下面那把底层的代码套一层

   public class DivFactory : IFactory
    {
        public ICalculator Create()
        {
            return new DivConcrete();
        }
    }
    public class MulFactory : IFactory
    {
        public ICalculator Create()
        {
            return new MulConcrete();
        }
    }

    public class SubFactory : IFactory
    {
        public ICalculator Create()
        {
            return new SubConcrete();
        }
    }

    public class AddFactory : IFactory
    {
        public ICalculator Create()
        {
            return new AddConcrete();
        }
    }

客户端实现就是这样的了,需要什么工厂就在客户端直接造一个工厂，至于其他的工厂或者新增都不会影响原来的代码，扩展性优于简单工厂，简单工厂需要扩展的话会改变修改代码。但是老生常谈，扩展性好结构肯定会复杂一下。

IFactory addFactory = new AddFactory();

addFactory.Create().Calculator(1,2,3,4,5);

三、抽象工厂

抽象工厂跟工厂方法基本上是一样的东西，他是负责一系列同类型的对象的创建。可以说工厂方法是抽象工厂的一个特例，工厂方法只负责创建一对一的对象。

因为抽象工厂通过计算器来实现已经不太合适，所以换个例子。

    public interface IProductX { }
    public interface IProductY { }

    public class ProductX_A : IProductX { }
    public class ProductX_B : IProductX { }
    public class ProductY_A : IProductY { }
    public class ProductY_B : IProductY { }

上面是两个接口，可以实现两类对象，有接口就会有对应的实现。下面的抽象工厂就负责分配实体类的实例。

  public interface IFactory
    {
        IProductX CreateXSeries();
        IProductY CreateYSeries();
    }

实现IFactory就是抽象工厂的职责，这里也是套一层逻辑，通过相同的业务输出同一类的工厂。

  public class FactoryB : IFactory
    {
        public IProductX CreateXSeries()
        {
            return new ProductX_B();
        }

        public IProductY CreateYSeries()
        {
            return new ProductY_B();
        }
    }

    public class FactoryA : IFactory
    {
        public IProductX CreateXSeries()
        {
            return new ProductX_A();
        }

        public IProductY CreateYSeries()
        {
            return new ProductY_A();
        }
    }

客户端实现，这里并不关系底层是什么，只是从factory层面去获取我们想要的product。只不过每个factory都会实现一些列的product,要么productX_A和ProductY_A,,要门ProductX_B和productY_B，这都是提前归类好的。

   　　　　  IFactory factory = new FactoryA();
            var xa = factory.CreateXSeries();
            var ya = factory.CreateYSeries();

            factory = new FactoryB();
            var xb = factory.CreateXSeries();
            var yb = factory.CreateYSeries();

总结，这三类工厂关注点都是对象的创建，归类于创建型设计模式。类似的，我们不仅仅对对象进行抽象重建，还可以对方法也做抽象重建。

比如下面的代码，看过前面的应该很眼熟了

interface IFactory<T>{ T Create();}

public delegate decimal CalculateHandler(params decimal[] items);

class Calculator
{
　　//实现略
　　public decimal Add(params decimal[] items){ return 0;}

}

class CalculateHandlerFactory:IFactory<CalculateHandler>
{

　　public CalculateHandler Create()
　　{
　　　　return new Calculator().Add;
　　}
}

IFactory<CalculateHandler> factory = new  CalculateHandlerFactory();

factory.Create()(1,2,3,4);