C# 设计模式 之 抽象工厂模式

        工厂方法模式在于需要根据条件来控制对哪个类进行实例化，而抽象工厂模式确定实例化的往往设计到多个类，目的是创建一组相关或者相互依赖的对象提供支持！重点就是在于处理一组相关或者相互依赖类！

        举一个的经典实例，就是GUI工具箱。一个GUI工具箱就是一个对象，也是一个抽象工厂。GUI工具箱提供了各种GUI控件，并为它们提供了一个基本的东西，比如外观、颜色等。这样，当GUI控件有新版本了，可以再声明一个新的抽象工厂。那么软件就可以根据需要来使用那个一个抽象工厂类了。我们注意到各种GUI控件便是一组相关或者相互依赖类！

        它与工厂方法模式类似，不需要知道该对哪个类进行实例化。抽象工厂为用户提供了一个工厂，这个工厂便可以创建一系列的对象，而这些对象是相关的或是相互依赖的！  

        再看一个代码实例：

using  System;
using  System.Reflection;
using  System.Collections.Generic;
using  System.Text;

namespace  AbstractFactory
... {
    /**//// <summary>
    /// 计算学分
    /// </summary>
    public interface IComputeScore
    ...{
       int ComputeScore();
    }

    /**//// <summary>
    /// 计算基本费用
    /// </summary>
    public interface IComputeFee
    ...{
        decimal ComputeFee();
    }

    /**//// <summary>
    /// 本科生计算学分的操作类
    /// </summary>
    public class UndergraduateScore : IComputeScore
    ...{
        public int ComputeScore()
        ...{
            Console.WriteLine("ComputeUndergraduateScore");
            return 10;
        }
    }  

    /**//// <summary>
    /// 研究生计算学分的操作类
    /// </summary>
    public class GraduateScore : IComputeScore
    ...{
        public int ComputeScore()
        ...{
            Console.WriteLine("ComputeGraduateScore");
            return 20;
        }
    }

    /**//// <summary>
    /// 本科生计算基本费用的操作类
    /// </summary>
    public class UndergraduateFee : IComputeFee
    ...{
        public decimal ComputeFee()
        ...{
            Console.WriteLine("ComputeUndergraduateFee");
            return 100M;
        }
    }

    /**//// <summary>
    ///  研究生计算基本费用的操作类
    /// </summary>
    public class GraduateFee : IComputeFee
    ...{
        public decimal ComputeFee()
        ...{
            Console.WriteLine("ComputeGraduateFee");
            return 200M;
        }
    }

    /**//// <summary>
    /// 计算抽象工厂类，它就包含了创建两个相关的计算类的方法
    /// </summary>
    public abstract class ComputeFactory
    ...{
        public static ComputeFactory GetInstance()
        ...{
            //通过配置文件或者其他方式获得
            //string factoryName = "AbstractFactory.UndergraduateFactory";
            //ComputeFactory instance = (ComputeFactory)Assembly.Load(factoryName).CreateInstance(factoryName);
            ComputeFactory instance = new UndergraduateFactory();
            return instance;
        }

        public abstract IComputeScore CreateComputeScore();
        public abstract IComputeFee CreateComputeFee();
    }

    /**//// <summary>
    /// 本科生计算工厂类
    /// </summary>
     public class UndergraduateFactory : ComputeFactory
     ...{
         public override IComputeScore CreateComputeScore()
         ...{
             return new UndergraduateScore();
         }

         public override IComputeFee CreateComputeFee()
         ...{
             return new UndergraduateFee();
         }
     }

    /**//// <summary>
     /// 研究生计算工厂类
    /// </summary>
    public class GraduateFactory : ComputeFactory
    ...{
        public override IComputeScore CreateComputeScore()
        ...{
            return new GraduateScore();
        }
        public override IComputeFee CreateComputeFee()
        ...{
            return new GraduateFee();
        }
    }

    class Program
    ...{
        static void Main(string[] args)
        ...{
            ComputeFactory computeFactory = ComputeFactory.GetInstance();
            IComputeScore computeScore = computeFactory.CreateComputeScore();
            IComputeFee computeFee = computeFactory.CreateComputeFee();
            int score = computeScore.ComputeScore();
            decimal fee = computeFee.ComputeFee();
            //总费用 = 学分 * 150.0 + 基本费用
            decimal total = score * 150.0M + fee;
            Console.WriteLine(total);
            Console.ReadLine();
        }
    }
}