入戏如画

设计模式简单概括总结

Net设计模式实例之中介者模式（Mediator Pattern）

 中介者模式（Mediator Pattern），定义一个中介对象来封装系列对象之间的交互。中介者使各个对象不需要显示地相互引用，从而使其耦合性松散，而且可以独立地改变他们之间的交互。

经典案例：定义抽象类 中介和客户，在定义实例化中介和客户后；客户有个方法告诉中介我想和xx交往，中介可以找到客户，中介在给xx转达。

代码
class Program
    {
        static void Main(string[] args)
        {
            Mediator mediator = new MediatorOne();
            ClientA clienta = new ClientA(mediator, "A");
            ClientB clientb = new ClientB(mediator, "B");
            mediator.Registor(clienta);
            mediator.Registor(clientb);
            clienta.Tel("B", "hellor b");
            clientb.Tel("A", "hellor a");

            Console.ReadLine();
        }
    }
    /// <summary>
    /// 定义一个抽象中介
    /// </summary>
    public abstract class Mediator
    {
        /// <summary>
        /// 登记顾客
        /// </summary>
        /// <param name="_client"></param>
        public abstract void Registor(Client _client);

        /// <summary>
        /// 顾客留言
        /// </summary>
        /// <param name="_name"></param>
        /// <param name="_message"></param>
        /// <param name="_client"></param>
        public abstract void Send(string _name,string _message, Client _client);
    }

    /// <summary>
    /// 定义一个抽象顾客
    /// </summary>
    public abstract class Client
    {
        public Mediator mediator;


        public Client(Mediator _mediator, string _name)
        {
            this.mediator = _mediator;
            this.name = _name;
        }
        private string name;
        public string Name
        {
            get { return name; }
        }
        public abstract  void GetTel(string _message, string _name);

    }
    /// <summary>
    /// 中介实例
    /// </summary>
    public class MediatorOne : Mediator
    {
        private Dictionary<string, Client> clients = new Dictionary<string, Client>();

        public override void Registor(Client _client)
        {
            if (!clients.ContainsValue(_client))
            {
                clients[_client.Name] = _client;
            }

        }

        public override void SendToAll(string _name,string _message, Client _client)
        {
            if (clients.ContainsKey(_name))
            {
                clients[_name].GetTel(_message, _client.Name);
            }
        }
    }

    /// <summary>
    /// 顾客A
    /// </summary>
    class ClientA : Client
    {
        public ClientA(Mediator _mediator, string _name) : base(_mediator, _name) { }

        public void Tel(string _name, string _message)
        {
            this.mediator.Send(_name, _message, this);
        }

        public override  void GetTel(string _message,string _name)
        {
            Console.Write("A get tel:" + _message + " from " + _name);
        }

    }
    /// <summary>
    /// 顾客B
    /// </summary>
    class ClientB : Client
    {
        public ClientB(Mediator _mediator, string _name) : base(_mediator, _name) { }

        public void Tel(string _name,string _message)
        {
            this.mediator.Send(_name,_message, this);
        }

        public override  void GetTel(string _message,string _name)
        {
            Console.Write("B get tel:" + _message+" from "+_name);
        }

    }

 

 

Net设计模式实例之迭代器模式（Iterator Pattern）

提供一种方法顺序访问一个聚合对象中元素，而不暴露改集合对象的内部表示。 

类似：foreach 

  

 

Net设计模式实例之解释器模式（Interpreter Pattern）

 解释器模式（Interpreter Pattern），给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。当有一个语言需要解释执行，并且你可将该语言中的句子表示为一个抽象的语法树时，可以考虑使用解释器模式。

 

Net设计模式实例之命令模式(Command Pattern)

将请求封装为一个对象，从而使你用不同的请求对客户进行参数化，对请求排队或纪录请求日志，以及支持可撤销的操作。 

当需要有撤销或者恢复操作时，可以考虑使用命令模式。

 方法：建立一个储存信息列表的类，按索引或某种方式找到就行，具体操作支持可逆。例:加减数字,添加删除信息。

 

Net设计模式实例之访问者模式（Visitor Pattern）

 它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作，它把数据结构和作用于结构上的操作之间的耦合性解脱开，使的操作结合可以相对自由地演化。优点是增加新的操作很容易，因为增加一个新的操作就意味着增加一个新的访问者，访问者模式将有关的行为集中到一个访问对象中。

访问者模式的目的是要把处理从数据结构分离出来。如果系统有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式是个不错的选择，因为访问者模式使的算法操作的增加变的容易。相反，如果系统的数据结构不稳定，易于变化，则此系统就不适合使用访问者模式了。

 

 

http://www.cnblogs.com/chelsea/archive/2010/03/15/remove-accept-from-visitor-pattern.html

AVisitor: Visitor 
BVisitor: Visitor 
AElement: Element 
BElement: Element 
AVisitor aV=new AVisitor(); 
AElement aE=new AElement(); 
aV.Visit(aE); 

 

 

 引用：

1. 经典的Visitor模式(循环依赖)

 
classic visitor pattern
 1     public interface Document
 2     {
 3         void Accept(DocumentVisitor visitor);
 4     }
 5 
 6     public class WordDocument : Document
 7     {
 8         public void Accept(DocumentVisitor visitor)
 9         {
10             visitor.Visit(this);
11         }
12     }
13 
14     public class ExcelDocument : Document
15     {
16         public void Accept(DocumentVisitor visitor)
17         {
18             visitor.Visit(this);
19         }
20     }
21 
22     public interface DocumentVisitor
23     {
24         void Visit(WordDocument wordDocument);
25         void Visit(ExcelDocument excelDocument);
26     }
27 

  

这里面 Document依赖于DocumentVisitor, DocumentVisitor依赖于WordDocument和ExcelDocument, 而WrodDocument等又依赖于Document

这样 Document->DocumentVisitor->WordDocument->Document->...循环依赖

2. 经典的解依赖Visitor模式(Down Cast)
 
decouple visitor (dynamic cast))
 1     public interface Document
 2     {
 3         void Accept(DocumentVisitor visitor);
 4     }
 5 
 6     public class WordDocument : Document
 7     {
 8         public void Accept(DocumentVisitor visitor)
 9         {
10             if (visitor is WordDocumentVisitor)
11             {
12                 ((WordDocumentVisitor)visitor).Visit(this);
13             }
14         }
15     }
16 
17     public class ExcelDocument : Document
18     {
19         public void Accept(DocumentVisitor visitor)
20         {
21             if (visitor is ExcelDocumentVisitor)
22             {
23                 ((ExcelDocumentVisitor)visitor).Visit(this);
24             }
25         }
26     }
27 
28     public interface DocumentVisitor
29     {
30         //空接口, 依赖在这里断掉了
31     }
32 
33     public class ExcelDocumentVisitor : DocumentVisitor
34     {
35         public void Visit(ExcelDocument excelDocument)
36         {
37             
38         }
39     }
40 
41     public class WordDocumentVisitor : DocumentVisitor
42     {
43         public void Visit(WordDocument wordDocument)
44         {
45         }
46     }
47 

 

 3. 消除无聊Accept()方法的Visitor模式


上面的Accept方法几乎千篇一律, 遵循相同的模式. 里面无非就是类型计算, 可以利用C#的泛型支持将之消除

remove Accept from all subclasses
 1     public interface Document
 2     {
 3         void Accept(DocumentVisitor visitor);
 4     }
 5 
 6     public abstract class VisitableDocument<T> : Document where T : VisitableDocument<T>
 7     {
 8         public void Accept(DocumentVisitor visitor)
 9         {
10             var interfaces = visitor.GetType().GetInterfaces();
11 
12             foreach (var type in interfaces)
13             {
14                 if (type.GetGenericArguments().Contains(typeof(T)))
15                 {
16                     ((DocumentVisitor<T>)visitor).Visit((T)this);
17                 }
18             }
19         }
20     }
21 
22     public class WordDocument : VisitableDocument<WordDocument>
23     {
24         //不需要自己实现Accept, 基类已经实现
25     }
26 
27     public class ExcelDocument : VisitableDocument<ExcelDocument>
28     {
29         //不需要自己实现Accept, 基类已经实现
30     }
31 
32     public interface DocumentVisitor
33     {
34         //空接口
35     }
36 
37     public interface DocumentVisitor<T> : DocumentVisitor where T : VisitableDocument<T>
38     {
39         //泛型, 依赖在这里断掉了
40         void Visit(T document);
41     }
42 
43     public class PrintDocumentVisitor : DocumentVisitor<WordDocument>, DocumentVisitor<ExcelDocument>
44     {
45         public void Visit(WordDocument wordDocument)
46         {
47         }
48 
49         public void Visit(ExcelDocument excelDocument)
50         {
51         }
52     }
53 

 

 

Net设计模式实例之模板方法模式(Template Mothed Pattern)

模板方法模式(Template Method Pattern),定义一个操作中的算法骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可以重定义算法的某些特定步骤。模板方法模式把不变行为搬移到超类，从而去除子类中的重复代码，实际上模板方法模式就是提供了一个代码复用平台。

 

要完成在某一细节上层次一致的一个过程或一系列步骤，但个别步骤在更详细的层次上实现不同时，可以使用模版方法模式解决问题。

 实例：定义一个抽象类：方法固定并且可以重写，方法的执行循序固定。其他类可以继承，具体细节不同可以重写基类方法。

 

Net设计模式实例之状态模式(State Pattern)

把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简单化。

当一个对象行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑使用状态模式了。

 

      状态更加形象的表示出当前的运算，如:人胖时，就该减肥，瘦时就该多吃（呵呵），正好就保持。

 

 

 

 

Net设计模式实例之备忘录模式(Memento Pattern)

备忘录模式（Memento Pattern），在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可以就该对象恢复到原先保存的状态。

   当系统功能比较复杂，而且需要记录历史属性以便当需要时做恢复动作。Originator可以根据保存的Memento信息还原到前一状态。

一个可以记录某类几次变化信息的类，当需要回复时，赋值给该类。

 

 

Net设计模式实例之代理模式（Proxy Pattern）

代理模式（Proxy Pattern）对其他对象提供一种代理以控制对这个对象的访问。
代理模式分为远程代理、虚拟代理、安全代理和智能指引。

 

进一步封装类，简单理解。

 

 

 

Net设计模式实例之享元模式( Flyweight Pattern)

享元模式可以避免大量非常相似类的开销。在程序设计中有时需要生成大量细粒度的类实例来表示数据。如果发现这些实例除了几个参数外基本伤都是相同的，有时就能够受大幅度第减少需要实例化的类的数量。如果能把这些参数移到类实例外面，在方法调用时将他们传递进来，就可以通过共享大幅度地减少单个实例的数目。

 一些类的集合,基本实现：当集合中有时返回，没有时添加。这样可以避免重复添加。

 

Net设计模式实例之外观模式（Façade Pattern）

一、外观模式简介（Brief Introduction）

外观模式，为子系统的一组接口提供一个统一的界面，此模式定义了一个高层接口，这一个高层接口使的子系统更加容易使用。

 

二、解决的问题（What To Solve）

1、分离不同的两个层

       典型的分层例子是Net三层架构，界面层与业务逻辑层分离，业务逻辑层与数据访问层分类。这样可以为子系统提供统一的界面和接口，降低了系统的耦合性。

2、减少依赖

       随着功能增加及程序的重构，系统会变得越来越复杂，这时增加一个外观可以提供一个简单的接口，减少他们之间的依赖。

3、为新旧系统交互提供接口

 

 

有的时候，新系统需要旧系统的核心功能，而这个旧的系统已经很难维护和扩展，可以给新系统增加一个Façade类，是的新系统与Façade类交互，Façade类与旧系统交互素有复杂的工作。

 

 添加个友情链接：我们学习网

 

Net设计模式实例之装饰者模式（Decorator Pattern）

优点：把类中的装饰功能从类中搬移出去，这样可以简化原有的类。有效地把类的核心功能和装饰功能区分开了。

 

动态地给一个对象添加一些额外的职责。

装饰模式，给一个对象动态添加额外职责，这些职责需要由用户决定加入的方式和时机。装饰模式提供了“即插即用”的方式，在运行期间决定何时增加何种功能。就增加功能来说，装饰模式比生成子类更加灵活。

 

abstract Car

ChinaCar :Car

abstract MakeCar:ChinaCar

 

MakeCarOne:MakeCar 

 

MakeCarTwo:MakeCar 

 使用：

 

  ChinaCar ccar=new ChiaCar();

  MakeCarOne mCarOne=new MakeCarOne();

  MakeCarTwo mCarTwo=new MakeCarTwo();

 mCarOne.Make( ccar);

 mCarTwo.Make(mCarOne); 

 

 

Net设计模式实例之组合模式（Composite Pattern）

组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。解决整合与部分可以被一致对待问题。

定义一个抽象类x ，其他类都继承他，设定一个类为主体，并可以添加抽象类x.这样类既可以组合又可以一致调用

 

 

Net设计模式实例之桥接模式( Bridge Pattern)

将抽象部分与它的实现部分分离，使的抽象和实现都可以独立地变化

两个抽象类xy,x中包含y.派生类x在实例化是指定派生类y就可以实现了。两个类可以都有变动。

 

 

Net设计模式实例之适配器模式（Adapter Pattern）

适配器模式，将一个类装换成客户期望的另外一个接口。Adapter模式使的原本由于接口不兼容而不能工作的那些类可以一起工作。

中间类，转换方法。 

 

Net设计模式实例之单例模式( Singleton Pattern)

保证一个类只有一个实例，并提供一个访问它的全局访问点。单例模式因为Singleton封装它的唯一实例，它就可以严格地控制客户怎样访问它以及何时访问它。

判断为空，加锁操作，简单理解。 

 

Net设计模式实例之原型模式( Prototype Pattern)

原型模式(Prototype Pattern)：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
当一个对象生成不是通过New而是通过复制旧对象的时候，可以考虑使用原型模式。Clone()方法

 


 

 

 

 

 

 

 

 

posted on 2010-03-17 12:11  问题很严重，加班吧。  阅读(194)  评论(0)  编辑  收藏  举报

导航

家庭日常健康生活小窍门常识妙招大全_废物利用手工制作DIY_生活百事通 儿童神话童话幼儿寓言民间鬼故事大全