抽象工厂模式(Abstract Factory Pattern)

介绍
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

示例
有Message和MessageModel，Message有一个Insert()方法，该方法的参数是MessageModel。

　　AbstractMessageModel

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// 抽象Message实体类（AbstractProduct）
    /// </summary>
    public abstract class AbstractMessageModel
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public AbstractMessageModel()
        {

        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="msg">Message内容</param>
        /// <param name="pt">Message发布时间</param>
        public AbstractMessageModel(string msg, DateTime pt)
        {
            this._message = msg;
            this._publishTime = pt;
        }

        private string _message;
        /// <summary>
        /// Message内容
        /// </summary>
        public string Message
        {
            get { return _message; }
            set { _message = value; }
        }

        private DateTime _publishTime;
        /// <summary>
        /// Message发布时间
        /// </summary>
        public DateTime PublishTime
        {
            get { return _publishTime; }
            set { _publishTime = value; }
        }

        /// <summary>
        /// UserId
        /// </summary>
        public abstract string UserId
        {
            get;
            set;
        }
    }
}

　　SqlMessageModel

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// SqlMessage实体类（Product）
    /// </summary>
    public class SqlMessageModel : AbstractMessageModel
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public SqlMessageModel()
            : base()
        {

        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userId">UserId</param>
        /// <param name="msg">Message内容</param>
        /// <param name="pt">Message发布时间</param>
        public SqlMessageModel(string userId, string msg, DateTime pt)
            : base(msg, pt)
        {
            this._userId = userId;
        }

        private string _userId;
        /// <summary>
        /// Message内容
        /// </summary>
        public override string UserId
        {
            get { return _userId; }
            set { _userId = value; }
        }
    }
}

　　XmlMessageModel

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// XmlMessage实体类（Product）
    /// </summary>
    public class XmlMessageModel : AbstractMessageModel
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public XmlMessageModel()
            : base()
        {

        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userId">UserId</param>
        /// <param name="msg">Message内容</param>
        /// <param name="pt">Message发布时间</param>
        public XmlMessageModel(string userId, string msg, DateTime pt)
            : base (msg, pt)
        {
            this._userId = userId;
        }

        private string _userId;
        /// <summary>
        /// Message内容
        /// </summary>
        public override string UserId
        {
            // 解密算法后的值
            get { return _userId; } 

            // 加密算法后的值
            set { _userId = value; }
        }
    }
}

　　AbstractMessage

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// 操作Message抽象类（AbstractProduct）
    /// </summary>
    public abstract class AbstractMessage
    {
        /// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="amm">AbstractMessageModel</param>
        /// <returns></returns>
        public abstract string Insert(AbstractMessageModel amm);
    }
}

　　SqlMessage

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// Sql方式操作Message类（Product）
    /// </summary>
    public class SqlMessage : AbstractMessage
    {
        /// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="amm">AbstractMessageModel</param>
        /// <returns></returns>
        public override string Insert(AbstractMessageModel amm)
        {
            return "Sql方式插入Message。帐号：" + amm.UserId
                + "；内容：" + amm.Message
                + "；时间：" + amm.PublishTime.ToString();
        }
    }
}

　　XmlMessage

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// Xml方式操作Message类（Product）
    /// </summary>
    public class XmlMessage : AbstractMessage
    {
        /// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="amm">AbstractMessageModel</param>
        /// <returns></returns>
        public override string Insert(AbstractMessageModel amm)
        {
            return "Xml方式插入Message。帐号：" + amm.UserId
                + "；内容：" + amm.Message
                + "；时间：" + amm.PublishTime.ToString();
        }
    }
}

　　AbstractMessageFactory

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// 抽象Message工厂（AbstractFactory）
    /// </summary>
    public abstract class AbstractMessageFactory
    {
        /// <summary>
        /// 创建MessageModel对象
        /// </summary>
        /// <returns></returns>
        public abstract AbstractMessageModel CreateMessageModel();

        /// <summary>
        /// 创建Message对象
        /// </summary>
        /// <returns></returns>
        public abstract AbstractMessage CreateMessage();
    }
}

　　SqlMessageFactory

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// SqlMessage工厂（ConcreteFactory）
    /// </summary>
    public class SqlMessageFactory : AbstractMessageFactory
    {
        /// <summary>
        /// 创建SqlMessageModel对象
        /// </summary>
        /// <returns></returns>
        public override AbstractMessageModel CreateMessageModel()
        {
            return new SqlMessageModel();
        }

        /// <summary>
        /// 创建SqlMessage对象
        /// </summary>
        /// <returns></returns>
        public override AbstractMessage CreateMessage()
        {
            return new SqlMessage();
        }
    }
}

　　XmlMessageFactory

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// XmlMessage工厂（ConcreteFactory）
    /// </summary>
    public class XmlMessageFactory : AbstractMessageFactory
    {
        /// <summary>
        /// 创建XmlMessageModel对象
        /// </summary>
        /// <returns></returns>
        public override AbstractMessageModel CreateMessageModel()
        {
            return new XmlMessageModel();
        }

        /// <summary>
        /// 创建XmlMessage对象
        /// </summary>
        /// <returns></returns>
        public override AbstractMessage CreateMessage()
        {
            return new XmlMessage();
        }
    }
}

　　Message

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

namespace Pattern.AbstractFactory
{
    /// <summary>
    /// Context类
    /// </summary>
    public class Message
    {
        private AbstractMessage _insertMessage;
        private AbstractMessageModel _messageModel;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="factory">AbstractMessageFactory</param>
        public Message(AbstractMessageFactory factory)
        {
            DateTime pt = DateTime.Now;

            _insertMessage = factory.CreateMessage();
            _messageModel = factory.CreateMessageModel();

        }

        /// <summary>
        /// 插入Message
        /// </summary>
        /// <param name="userId">UserId</param>
        /// <param name="msg">Message内容</param>
        /// <param name="pt">Message发布时间</param>
        /// <returns></returns>
        public string Insert(string userId, string msg, DateTime pt)
        {
            _messageModel.UserId = userId;
            _messageModel.Message = msg;
            _messageModel.PublishTime = pt;

            return _insertMessage.Insert(_messageModel);
        }
    }
}

　　Client

using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

using Pattern.AbstractFactory;

public partial class AbstractFactory : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        AbstractMessageFactory amf = new SqlMessageFactory();

        Message m = new Message(amf);

        Response.Write(m.Insert("admin", "Sql方式", DateTime.Now));
        Response.Write("<br />");

        amf = new XmlMessageFactory();

        m = new Message(amf);

        Response.Write(m.Insert("user", "Xml方式", DateTime.Now));
    }
}

　　运行结果
　　Sql方式插入Message。帐号：admin；内容：Sql方式；时间：2007-5-3 22:04:56
　　Xml方式插入Message。帐号：user；内容：Xml方式；时间：2007-5-3 22:04:56