设计模式实践反射到所有接口实现类实践工厂方法，页面中有大量计算数据时设计实践

平时在开发中会经常用到设计模式，有朋友建议把平时工作中用到的设计模式的实践都记录下来分享出来，同时也可以激励自己，时常反省自己的设计是不是还可以重构的更好。

现在说一下我使用反射得到所有实现了指定接口类的简单工厂模式，设计它的原因是我需要做一个财务的页面，在这个页面需要显示43个数据，这43个数据的来源都是各自独立的，基本上都是一些特殊的统计和汇总的值。简单的想法是设计方法是实现一个类，在这个类中写入43个方法，在这43个方法中有各自的计算的实现，然后写一个满满的几千行的类，挺恐怖的，但是确定了这些方法中的算法是没有问题的，计算所得的结果也是正确的。接下来我对它进行重构，使它更清晰。

接下来我设计了一个接口，这个接口中有一个计算方法，并且接收一个参数对象。看起来象这样子：

public class FinanceArg
{
    public double Year { get; set; }
    public double Month { get; set; }
}

public interface IFinance
{
    public double GetData(FinanceArg arg);
}

现在我把每一种计算方法都继承自IFinance，然后实现其中的GetData数据。

这样当用户需要在增加一种方法的时候就可以将直接扩展一个类，如果是用户需要修改某一种统计方法时，也可以重新做一个类，然后客户修改调用就可以了。

//合计收入
public class Income : IFinance
{
    public double GetData(FinanceArg arg)
}

//合计支付
public class Payment : IFinance
{
    public double GetData(FinanceArg arg)
}

接下来设计一个工厂类来实现这些对象的实例，我使用了.NET的反射方法，通过客户端给定的类名在程序集中查找类然后调用，方法类似下面的：

public static class FinanceFactory
{
    public static IFinance CreateInstance(string assembly, string typeName)
    {
        return (IFinance)Assembly.Load(assembly).CreateInstance(typeName);
    }
}

这样就实现了一个标准的工厂方法，本来呢到这里应该就结束了。但是我个人觉得为页面中每个标签都调用这个确实很麻烦，所以就想了另一种方法

（个人实践）

先在程序集中把所有继承了指定接口的类找到，放到缓存里，然后调用的时候就直接拿出来。修改后如下：

public class FinanceArg
{
    public double Year { get; set; }
    public double Month { get; set; }
    public string TypeName { get; set; }
}

public static class FinanceFactory
{
    private static Dictionary<string, IFinance> _dataSourceDict;

    /// <summary>
    /// 初始化工厂类时时缓存所有指定程序集中继承了指定接口的全部类
    /// </summary>
    public static FinanceFactory(string assemblyName, string interfaceName)
    {
        Assembly assembly = Assembly.Load(assemblyName);

        _dataSourceDict = GetInstanceByImplementsInterface<IFinance>(assembly, interfaceName)
            .ToDictionary(type => type.GetType().Name);
    }
    /// <summary>
    /// 反射找到继承了指定接口的所有类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="assembly"></param>
    /// <param name="interfaceName"></param>
    /// <returns></returns>
    private static IEnumerable<T> GetInstanceByImplementsInterface<T>(Assembly assembly, string interfaceName)
    {
        Type[] types = assembly.GetTypes();
        TypeFilter myFilter = new TypeFilter((x, y) => x.ToString() == y.ToString());
        foreach (Type type in types)
            foreach (Type t in type.FindInterfaces(myFilter, interfaceName))
                yield return (T)assembly.CreateInstance(type.FullName);
    }
    /// <summary>
    /// 调用方法
    /// </summary>
    /// <param name="arg"></param>
    /// <returns></returns>
    public static double GetTotal(FinanceArg arg)
    {
        if (_dataSourceDict.ContainsKey(arg.TypeName))
            return _dataSourceDict[arg.TypeName].GetData(arg);

        return -1;
    }

这里我为参数增加了实例哪个类的参数，客户端调用的时候传入实现的类，这样子不就又耦合了吗，嗯，的确是但是这是因为我为了在前台与页面的标签名相匹配。为什么要与前台页面的标签名所匹配呢，因为我打算让前台的页面的标签名可以通过AJAX自动的调用后端的同名的类，这是一个约定胜于配置的实践，我让页面的标签和后台的类约定好名字，然后就可以在前台使用AJAX调用了，当需要增加一项数据统计时可以在页面上增加一个span标签，然后在类中实现一个与该SPAN名字相同的继承了IFinance的类，系统会自动的匹配这两者，然后进行调用，具体的代码如下：

<table>
    <tr>
        <td>收入：</td>
        <td><span id="Income" class="remoting" /></td>
    </tr>
    <tr>
        <td>支出：</td>
        <td><span id="Payment" class="remoting" /></td>
    </tr>
</table>
<script type="text/javascript">       $(".remoting").each(function(){         $(this).load("GetData.ashx", {year:'2011', month:'7', typeName=$(this).attr('id'), rnd:Math.random()});     });</script>

页面中的大概情况就是这样子，当然约定是自己定义的，只要和页面设计者约定好就可以了，也不一定是id，也可以是某个attribute。

其中的GetData.ashx则简单的多了，只需要在接收到AJAX过来的参数直接交给Factory，然后输出数据就可以了。

总结一下：在实际项目中并不能能死搬硬套一个模式，而应该根据实际项目灵活运用，甚至可以将多个原则组合起来运用。本例中就使用了类的单一职责，分离关注点，约定胜于配置这些原则，并融合了工厂模式来实现这个应用。前台则使用AJAX来异步调用使得在很大计算量的前提下还可以保持页面的载入速度和整体运行效果。并且可以单独测试某项数据的读取和计算速度并进行优化（在实际项目中我对一些计算量比较大的类使用了并行计算）。