抽象工厂

其实一个简单的计算器就足够了，但是设计模式让它变得越来越复杂了。

 public interface ICalculator
    {
        decimal Invoke(params decimal[] args);
    }
    public class AddCal : ICalculator
    {
        public decimal Invoke(params decimal[] args)
        {
            return args.Aggregate((x, y) => x + y);
        }
    }

 ICalculator calculator = new AddCal();
            calculator.Invoke(1, 2, 3, 4, 5);

上面代码忽略减乘除实现，面向对象思维入门级代码。

面向对象感觉最难的应该就是处理对象与对象之间的关系，而这个所谓关系正好就覆盖到了整个项目的全部。为什么现在不用面向过的思维来解决问题，一个道理吧。简单or复杂都有自己的代价。

抽象工厂代码实现如下：

 public delegate int CalculateHandler(params int[] items);
    public interface IF<T>
    {
        public T Create();

    }
    public class Calculate
    {
        public int Add(params int[] items)
        {
            return items.Aggregate((x, y) => x + y);
        }
    }
    public class CalculateF : IF<CalculateHandler>
    {
        private Calculate _calculate;
        public CalculateF(Calculate calculate)
        {
            _calculate = calculate;
        }
        public CalculateHandler Create()
        {
            return _calculate.Add;
        }
    }

 IF<CalculateHandler> ch = new CalculateF(new Calculate());
            var result = ch.Create();
            Trace.WriteLine(result.Invoke(1, 2, 3, 4, 5));

这里的实现其实跟上面的ICalculator的接口实现是一回事，只不过在具体的实现层面加了一层判断，把创建类封装起来了，通过参数注入，这里复杂的部分还是怎么去抽象出来实体类，毕竟不是结果或者行为型模式，关注点还是在于对象的创建。

所以客户端代码比上面对了一层new对象。

这个代码可以继续衍生一下才能体现出来抽象工厂的优势，要不然就用开头的第一种了，简单又方便：

public interface IF<in M,out T> { T Create(M cal); } //多元化
    public class FI : IF<ICal,CalHandler>
    {
        public CalHandler Create(ICal cal)
        {
           return cal.Invoke;
        }
    }
    public interface ICal
    {
        decimal Invoke(params decimal[] args);
    }
    public delegate decimal CalHandler(params decimal[] args);
    public interface IPrint
    {
        void Print(string str);
    }
    public delegate void PrintHandler(string str);
    public class FII : IF<IPrint, PrintHandler>
    {
        public PrintHandler Create(IPrint cal)
        {
            return cal.Print;
        }
    }
    public class PrintScreen : IPrint
    {
        public void Print(string str)
        {
            Trace.WriteLine(str);
        }
    }

    public class AddCal : ICal
    {
        public decimal Invoke(params decimal[] args)
        {
            return args.Aggregate((x, y) => x = y);
        }
    }

    　　　　IF<IPrint, PrintHandler> iFi = new FII();
            IPrint print = new PrintScreen();
            iFi.Create(print).Invoke("hello world");
            IF<ICal, CalHandler> iFii = new FI();
            ICal cal = new AddCal();
            iFii.Create(cal).Invoke(1, 2, 3, 4, 5);

总结：

任何功能实现应该都离不开方法的执行，对象作为行为的载体，承载了太多的角色扮演，所以对象和对象之间的关系很复杂，学习设计模式应该是个捷径。