解读设计模式----抽象工厂模式(AbstractFactory Pattern)

一、模式描述
      我的程序中有需要一系列的对象，比如我们要吃一碗米饭(Rice),要喝一杯咖啡(Coffee)......,要想利用他们，我们就必须在程序中根据用户要求，然后一个个调用 new 操作符来生成他们，这样客户程序就要知道相应的类的信息，生成的代码显然不够灵活。那么我们可以在代码中不利用具体的类，而只是说明我们需要什么，然后就能够得到我们想要的对象呢？ 
      这当然是可以的，根据GOF在《设计模式》一书里介绍，要创建对象这样的工作应该是属于创建型模式完成的。熟悉各种设计模式意图的朋友就会很快得出结论：“提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类”，至少“无需指定它们具体的类”符合我们的要求。OK，这就是抽象工厂模式的意图。

二、模式意图
      提供一个创建一系列相关或相互依赖对象的接口，而不需指定他们具体的类。

三、模式UML图：                   
             
四、模式参与者
  抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。 
  具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。
  抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。
  具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

五、模式与反射
     利用设计模式可以使我们的代码更灵活，更容易扩展，更容易维护。各种面向对象的程序设计语言都提供了基本相同的机制：比如类、继承、派生、多态等等。但是又有各自的特色，C# 中的反射机制便是一个很重要的工具，好好地利用就可以在实际中发挥很大的作用。
     反射是.NET Framework中的一个非常重要的特性。相信绝大多数的朋友都对其有所了解或是已经熟练的应用这项技术。我们需要根据需求去动态的创建一对象的实例，在程序设计中，通常我们会为了解耦合，把接口的实现对象写入配置文件，让工厂自己去一个特定的地方（配置文件）找他应该要实例化的对象（接口的实现对象），通过这样来实现“依赖注入（Dependency Injection）”。
     本来“依赖注入”需要专门的IOC容器提供，比如Spring.net,Castle这类似的框架产品。而在抽象工厂模式的应用中显然没有这么麻烦，通常的实现就是使用.NET技术‘反射’就可以了。下面是反射的两种常见应用：
应用一：
         Activator.CreateInstance("类型");
应用二：
         Assembly.Load("程序集名称").CreateInstance("命名空间.类名称")；

六、抽象工厂的简单实现

Entity Code
 1namespace DesignPattern.AbstractFactory
 2{
 3    public class User
 4    {
 5        private int _id;
 6        public int Id
 7        {
 8            get { return _id; }
 9            set { _id = value; }
        }

        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        private string _age;
        public string Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public User()
        { }

        public User(int id, string name, string age)
        {
            _id = id;
            _name = name;
            _age = age;
        }
    }
}
----------------------------------------------------------------------
namespace DesignPattern.AbstractFactory
{
    public class News
    {
        private int _id;
        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        private string _title;
        public string Title
        {
            get { return _title; }
            set { _title = value; }
        }

        private string _context;
        public string Context
        {
            get { return _context; }
            set { _context = value; }
        }

        private string _author;
        public string Author
        {
            get { return _author; }
            set { _author = value; }
        }

        public News()
        { }

        public News(int id, string title, string context, string author)
        {
            _id = id;
            _title = title;
            _context = context;
            _author = author;
        }
    }
}

 

 1namespace DesignPattern.AbstractFactory
 2{
 3    /**//// <summary>
 4    /// 抽象产品角色
 5    /// </summary>
 6    public interface INews
 7    {
 8        void Insert(News news);
 9        News QueryById(int newsId);
    }

    /**//// <summary>
    /// 具体产品角色
    /// </summary>
    public class NewsSql:INews
    {
        public void Insert(News news)
        {
            Console.WriteLine("插入新闻到SQL数据库");
        }

        public News QueryById(int newsId)
        {
            return new News(1, "Hello", " Hello C#!", "beniao");
        }
    }

    /**//// <summary>
    /// 具体产品角色
    /// </summary>
    public class NewsAccess : INews
    {
        public void Insert(News news)
        {
            Console.WriteLine("插入新闻到Access数据库");
        }

        public News QueryById(int newsId)
        {
            return new News(1, "Hello", " Hello C#!", "beniao");
        }
    }
}

 

 1namespace DesignPattern.AbstractFactory
 2{
 3    /**//// <summary>
 4    /// 抽象产品角色
 5    /// </summary>
 6    public interface IUser
 7    {
 8        void Insert(User user);
 9        User QueryById(int userId);
    }

    /**//// <summary>
    /// 具体产品角色
    /// </summary>
    public class UserSql:IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("Insert SQL OK!");
        }

        public User QueryById(int userId)
        {
            return new User(1, "beniao", "22");
        }
    }

    /**//// <summary>
    /// 具体产品角色
    /// </summary>
    public class UserAccess : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("Insert Access OK!");
        }

        public User QueryById(int userId)
        {
            return new User(2, "beniao", "23");
        }
    }
}

 

 1namespace DesignPattern.AbstractFactory
 2{
 3    /**//// <summary>
 4    /// 工厂角色(根据配置文件来确定创建何种对象)
 5    /// </summary>
 6    public class DataAccess
 7    {
 8        public static IUser CreateUser()
 9        {
            string obj = ConfigurationManager.AppSettings["usersql"];
            return (IUser)Assembly.Load("DesignPattern.AbstractFactory").CreateInstance(obj);
        }

        public static INews CreateNews()
        {
            string obj = ConfigurationManager.AppSettings["newssql"];
            return (INews)Assembly.Load("DesignPattern.AbstractFactory").CreateInstance(obj);
        }
    }
***********************************************************************************
    /**//// <summary>
    /// 如果根据GOF的定义及UML图,此为抽象工厂角色
    /// </summary>
    public class Factory
    {
        public  virtual IUser CreateUser() 
        {
            return null;
        }

        public  virtual INews CreateNews()
        {
            return null;
        }
    }

    /**//// <summary>
    /// 具体的工厂角色
    /// </summary>
    public class SqlFactory:Factory
    {
        public override IUser CreateUser()
        {
            string obj = ConfigurationManager.AppSettings["usersql"];
            return (IUser)Assembly.Load("DesignPattern.AbstractFactory").CreateInstance(obj);
        }

        public override INews CreateNews()
        {
            string obj = ConfigurationManager.AppSettings["newssql"];
            return (INews)Assembly.Load("DesignPattern.AbstractFactory").CreateInstance(obj);
        }
    }

    /**//// <summary>
    /// 具体的工厂角色
    /// </summary>
    public class AccessFactory : Factory
    {
        public override IUser CreateUser()
        {
            string obj = ConfigurationManager.AppSettings["useracc"];
            return (IUser)Assembly.Load("DesignPattern.AbstractFactory").CreateInstance(obj);
        }

        public override INews CreateNews()
        {
            string obj = ConfigurationManager.AppSettings["newsacc"];
            return (INews)Assembly.Load("DesignPattern.AbstractFactory").CreateInstance(obj);
        } 
    }
}

 

 1namespace DesignPattern.AbstractFactory
 2{
 3    class Program
 4    {
 5        static void Main(string[] args)
 6        {
 7            IUser user = DataAccess.CreateUser();
 8            user.Insert(null);
 9
            INews news = DataAccess.CreateNews();
            news.Insert(null);

            //******************GOF************************

            Factory factory = new SqlFactory();
            factory.CreateNews().Insert(null);
            factory.CreateUser().Insert(null);

            factory = new AccessFactory();
            factory.CreateNews().Insert(null);
            factory.CreateUser().Insert(null);
        }
    }
}

          
七、.NET 2.0中的抽象工厂模式
     .NET 2.0相比.NET 1.1有很大的改进，就在ADO.NET上来说吧，提供了一套新的操作接口。下面我就简单的介绍下这套接口的设计，在System.Date下提供了IDbConnection 、IDbCommand、IDbDataAdapter以及IDbTransaction这样一系列接口，通过ProviderFactory来完成具体实现对象的创建，这里就是抽象工厂模式的一个应用。示意性代码：

 1public IDbConnection CreateConnection()
 2{
 3    IDbConnection conn = null;
 4    try
 5    {
 6        conn = (IDbConnection)Activator.CreateInstance(_connectionTypes[(int)_provider]);
 7    }
 8    catch(TargetInvocationException e)
 9    {
        throw new Exception(e.Message);
    }
    return conn;
}

public IDbConnection CreateConnection(string connectionString)
{
    IDbConnection conn = null;
    object[] param ={ connectionString };
    try
    {
        conn = (IDbConnection)Activator.CreateInstance(_connectionTypes[(int)_provider], param);
    }
    catch (TargetInvocationException e)
    {
        throw new Exception(e.Message);
    }
    return conn;
}

     在_connectionTypes数组里存放的是IDbConnection接口的具体实现类型，如下：

private static Type[] _connectionTypes = new Type[] { typeof(OleDbConnection), typeof(SqlConnection) };

由于Command,DataAdapter等对象的代码都和上面很相似，这里就不作过多解释，我把代码贴到下面，有兴趣的看看：

ProviderFactory
  1using System;
  2using System.Data;
  3using System.Configuration;
  4using System.Web;
  5using System.Web.Security;
  6using System.Web.UI;
  7using System.Web.UI.WebControls;
  8using System.Web.UI.WebControls.WebParts;
  9using System.Web.UI.HtmlControls;
 10using System.Reflection;
 11using System.Data.OleDb;
 12using System.Data.SqlClient;
 13
 14/**//// <summary>
 15/// ProviderFactory 的摘要说明
 16/// </summary>
 17public class ProviderFactory
 18{
 19    /**//// <summary>
 20    /// 私有构造器，伪单例。
 21    /// 一个具体的工厂通常是一个单件(Singleton)。
 22    /// </summary>
 23    private ProviderFactory()
 24    {
 25
 26    }
 27
 28    public ProviderFactory(ProviderType provider)
 29    {
 30        _provider = provider;
 31    }
 32
 33    private static Type[] _connectionTypes = new Type[] { typeof(OleDbConnection), typeof(SqlConnection) };
 34    private static Type[] _commandTypes = new Type[] { typeof(OleDbCommand), typeof(SqlCommand) };
 35    private static Type[] _dataAdapterTypes = new Type[] { typeof(OleDbDataAdapter), typeof(SqlDataAdapter) };
 36    private static Type[] _dataParameterTypes = new Type[] { typeof(OleDbParameter), typeof(SqlParameter) };
 37    
 38    private ProviderType _provider;
 39    public ProviderType Provider
 40    {
 41        get { return _provider; }
 42        set { _provider = value; }
 43    }
 44
 45    public IDbConnection CreateConnection()
 46    {
 47        IDbConnection conn = null;
 48        try
 49        {
 50            conn = (IDbConnection)Activator.CreateInstance(_connectionTypes[(int)_provider]);
 51        }
 52        catch(TargetInvocationException e)
 53        {
 54            throw new Exception(e.Message);
 55        }
 56        return conn;
 57    }
 58
 59    public IDbConnection CreateConnection(string connectionString)
 60    {
 61        IDbConnection conn = null;
 62        object[] param ={ connectionString };
 63        try
 64        {
 65            conn = (IDbConnection)Activator.CreateInstance(_connectionTypes[(int)_provider], param);
 66        }
 67        catch (TargetInvocationException e)
 68        {
 69            throw new Exception(e.Message);
 70        }
 71        return conn;
 72    }
 73
 74    public IDbCommand CreateCommand()
 75    {
 76        IDbCommand cmd = null;
 77        try
 78        {
 79            cmd = (IDbCommand)Activator.CreateInstance(_commandTypes[(int)_provider]);
 80        }
 81        catch (TargetInvocationException e)
 82        {
 83            throw new Exception(e.Message);
 84        }
 85        return cmd;
 86    }
 87
 88    public IDbCommand CreateCommand(string cmdText)
 89    {
 90        IDbCommand cmd = null;
 91        object[] args = { cmdText };
 92        try
 93        {
 94            cmd = (IDbCommand)Activator.CreateInstance(_commandTypes[(int)_provider], args);
 95        }
 96        catch (TargetInvocationException e)
 97        {
 98            throw new Exception(e.Message);
 99        }
        return cmd;
    }

    public IDbCommand CreateCommand(string cmdText, IDbConnection connection)
    {
        IDbCommand cmd = null;
        object[] args = { cmdText, connection };
        try
        {
            cmd = (IDbCommand)Activator.CreateInstance(_commandTypes[(int)_provider], args);
        }
        catch (TargetInvocationException e)
        {
            throw new Exception(e.Message);
        }
        return cmd;
    }

    public IDbCommand CreateCommand(string cmdText, IDbConnection connection, IDbTransaction transaction)
    {
        IDbCommand cmd = null;
        object[] args = { cmdText, connection, transaction };
        try
        {
            cmd = (IDbCommand)Activator.CreateInstance(_commandTypes[(int)_provider], args);
        }
        catch (TargetInvocationException e)
        {
            throw new Exception(e.Message);
        }
        return cmd;
    }

    public IDbDataAdapter CreateDataAdapter()
    {
        IDbDataAdapter da = null;
        try
        {
            da = (IDbDataAdapter)Activator.CreateInstance(_dataAdapterTypes[(int)_provider]);
        }
        catch (TargetInvocationException e)
        {
            throw new SystemException(e.InnerException.Message, e.InnerException);
        }
        return da;
    }

    public IDbDataAdapter CreateDataAdapter(IDbCommand selectCommand)
    {
        IDbDataAdapter da = null;
        object[] args = { selectCommand };
        try
        {
            da = (IDbDataAdapter)Activator.CreateInstance(_dataAdapterTypes[(int)_provider], args);
        }
        catch (TargetInvocationException e)
        {
            throw new SystemException(e.InnerException.Message, e.InnerException);
        }
        return da;
    }

    public IDbDataAdapter CreateDataAdapter(string selectCommandText, IDbConnection selectConnection)
    {
        IDbDataAdapter da = null;
        object[] args = { selectCommandText, selectConnection };
        try
        {
            da = (IDbDataAdapter)Activator.CreateInstance(_dataAdapterTypes[(int)_provider], args);
        }
        catch (TargetInvocationException e)
        {
            throw new SystemException(e.InnerException.Message, e.InnerException);
        }
        return da;
    }

    public IDbDataAdapter CreateDataAdapter(string selectCommandText, string selectConnectionString)
    {
        IDbDataAdapter da = null;
        object[] args = { selectCommandText, selectConnectionString };
        try
        {
            da = (IDbDataAdapter)Activator.CreateInstance(_dataAdapterTypes[(int)_provider], args);
        }
        catch (TargetInvocationException e)
        {
            throw new SystemException(e.InnerException.Message, e.InnerException);
        }
        return da;
    }

    public IDbDataParameter CreateDataParameter()
    {
        IDbDataParameter param = null;
        try
        {
            param = (IDbDataParameter)Activator.CreateInstance(_dataParameterTypes[(int)_provider]);
        }
        catch (TargetInvocationException e)
        {
            throw new SystemException(e.InnerException.Message, e.InnerException);
        }
        return param;
    }

    public IDbDataParameter CreateDataParameter(string parameterName, object value)
    {
        IDbDataParameter param = null;
        object[] args = { parameterName, value };
        try
        {
            param = (IDbDataParameter)Activator.CreateInstance(_dataParameterTypes[(int)_provider], args);
        }
        catch (TargetInvocationException e)
        {
            throw new SystemException(e.InnerException.Message, e.InnerException);
        }
        return param;
    }

    public IDbDataParameter CreateDataParameter(string parameterName, DbType dataType)
    {
        IDbDataParameter param = CreateDataParameter();
        if (param != null)
        {
            param.ParameterName = parameterName;
            param.DbType = dataType;
        }
        return param;
    }

    public IDbDataParameter CreateDataParameter(string parameterName, DbType dataType, int size)
    {
        IDbDataParameter param = CreateDataParameter();
        if (param != null)
        {
            param.ParameterName = parameterName;
            param.DbType = dataType;
            param.Size = size;
        }
        return param;
    }

    public IDbDataParameter CreateDataParameter(string parameterName, DbType dataType, int size, string sourceColumn)
    {
        IDbDataParameter param = CreateDataParameter();
        if (param != null)
        {
            param.ParameterName = parameterName;
            param.DbType = dataType;
            param.Size = size;
            param.SourceColumn = sourceColumn;
        }
        return param;
    }
}

      关于.NET 2.0的这一知识点不了解的朋友可以下载Web Cast课程进行学习。本文就简单的介绍这些。

七、.NET 2.0中的新ADO.NET操作接口应用示例
     建立一ASP.NET网站项目，在默认的Default.aspx里放置一个GridView控件便OK。这里以MSSQL 2000里的Northwind数据库作为示例数据库，查询出订单表的数据呈现在aspx页面上，进入后台代码文件（.cs文件）：

 1public partial class _Default : System.Web.UI.Page 
 2{
 3    protected void Page_Load(object sender, EventArgs e)
 4    {
 5        string connectionString="Data Source=.;Initial Catalog=Northwind;user id=sa;password=;";
 6        string cmdText = "select * from orders";
 7
 8        ProviderFactory factory = new ProviderFactory(ProviderType.SqlClient);
 9        IDbConnection conn = factory.CreateConnection(connectionString);
        IDbDataAdapter sda = factory.CreateDataAdapter(cmdText, conn);
        DataSet ds = new DataSet();
        sda.Fill(ds);
        this.GridView1.DataSource = ds.Tables[0];
        this.GridView1.DataBind();
    }
}

      ProviderFactory担任着工厂的角色，负责创建如IDbConnection、IDbCommand等一系列的产品。如上，我们拿到了工厂角色，通过工厂角色的CreateConnection就创建到了一个基于抽象产品角色IDbConnection接口的实现对象（具体是什么实现对象我们暂不管）。
     .NET 2.0提供了这一套操作接口，对于程序实现上就更加灵活了，更是强调了使用“依赖接口/抽象编程”的思想。 

示例程序代码下载
注：转载请注明出处：http://beniao.cnblogs.com/ 或  http://www.cnblogs.com
由于最近生病精神不振，文章介绍的不是很清楚，望大家体谅。