乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)

原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)
[索引页][源码下载]

乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)

作者：webabcd

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

示例
有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

参考
http://www.dofactory.com/Patterns/PatternAbstract.aspx

OK
[源码下载]

时间： 2024-08-07 22:24:24

乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)的相关文章

抽象工厂模式(abstract factory pattern) 详解

抽象工厂模式: 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要明确指定具体类. 全部代码: http://download.csdn.net/detail/u012515223/7403553 具体方法: 1. 提供一个抽象工厂(abstract factory)接口(interface)类, 不同的具体工厂(concrete factory)继承此类. 代码: /** * @time 2014年5月26日 */ package factory; /** * @author C.L.W

.Net设计模式之简单工厂模式(Simple Factory Pattern)

一.简单工厂模式简介(Bref Introduction) 简单工厂模式(Simple Factory Pattern)的优点是,工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖 二.解决的问题(What To Solve) 客户实例化对象时不需要关心该对象是由哪个子类实例化的. 三.简单工厂模式分析(Analysis) 1.简单工厂模式结构 IProduct接口:抽象产品类 ConcreteProduct类:产品类的具体实现 Simp

C#设计模式(4)——抽象工厂模式

原文:C#设计模式(4)--抽象工厂模式 一.引言 在上一专题中介绍了工厂方法模式,工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类随着产品类的增加需要增加额外的代码),而工厂方法模式每个具体工厂类只完成单个实例的创建,所以它具有很好的可扩展性.但是在现实生活中,一个工厂只创建单个产品这样的例子很少,因为现在的工厂都多元化了,一个工厂创建一系列的产品,如果我们要设计这样的系统时,工厂方法模式显然在这里不适用,然后抽象工厂模式却可以很好地解决一系列产品创建的问题,这是本专

跟屌丝大哥学习设计模式－抽象工厂模式

1.3 抽象工厂(Abstract Factory)模式    抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品具体类型的情况下,创建多个产品族中的产品对象.这就是抽象工厂模式的用意.     每个模式都是针对一定问题的解决方案.抽象工厂模式面对的问题是多产品等级结构的系统设计.     在学习抽象工厂具体实例之前,应该明白两个重要的概念:产品族和产品等级.     产品族:是指位于不同产品等级结构中,功能相关联的产品组成的家族.比如AMD的CPU和ADM芯片的主板,组成一个家族.

设计模式之四(抽象工厂模式第三回合)

原文:设计模式之四(抽象工厂模式第三回合) 前言 抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 抽象工厂模式最大的好处便是易于交换产品系列,由于具体工厂类,例如IFactory factory=new AccessFactory(),在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需要改变具体工厂即可使用不同的产品配置.我们的设计不能去防止需要的变更,那么我们的理想便是让改动变得最小,那么现在如果你要更改数据库访问,

设计模式之四(抽象工厂模式第一回合)

原文:设计模式之四(抽象工厂模式第一回合) 前言 首先关于抽象工厂模式的学习,我们需要慢慢的,由浅入深的进入.不能单刀直入,否则可能达不到预期学明白的目标. 第一回合  首先我们从最简单的数据访问程序开始吧. 下面先来看一个简单的小例子,代码很简单 public class User { public int ID{get;set;} public string Name{get;set;} } 一个简单的实体类,也相当于在SqlServer数据库中建立了相同的数据表 public class

C++设计模式之抽象工厂模式_C 语言

问题描述 之前讲到了C++设计模式--工厂方法模式,我们可能会想到,后期产品会越来越多了,建立的工厂也会越来越多,工厂进行了增长,工厂变的凌乱而难于管理:由于工厂方法模式创建的对象都是继承于Product的,所以工厂方法模式中,每个工厂只能创建单一种类的产品,当需要生产一种全新的产品(不继承自Product)时,发现工厂方法是心有余而力不足. 举个例子来说:一个显示器电路板厂商,旗下的显示器电路板种类有非液晶的和液晶的:这个时候,厂商建造两个工厂,工厂A负责生产非液晶显示器电路板,工厂B负责生产

艾伟_转载：.NET设计模式：抽象工厂模式（Abstract Factory）

概述 在软件系统中,经常面临着"一系列相互依赖的对象"的创建工作:同时由于需求的变化,往往存在着更多系列对象的创建工作.如何应对这种变化?如何绕过常规的对象的创建方法(new),提供一种"封装机制"来避免客户程序和这种"多系列具体对象创建工作"的紧耦合?这就是我们要说的抽象工厂模式. 意图 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类. 模型图 逻辑模型: 物理模型: 生活中的例子 抽象工厂的目的是要提供一个创建一系列相关或

【java设计模式】之 抽象工厂（Abstract Factory）模式

版权声明:尊重博主原创文章,转载请注明出处哦~http://blog.csdn.net/eson_15/article/details/51253161 目录(?)[+] 1. 女娲的失误         上一节学习了工厂模式,女娲运用了该模式成功创建了三个人种,可是问题来了,她发现没有性别--这失误也忒大了点吧--竟然没有性别,那岂不是--无奈,只好抹掉重来了,于是所有人都被消灭掉了,重新造人.         女娲开始分析了,既然要区别男女,那么生产人种的工厂(八卦炉)要重新改造了,因为一个