备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

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

2014-03-09 944
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原文:乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern)[索引页][源码下载]乐在其中设计模式(C#) - 抽象工厂模式(Abstract Factory Pattern) 作者：webabcd 介绍 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
原文: 乐在其中设计模式(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
[源码下载]
文章标签：
C#
SQL
数据格式
XML
索引
算法
设计模式
关键词：
设计模式抽象工厂模式
设计模式pattern
设计模式factory
设计模式abstract factory
设计模式抽象工厂模式abstract factory
杰克.陈
目录
相关文章
鱼找水需要时间
|
3月前
|
设计模式 算法 Java
行为型设计模式-策略模式（Strategy Pattern）
行为型设计模式-策略模式（Strategy Pattern）
鱼找水需要时间
22 0
w风雨无阻w
|
4月前
|
设计模式
二十三种设计模式全面解析-解密组合模式（Composite Pattern）：构建统一而强大的对象结构
二十三种设计模式全面解析-解密组合模式（Composite Pattern）：构建统一而强大的对象结构
w风雨无阻w
44 0
w风雨无阻w
|
4月前
|
设计模式 缓存
二十三种设计模式全面解析-代理模式（Proxy Pattern）详解：探索隐藏于背后的力量
二十三种设计模式全面解析-代理模式（Proxy Pattern）详解：探索隐藏于背后的力量
w风雨无阻w
25 0
w风雨无阻w
|
4月前
|
设计模式 存储 安全
二十三种设计模式全面解析-享元模式（Flyweight Pattern）详解：构建高效共享的对象结构
二十三种设计模式全面解析-享元模式（Flyweight Pattern）详解：构建高效共享的对象结构
w风雨无阻w
47 0
辰辰zZ
|
4天前
|
设计模式 Java
【设计模式系列笔记】抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是一种设计模式，属于创建型模式之一。它提供了一种方式来创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式通过引入抽象的工厂接口，使得客户端代码可以使用抽象的接口来创建一组相关的产品，而不关心这些产品的具体实现。
辰辰zZ
99 4
小小工匠
|
3月前
|
设计模式 算法
设计模式 - 行为型模式_ 访问者模式Visitor Pattern
设计模式 - 行为型模式_ 访问者模式Visitor Pattern
小小工匠
39 1
设计模式 - 行为型模式_ 访问者模式Visitor Pattern
小小工匠
|
3月前
|
设计模式 Java 应用服务中间件
设计模式 -结构型模式_门面模式(外观模式) Facade Pattern 在开源软件中的应用
设计模式 -结构型模式_门面模式(外观模式) Facade Pattern 在开源软件中的应用
小小工匠
31 1
小小工匠
|
3月前
|
设计模式 缓存 安全
设计模式 - 创建型模式_ 单例模式 Singleton Pattern
设计模式 - 创建型模式_ 单例模式 Singleton Pattern
小小工匠
39 0
东方睿赢
|
10天前
|
设计模式 存储 Java
Java设计模式：解释一下单例模式（Singleton Pattern）。
`Singleton Pattern`是Java中的创建型设计模式，确保类只有一个实例并提供全局访问点。它通过私有化构造函数，用静态方法返回唯一的实例。类内静态变量存储此实例，对外仅通过静态方法访问。
东方睿赢
15 1
喜欢猪猪
|
20天前
|
设计模式 Java Windows
23种设计模式，抽象工厂模式的概念优缺点以及JAVA代码举例
【4月更文挑战第10天】抽象工厂模式是一种创建型设计模式，它提供了一个接口用于创建相关或依赖对象的家族，而不需要指定具体类。该模式允许客户端在不知道具体类的情况下，通过其共同的接口来创建一组产品。
喜欢猪猪
27 7