亚洲一级黄色,亚洲一区二区av电影,国产欧美日韩伦理

梦在天�� — Thu, 17 Jan 2008 02:14:00 GMT

�ȝ��Q?a href="http://m.shnenglu.com/mzty/archive/2007/08/13/29922.html">

http://m.shnenglu.com/mzty/archive/2007/08/13/29922.html C++高��

http://m.shnenglu.com/mzty/archive/2007/03/02/19109.html C++基础

http://m.shnenglu.com/mzty/archive/2007/04/16/22064.html C#界面�Q�C++核心��法

http://m.shnenglu.com/mzty/archive/2007/03/04/19163.html 设计模式

http://m.shnenglu.com/mzty/archive/2007/03/29/20893.html 64bit�Q�FW3.0随笔分类

http://m.shnenglu.com/mzty/archive/2007/03/29/20892.html windows脚本技�?/p>

http://m.shnenglu.com/mzty/archive/2007/03/04/19167.html C#基础

梦在天�� 2008-01-17 10:14 发表评论

梦在天�� — Thu, 24 May 2007 11:42:00 GMT

一�Q�策略模�?br> 在看《C++设计新思维》的时候，发现在一开始就大篇�q�的介绍�{�略模式�Q�policy�Q�，�{�略模式不属于经典设计模式中的一�U�，但是其实在我们日常的开发中是必不可��的。policy,�{�略�Q�方针，�q�里的意思是指把复杂功能的类��量的拆分�ؓ功能单一的简单类的组合，��单的�c�d��负责单纯行�ؓ或结构的某一斚w��。增加程序库的弹性，可复用性，可扩展性。policy是一个虚拟的概念�Q�他定义了某一�c�class的一些接口规范，�q�不与C++语法的关键字对应�Q�只是一个抽象的概念�?br>
�?nbsp; 实例1

//policy模式的常见��用实例smartptr�Q?/span>
template
<
   class T,
   template <class> class CheckingPolicy,
   template <class> class ThreadingModel
>
class SmartPtr
   : public CheckingPolicy<T>
   , public ThreadingModel<SmartPtr>
{
   T* operator->()
   {
      typename ThreadingModel<SmartPtr>::Lock guard(*this);
      CheckingPolicy<T>::Check(pointee_);
      return pointee_;
   }
private:
   T* pointee_;
};

�?nbsp; 实例二，比如��_��我们定义一个policy�Q�他是一个带有参数T的一个模版，他必��L��一个Create函数�Q�且�q�回T�c�d��指针。对于这个定义，我们可以有不同的实现�Q�从而满��不同用��L��不同的需求�?br>

template <class T>
struct OpNewCreator
{
   static T* Create()
   {
      return new T;
   }
};

template <class T>
struct MallocCreator
{
   static T* Create()
   {
      void* buf = std::malloc(sizeof(T));
      if (!buf) return 0;
      return new(buf) T;
   }
};

template <class T>
struct PrototypeCreator
{
   PrototypeCreator(T* pObj = 0)
      :pPrototype_(pObj)
   {}
   T* Create()
   {
      return pPrototype_ ? pPrototype_->Clone() : 0;
   }
   T* GetPrototype() { return pPrototype_; }
   void SetPrototype(T* pObj) { pPrototype_ = pObj; }
private:
   T* pPrototype_;
};

//test class
class Widget
{
};

//调用�Ҏ��一�Q?/span>
template <class CreationPolicy>
class WidgetManager : public CreationPolicy
{
};
void main()
{

typedef WidgetManager< OpNewCreator<Widget> > MyWidgetMgr;

}

//调用�Ҏ��二：因�ؓ一般Manager是特定于某一�cȝ��class�Q�所以在Manager中就指定要处理的class�c�d��?/span>
template <template <class Created> class CreationPolicy>
class WidgetManager : public CreationPolicy<Widget>
{
};
void main()
{
    // Application code
typedef WidgetManager<OpNewCreator> MyWidgetMgr;
}

对于上面一个策略有3中不同的实现�Q�从而就可以满��不同的客��L��需求�?br>但是对于上面的��用，我们�q�可以有更好的修改：因�ؓPolicy的实现class一般会被��承，所以我们要考虑他的析构�Q�一般的我们使析构函数virtual�Q�但是这里会影响template的静态编译特性，影响效率�Q�所以我们��用protected或private的析构函敎ͼ�既不影响�l�承�c�d��基类的析构，也不影响使用�?br>如修改如下：

template <class T>
struct OpNewCreator
{
   static T* Create()
   {
    return new T;
   }
protected:
   ~OpNewCreator() {}
};

我们�q�可以修改上面的manger�Q�实现creator policy的switch�Q?br>

template <template <class> class CreationPolicy>
class WidgetManager : public CreationPolicy<Widget>
{
   void SwitchPrototype(Widget* pNewPrototype)
   {
      CreationPolicy<Widget>& myPolicy = *this;
      delete myPolicy.GetPrototype();
      myPolicy.SetPrototype(pNewPrototype);
   }
};

�?policy 模式�Ҏ��们创建可复用�Q�可扩展的库的开发有非常重要的作用，是OO的基本的讑֎�则式之一�?br>

梦在天�� 2007-05-24 19:42 发表评论

设计模式随笔分类

梦在天�� — Sun, 04 Mar 2007 03:31:00 GMT

梦在天�� 2007-03-04 11:31 发表评论

梦在天�� — Thu, 25 May 2006 05:39:00 GMT

This main topic of this article is to show how patterns are used in MFC. We will be seeing the usage of three patterns in MFC library.

Creational : Singleton Pattern

First step in any MFC application is the creation of application object (object of class derived from CWinApp). There should be only one application object in an instance of MFC application. CWinApp is designed to make sure that only application object is present in a given instance. CWinApp and its descendants are called Singleton Classes. A class (CWinApp or its descendant) that assures a maximum of ONE object of its type at a given time and provides a global access point (AfxGetApp() method) to this object is a Singleton class.

As this principle is applied over and over again to solve recurring object "creational" problems, this becomes a pattern. Singleton Pattern ensures that a class only has one instance and provides a global access point it. The article Creating Singleton Objects using Visual C++ talks about different approaches for implementing Singletons.

Structural : Bridge Pattern

Bridge Pattern is all about decoupling an abstraction (interface) from its implementation so that the two can vary independently. In MFC, the process of storing/retrieving an object to/from a persistence mechanism (like a file) is called Serialization. MFC uses the Bridge Pattern to implement Serialization. CArchive and CFile classes implement object Serialization. CArchive class provides the interface for writing/reading an object to/from a persistence mechanism whereas the CFile and its sub classes provides implementation for different persistence mechanisms such as memory, disk file, sockets etc.

A CArchive object is configured with an object of class CFile (or a derived class) during its construction, from which it obtains the necessary information for serialization, including the filename and type of the requested operation (a read or write). Client performing the Serialization operation can use CArchive object without regarding the persistence mechanism implemented by CFile classes.

The article Bridge Pattern - Bridging the gap between Interface and Implementation talks about Bridge pattern in detail.

Behavioral : Observer Pattern

The Observer Pattern is intended to "Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically". An object that is subjected to change is called a Subject and an object that depends on the Subject's state is called an Observer.

MFC uses a Document/View variant of the Observer Pattern. MFC's famous Document/View architecture uses this variant. A document contains the data object and acts as a Subject. A view is a window object through which the user updates the document and it acts as an Observer. A document can have multiple views. Whenever the data in the document is changed by one of the views, it updates the document by calling UpdateAllViews method, with optional hint about the modification. To inform about the change to other views, the document object calls OnUpdate method for each view attached to it (except the view that called UpdateAllViews). Derived view classes can override the OnUpdate method and update themselves by querying the data from the document.

The article Applying Observer Pattern in C++ Applications talks about Observer pattern in detail.

Summary

Design Pattern provides a common language for designers and helps them to decompose systems into a set of cooperating classes and objects. They provide proven design solution to recurring problems. In this article, I have introduced the design pattern and how MFC is using some of the patterns in its design. We can easily find more and more patterns when we dig into MFC and its classes.

梦在天�� 2006-05-25 13:39 发表评论

接口模式 -- 接口中�ؓ什么不能包含delegate

梦在天�� — Thu, 18 May 2006 07:21:00 GMT

接口模式 : interface and abstract calss

接口可以包含function, property, index, event ,但是不能包含 delegate:
:因�ؓ一个接口声明规范了成员,不是�c�d��. delegate引入一个新的类�?而event引入的是一个新的成�?

梦在天�� 2006-05-18 15:21 发表评论

.net中更好的使用设计模式的DLL(Commonly Used .NET Coding Patterns in CodeDom)(�?

梦在天�� — Tue, 09 May 2006 01:46:00 GMT

Download binary - 263 Kb

Download source - 275 Kb

Introduction
Argument Assertion patterns
The Asynchronous Operation pattern
The BeginProcess/EndProcess pattern
Binary Operator patterns
Compound Assignment patterns
The Cursor Lock pattern
The Custom Attribute pattern
The Custom Exception pattern
The Delegate pattern
The Disposable Type pattern
The Event pattern
The Flags pattern
The For Each pattern
The Get Property/Field pattern
The Is Instance Of pattern
The Lock pattern
The Observer pattern
The Singleton pattern
The Typed Collection pattern
Unary Operator patterns
The Using pattern
XML Comment patterns
History
License

原文地址:http://www.codeproject.com/csharp/codedompatterns.asp

梦在天�� 2006-05-09 09:46 发表评论

模式设计c#�Q�－行�ؓ型－�Q�visitor

梦在天�� — Tue, 03 Jan 2006 08:18:00 GMT

名称	Visitor
�l�构
意图	表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的�cȝ��前提下定义作用于�q�些元素的新操作�?/td>
适用�?/td>	一个对象结构包含很多类对象�Q�它们有不同的接口，而你惛_��q�些对象实施一些依赖于其具体类的操作�? 需要对一个对象结构中的对象进行很多不同的�q�且不相关的操作�Q�而你想避免让�q�些操作“污染”这些对象的�c�R��Vi s i t o r 使得你可以将相关的操作集中�v来定义在一个类中。当该对象结构被很多应用�׃�n�Ӟ��用Vi s i t o r 模式让每个应用仅包含需要用到的操作�? 定义对象�l�构的类很少改变�Q�但�l�常需要在此结构上定义新的操作。改变对象结构类需要重定义�Ҏ��有访问者的接口�Q�这可能需要很大的代�h。如果对象结构类�l�常改变�Q�那么可能还是在�q�些�c�M��定义�q�些操作较好�?

// Visitor pattern -- Structural example

																using System;
using System.Collections;

namespace DoFactory.GangOfFour.Visitor.Structural
{
  
  // MainApp test application 

  class MainApp
  {
    staticvoid Main()
    {
      // Setup structure 
      ObjectStructure o = new ObjectStructure();
      o.Attach(new ConcreteElementA());
      o.Attach(new ConcreteElementB());

      // Create visitor objects 
      ConcreteVisitor1 v1 = new ConcreteVisitor1();
      ConcreteVisitor2 v2 = new ConcreteVisitor2();

      // Structure accepting visitors 
      o.Accept(v1);
      o.Accept(v2);

      // Wait for user 
      Console.Read();
    }
  }

  // "Visitor" 

  abstractclass Visitor
  {
    publicabstractvoid VisitConcreteElementA(
      ConcreteElementA concreteElementA);
    publicabstractvoid VisitConcreteElementB(
      ConcreteElementB concreteElementB);
  }

  // "ConcreteVisitor1" 

  class ConcreteVisitor1 : Visitor
  {
    publicoverridevoid VisitConcreteElementA(
      ConcreteElementA concreteElementA)
    {
      Console.WriteLine("{0} visited by {1}",
        concreteElementA.GetType().Name, this.GetType().Name);
    }

    publicoverridevoid VisitConcreteElementB(
      ConcreteElementB concreteElementB)
    {
      Console.WriteLine("{0} visited by {1}",
        concreteElementB.GetType().Name, this.GetType().Name);
    }
  }

  // "ConcreteVisitor2" 

  class ConcreteVisitor2 : Visitor
  {
    publicoverridevoid VisitConcreteElementA(
      ConcreteElementA concreteElementA)
    {
      Console.WriteLine("{0} visited by {1}",
        concreteElementA.GetType().Name, this.GetType().Name);
    }

    publicoverridevoid VisitConcreteElementB(
      ConcreteElementB concreteElementB)
    {
      Console.WriteLine("{0} visited by {1}",
        concreteElementB.GetType().Name, this.GetType().Name);
    }
  }

  // "Element" 

  abstractclass Element
  {
    publicabstractvoid Accept(Visitor visitor);
  }

  // "ConcreteElementA" 

  class ConcreteElementA : Element
  {
    publicoverridevoid Accept(Visitor visitor)
    {
      visitor.VisitConcreteElementA(this);
    }

    publicvoid OperationA()
    {
    }
  }

  // "ConcreteElementB" 

  class ConcreteElementB : Element
  {
    publicoverridevoid Accept(Visitor visitor)
    {
      visitor.VisitConcreteElementB(this);
    }

    publicvoid OperationB()
    {
    }
  }

  // "ObjectStructure" 

  class ObjectStructure
  {
    private ArrayList elements = new ArrayList();

    publicvoid Attach(Element element)
    {
      elements.Add(element);
    }

    publicvoid Detach(Element element)
    {
      elements.Remove(element);
    }

    publicvoid Accept(Visitor visitor)
    {
      foreach (Element e in elements)
      {
        e.Accept(visitor);
      }
    }
  }
}

Output

ConcreteElementA visited by ConcreteVisitor1
ConcreteElementB visited by ConcreteVisitor1
ConcreteElementA visited by ConcreteVisitor2
ConcreteElementB visited by ConcreteVisitor2

梦在天�� 2006-01-03 16:18 发表评论

模式设计c#�Q�－行�ؓ型－�Q�strategy

梦在天�� — Tue, 03 Jan 2006 08:17:00 GMT

摘要: 名称 Strategy �l�构意图定义一�p�d��的算�?把它们一个个��装��h��, �q�且使它们可�怺�替换。本模式使得��法可独立于使用它的客户而变化�? ... 阅读全文

梦在天�� 2006-01-03 16:17 发表评论

模式设计c#�Q�－行�ؓ型－�Q�state

梦在天�� — Tue, 03 Jan 2006 08:15:00 GMT

摘要: 名称 State �l�构意图允许一个对象在其内部状态改变时改变它的行�ؓ。对象看��h��g��修改了它的类�? �?.. 阅读全文

梦在天�� 2006-01-03 16:15 发表评论

模式设计c#�Q�－行�ؓ型－�Q�observer

梦在天�� — Tue, 03 Jan 2006 08:13:00 GMT

摘要: 名称 Observer �l�构意图定义对象间的一�U�一对多的依赖关�p?当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知�q�被自动更新�? ... 阅读全文

梦在天�� 2006-01-03 16:13 发表评论

模式设计c#�Q�－行�ؓ型－�Q�menento

梦在天�� — Tue, 03 Jan 2006 08:12:00 GMT

摘要: 名称 Memento �l�构意图在不破坏��装性的前提下，捕获一个对象的内部状态，�q�在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态�?... 阅读全文

梦在天�� 2006-01-03 16:12 发表评论

模式设计c#�Q�－行�ؓ型－�Q�mediator

梦在天�� — Tue, 03 Jan 2006 08:10:00 GMT

摘要: 名称 Mediator �l�构意图用一个中介对象来��装一�p�d��的对象交互。中介者��各对象不需要显式地�怺�引用�Q�从而��其耦合松散�Q�而且可以独立地改变它们之间的... 阅读全文

梦在天�� 2006-01-03 16:10 发表评论

模式设计c#�Q�－行�ؓ型－�Q�iterator

梦在天�� — Tue, 03 Jan 2006 08:08:00 GMT

名称	Iterator
�l�构
意图	提供一�U�方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示�?/TD>
适用�?/TD>	讉K��一个聚合对象的内容而无需暴露它的内部表示�? 支持对聚合对象的多种遍历�? 为遍历不同的聚合�l�构提供一个统一的接�?�? 支持多态�P�?�?

namespace Iterator_DesignPattern
{
    using System;
    using System.Collections;

    class Node
    {
        private string name;
        public string Name
        {
            get
            {
                return name;
            }
        }
        public Node(string s)
        {
            name = s;
        }
    }

    class NodeCollection
    {
        private ArrayList list = new ArrayList();
        private int nodeMax = 0;

        // left as a student exercise - implement collection
        // functions to remove and edit entries also
        public void AddNode(Node n)
        {
            list.Add(n);
            nodeMax++;
        }
        public Node GetNode(int i)
        {
            return ((Node) list[i]);
        }

        public int NodeMax
        {
            get
            {
                return nodeMax;
            }
        }
    }

    /*
     * The iterator needs to understand how to traverse the collection
     * It can do that as way it pleases - forward, reverse, depth-first,
     */
    abstract class Iterator
    {
        abstract public Node Next();
    }

    class ReverseIterator : Iterator
    {
        private NodeCollection nodeCollection;
        private int currentIndex;

        public ReverseIterator (NodeCollection c)
        {
            nodeCollection = c;
            currentIndex = c.NodeMax -1; // array index starts at 0!
        }

        // note: as the code stands, if the collection changes,
        // the iterator needs to be restarted
        override public Node Next()
        {
            if (currentIndex == -1)
                return null;
            else
                return(nodeCollection.GetNode(currentIndex--));
        }
    }

    ///

/// Summary description for Client.
///

    public class Client
    {
        public static int Main(string[] args)
        {
            NodeCollection c = new NodeCollection();
            c.AddNode(new Node("first"));
            c.AddNode(new Node("second"));
            c.AddNode(new Node("third"));

            // now use iterator to traverse this
            ReverseIterator i = new ReverseIterator(c);

            // the code below will work with any iterator type
            Node n;
            do
            {
                n = i.Next();
                if (n != null)
                    Console.WriteLine("{0}", n.Name);
            } while (n != null);

            return 0;
        }
    }
}

梦在天�� 2006-01-03 16:08 发表评论

模式设计c#�Q�－行�ؓ型－�Q�command

梦在天�� — Tue, 03 Jan 2006 08:07:00 GMT

名称	Command
�l�构
意图	��一个请求封装�ؓ一个对象，从而��你可用不同的��h��对客戯��行参数化�Q�对��h��排队或记录请求日志，以及支持可撤消的操作�?/TD>
适用�?/TD>	抽象出待执行的动作以参数化某对象�Q�你可用�q�程语言中的回调�Q�c a l l b a c k �Q�函数表达这�U�参数化机制。所谓回调函数是指函数先在某处注册，而它��在�E�后某个需要的时候被调用。C o m m a n d 模式是回调机制的一个面向对象的替代品�? 在不同的时刻指定、排列和执行��h��。一个C o m m a n d 对象可以有一个与初始��h��无关的生存期。如果一个请求的接收者可用一�U�与地址�I�间无关的方式表达，那么��可��负责该��h��的命令对象传送给另一个不同的�q�程�q�在那儿实现该请求�? 支持取消操作。C o m m a n d 的E x c u t e 操作可在实施操作前将状态存储�v来，在取消操作时�q�个状态用来消除该操作的媄响。C o m m a n d 接口必须��d��一个U n e x e c u t e 操作�Q�该操作取消上一�ơE x e c u t e 调用的效果。执行的命��o被存储在一个历史列表中。可通过向后和向前遍历这一列表�q�分别调用U n e x e c u t e 和E x e c u t e 来实现重��C��限的“取消”和“重做”�? 支持修改日志�Q�这样当�pȝ��崩溃�Ӟ��q�些修改可以被重做一遍。在C o m m a n d 接口中添加装载操作和存储操作�Q�可以用来保持变动的一个一致的修改日志。从崩溃中恢复的�q�程包括从磁盘中重新��d��记录下来的命令�ƈ用E x e c u t e 操作重新执行它们�? 用构建在原语操作上的高层操作构造一个系�l�。这样一�U�结构在支持事务( t r a n s a c t i o n )的信息系�l�中很常见。一个事务封装了�Ҏ��据的一�l�变动。C o m m a n d 模式提供了对事务�q�行建模的方法。C o m m a n d 有一个公��q��接口�Q��得你可以用同一�U�方式调用所有的事务。同时��用该模式也易于添加新事务以扩展系�l��?

Code Example

namespace Command_DesignPattern
{
    using System;

    abstract class Command
    {
        abstract public void Execute();
        protected Receiver r;
        public Receiver R
        {
            set
            {
                r = value;
            }
        }
    }

    class ConcreteCommand : Command
    {
        override public void Execute()
        {
            Console.WriteLine("Command executed");
            r.InformAboutCommand();
        }
    }

    class Receiver
    {
        public void InformAboutCommand()
        {
            Console.WriteLine("Receiver informed about command");
        }

    }

    class Invoker
    {
        private Command command;
        public void StoreCommand(Command c)
        {
            command = c;
        }
        public void ExecuteCommand()
        {
            command.Execute();
        }
    }

    ///

/// Summary description for Client.
///

    public class Client
    {
        public static int Main(string[] args)
        {
            // Set up everything
            Command c = new ConcreteCommand();
            Receiver r = new Receiver();
            c.R = r;
            Invoker i = new Invoker();
            i.StoreCommand(c);

            // now let application run

            // the invoker is how the command is exposed for the end-user
            // (or a client) initiates the command,
            // (e.g. toolbar button, menu item)

            i.ExecuteCommand();

            return 0;
        }
    }
}

梦在天�� 2006-01-03 16:07 发表评论

模式设计c#�Q�－行�ؓ型－�Q�Chain of Responsibility

梦在天�� — Tue, 03 Jan 2006 08:06:00 GMT

摘要: 名称 Chain of Responsibility �l�构意图使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将�q�些对象�q�成一�?.. 阅读全文

梦在天�� 2006-01-03 16:06 发表评论

模式设计c#�Q�－行�ؓ型－�Q�templetemethod

梦在天�� — Tue, 03 Jan 2006 08:04:00 GMT

名称	Template Method
�l�构
意图	定义一个操作中的算法的骨架�Q�而将一些步骤�g�q�到子类中。Te m p l a t e M e t h o d 使得子类可以不改变一个算法的�l�构卛_��重定义该��法的某些特定步骤�?/td>
适用�?/td>	一�ơ性实��C��个算法的不变的部分，�q�将可变的行为留�l�子�c�L��实现�? 各子�c�M��公共的行为应被提取出来�ƈ集中��C��个公��q��c�M��以避免代码重复。这是O p d y k e 和J o h n s o n 所描述�q�的“重分解以一般化”的一个很好的例子[ O J 9 3 ]。首先识别现有代码中的不同之处，�q�且��不同之处分��Mؓ新的操作。最后，用一个调用这些新的操作的模板�Ҏ��来替换这些不同的代码�? 控制子类扩展。模板方法只在特定点调用“h o o k ”操作（参见效果一节）�Q�这样就只允许在�q�些点进行扩展�?

Code Example

namespace TemplateMethod_DesignPattern
{
    using System;

    class Algorithm
    {
        public void DoAlgorithm()
        {
            Console.WriteLine("In DoAlgorithm");

            // do some part of the algorithm here

            // step1 goes here
            Console.WriteLine("In Algorithm - DoAlgoStep1");
            // . . .

            // step 2 goes here
            Console.WriteLine("In Algorithm - DoAlgoStep2");
            // . . .

            // Now call configurable/replacable part
            DoAlgoStep3();

            // step 4 goes here
            Console.WriteLine("In Algorithm - DoAlgoStep4");
            // . . .

            // Now call next configurable part
            DoAlgoStep5();
        }

        virtual public void DoAlgoStep3()
        {
            Console.WriteLine("In Algorithm - DoAlgoStep3");
        }

        virtual public void DoAlgoStep5()
        {
            Console.WriteLine("In Algorithm - DoAlgoStep5");
        }
    }

    class CustomAlgorithm : Algorithm
    {
        public override void DoAlgoStep3()
        {
            Console.WriteLine("In CustomAlgorithm - DoAlgoStep3");
        }

        public override void DoAlgoStep5()
        {
            Console.WriteLine("In CustomAlgorithm - DoAlgoStep5");
        }
    }

    ///

/// Summary description for Client.
///

    public class Client
    {
        public static int Main(string[] args)
        {
            CustomAlgorithm c = new CustomAlgorithm();

            c.DoAlgorithm();

            return 0;
        }
    }
}

模板�Ҏ��Q�Template Method�Q�模�?

准备一个抽象类�Q�将部分逻辑以具体方法以及具体构造子的�Ş式实玎ͼ�然后声明一些抽象方法来�q��子类实现剩余的逻辑。不同的子类可以以不同的方式实现�q�些抽象�Ҏ��Q�从而对剩余的逻辑有不同的实现。这��是模版�Ҏ��模式的用意�?/p>

很多人可能没有想刎ͼ�模版�Ҏ��模式实际上是所有模式中最为常见的几个模式之一�Q�而且很多人可能��用过模版�Ҏ��模式而没有意识到自己已经使用了这个模式。模版方法模式是��Z��l�承的代码复用的基本技术，模版�Ҏ��模式的结构和用法也是面向对象设计的核心�?/p>

模版�Ҏ��模式需要开发抽象类和具体子�cȝ��设计师之间的协作。一个设计师负责�l�出一个算法的轮廓和骨�Ӟ��另一些设计师则负责给��个算法的各个逻辑步骤。代表这些具体逻辑步骤的方法称做基本方法（primitive method�Q�；而将�q�些基本法方法��L��h��的方法叫做模版方法（template method�Q�，�q�个设计模式的名字就是从此而来�?br /> 模版�Ҏ��模式中的�Ҏ��

模版�Ҏ��中的�Ҏ��可以分�ؓ两大�c�：模版�Ҏ��Q�Template Method�Q�和基本�Ҏ��Q�Primitive Method)�?/p>

模版�Ҏ��

一个模版方法是定义在抽象类中的�Q�把基本操作�Ҏ��l�合在一起�Ş成一个�ȝ��法或一个总行为的�Ҏ��。这个模版方法一般会在抽象类中定义，�q�由子类不加以修改地完全�l�承下来�?/p>

基本�Ҏ��

基本�Ҏ��又可以分��Z��U�：抽象�Ҏ��Q�Abstract Method�Q�、具体方法（Concrete Method�Q�和钩子�Ҏ��Q�Hook Method�Q��?/p>

抽象�Ҏ��Q�一个抽象方法由抽象�c�d��明，由具体子�c�d��现。在C#语言里一个抽象方法以abstract关键字标�C�出来�?/p>

具体�Ҏ��Q�一个具体方法由抽象�c�d��明�ƈ实现�Q�而子�c�dƈ不实现或�|�换。在C#语言里面�Q�一个具体方法没有abstract关键字�?/p>

钩子�Ҏ��Q�一个钩子方法由抽象�c�d��明�ƈ实现�Q�而子�c�M��加以扩展。通常抽象�cȝ��出的实现是一个空实现�Q�作为方法的默认实现。（Visual FoxPro中项目向导徏立的��目会��用一个AppHook�c�d��现监视项目成员变化，调整�pȝ��l�构的工作。）钩子�Ҏ��的名字通常以do开始�?/p>

梦在天�� 2006-01-03 16:04 发表评论

模式设计c#�Q�－行�ؓ型－�Q�interpreter

梦在天�� — Tue, 03 Jan 2006 08:02:00 GMT

摘要: 名称 Interpreter �l�构意图 �l�定一个语�a��Q�定义它的文法的一�U�表�C�，�q�定义一个解释器�Q�这个解释器使用该表�C�来解释语言中的句子�? ... 阅读全文

梦在天�� 2006-01-03 16:02 发表评论

模式设计c#�Q�－�l�构型－�Q�proxy

梦在天�� — Tue, 03 Jan 2006 07:51:00 GMT

摘要: 名称 Proxy �l�构意图为其他对象提供一�U�代理以控制对这个对象的讉K��? 适用�? ... 阅读全文

梦在天�� 2006-01-03 15:51 发表评论

模式设计c#�Q�－�l�构型－�Q�flyweight

梦在天�� — Tue, 03 Jan 2006 07:50:00 GMT

摘要: 名称 Flyweight �l�构意图 �q�用�׃�n技术有效地支持大量�l�粒度的对象�? 适用�? ... 阅读全文

梦在天�� 2006-01-03 15:50 发表评论

模式设计c#�Q�－�l�构型－�Q�facade

梦在天�� — Tue, 03 Jan 2006 07:48:00 GMT

摘要: 名称 Facade �l�构意图为子�pȝ��中的一�l�接口提供一个一致的界面�Q�F a c a d e 模式定义了一个高层接口，�q�个接口使得�q�一子系�l�更加容易��用�?.. 阅读全文

梦在天�� 2006-01-03 15:48 发表评论

模式设计c#�Q�－�l�构型－�Q�decorator

梦在天�� — Tue, 03 Jan 2006 07:47:00 GMT

摘要: 名称 Decorator �l�构意图动态地�l�一个对象添加一些额外的职责。就增加功能来说�Q�D e c o r a t o r 模式相比生成子类更�ؓ灉|��?... 阅读全文

梦在天�� 2006-01-03 15:47 发表评论

模式设计c#�Q�－�l�构型－�Q�composite

梦在天�� — Tue, 03 Jan 2006 07:45:00 GMT

摘要: 名称 Composite �l�构意图 ��对象组合成树�Ş�l�构以表�C�“部�?整体”的层次�l�构。C o m p o s i t e 使得用户对单个对象和�l�合对象�?.. 阅读全文

梦在天�� 2006-01-03 15:45 发表评论

模式设计c#�Q�－�l�构型－�Q�Bridge

梦在天�� — Tue, 03 Jan 2006 07:43:00 GMT

名称	Bridge
�l�构
意图	��抽象部分与它的实现部分分离�Q��它们都可以独立地变化�?/TD>
适用�?/TD>	你不希望在抽象和它的实现部分之间有一个固定的�l�定关系。例如这�U�情况可能是因�ؓ�Q�在�E�序�q�行时刻实现部分应可以被选择或者切换�? �cȝ��抽象以及它的实现都应该可以通过生成子类的方法加以扩充。这时B r i d g e 模式使你可以对不同的抽象接口和实现部分进行组合，�q�分别对它们�q�行扩充�? 对一个抽象的实现部分的修改应对客户不产生影响�Q�即客户的代码不必重新编译�? �Q�C + +�Q�你惛_��客户完全隐藏抽象的实现部分。在C + +中，�cȝ��表示在类接口中是可见的�? 有许多类要生成。这样一�U�类层次�l�构说明你必��d��一个对象分解成两个部分。R u m b a u g h �U�这�U�类层次�l�构为“嵌套的普化”（nested generalizations �Q��? 你想在多个对象间�׃�n实现�Q�可能��用引用计敎ͼ��Q�但同时要求客户�q�不知道�q�一炏V��一个简单的例子便是C o p l i e n 的S t r i n g �c�[ C o p 9 2 ]�Q�在�q�个�c�M��多个对象可以�׃�n同一个字�W�串表示�Q�S t r i n g R e p �Q��?

Code Example

namespace Bridge_DesignPattern
{
    using System;

    class Abstraction
    {
        protected Implementation impToUse;

        public void SetImplementation(Implementation i)
        {
            impToUse = i;
        }

        virtual public void DumpString(string str)
        {
            impToUse.DoStringOp(str);
        }
    }

    class DerivedAbstraction_One : Abstraction
    {
        override public void DumpString(string str)
        {
            str += ".com";
            impToUse.DoStringOp(str);
        }
    }

    class Implementation
    {
        public virtual void DoStringOp(string str)
        {
            Console.WriteLine("Standard implementation - print string as is");
            Console.WriteLine("string = {0}", str);
        }
    }

    class DerivedImplementation_One : Implementation
    {
        override public void DoStringOp(string str)
        {
            Console.WriteLine("DerivedImplementation_One - don't print string");
        }
    }

    class DerivedImplementation_Two : Implementation
    {
        override public void DoStringOp(string str)
        {
            Console.WriteLine("DerivedImplementation_Two - print string twice");
            Console.WriteLine("string = {0}", str);
            Console.WriteLine("string = {0}", str);
        }
    }

    ///

/// Summary description for Client.
///

    public class Client
    {
        Abstraction SetupMyParticularAbstraction()
        {
            // we localize to this method the decision which abstraction and
            // which implementation to use. These need to be decided
            // somewhere and we do it here. All teh rest of the client
            // code can work against the abstraction object.
            Abstraction a = new DerivedAbstraction_One();
            a.SetImplementation(new DerivedImplementation_Two());
            return a;
        }

        public static int Main(string[] args)
        {
            Client c = new Client();
            Abstraction a = c.SetupMyParticularAbstraction();

            // From here on client code thinks it is talking to the
            // abstraction, and will not need to be changed as
            // derived abstractions are changed.

            // more client code using the abstraction goes here
            // . . .
            a.DumpString("Clipcode");

            return 0;
        }
    }
}

梦在天�� 2006-01-03 15:43 发表评论

模式设计c#�Q�－�l�构型－�Q�Adapter

梦在天�� — Tue, 03 Jan 2006 07:41:00 GMT

摘要: 名称 Adapter �l�构意图 ��一个类的接口�{换成客户希望的另外一个接口。A d a p t e r 模式使得原本�׃��接口... 阅读全文

梦在天�� 2006-01-03 15:41 发表评论

模式设计c#�Q�－创徏型－�Q�Singleton

梦在天�� — Tue, 03 Jan 2006 06:58:00 GMT

摘要: 名称 Singleton �l�构意图保证一个类仅有一个实例，�q�提供一个访问它的全局讉K��炏V�? 适用�? ... 阅读全文

梦在天�� 2006-01-03 14:58 发表评论

模式设计c#�Q�－创徏型－�Q�Prototype

梦在天�� — Tue, 03 Jan 2006 06:53:00 GMT

摘要: 阅读全文

梦在天�� 2006-01-03 14:53 发表评论

模式设计c#�Q�－创徏型－�Q�Builder

梦在天�� — Tue, 03 Jan 2006 06:47:00 GMT

摘要: 阅读全文

梦在天�� 2006-01-03 14:47 发表评论

模式设计c#�Q�－创徏型－�Q�AbstractFactory

梦在天�� — Tue, 03 Jan 2006 06:43:00 GMT

摘要: 阅读全文

梦在天�� 2006-01-03 14:43 发表评论

模式设计c#�Q�－创徏型－�Q�factory method

梦在天�� — Tue, 03 Jan 2006 06:28:00 GMT

摘要: 阅读全文

梦在天�� 2006-01-03 14:28 发表评论

梦在天�� — Tue, 03 Jan 2006 06:20:00 GMT

	创徏�?/TD>	�l�构�?/TD>	行�ؓ�?/TD>
�c?/TD>	Factory Method	Adapter_Class	Interpreter Template Method
对象	Abstract Factory Builder Prototype Singleton	Adapter_Object Bridge Composite Decorator Facade Flyweight Proxy	Chain of Responsibility Command Iterator Mediator Memento Observer State Strategy Visitor
概览

梦在天�� 2006-01-03 14:20 发表评论

亚洲一级黄色,亚洲一区二区av电影,国产欧美日韩伦理

设计模式随笔分类

Creational : Singleton Pattern

Structural : Bridge Pattern

Behavioral : Observer Pattern

Summary

接口模式 -- 接口中�ؓ什么不能包含delegate

.net中更好的使用设计模式的DLL(Commonly Used .NET Coding Patterns in CodeDom)(�?

Table of contents

原文地址:http://www.codeproject.com/csharp/codedompatterns.asp

模式设计c#�Q�－行�ؓ型－�Q�visitor

模式设计c#�Q�－行�ؓ型－�Q�strategy

模式设计c#�Q�－行�ؓ型－�Q�state

模式设计c#�Q�－行�ؓ型－�Q�observer

模式设计c#�Q�－行�ؓ型－�Q�menento

模式设计c#�Q�－行�ؓ型－�Q�mediator

模式设计c#�Q�－行�ؓ型－�Q�iterator

模式设计c#�Q�－行�ؓ型－�Q�command

模式设计c#�Q�－行�ؓ型－�Q�Chain of Responsibility

模式设计c#�Q�－行�ؓ型－�Q�templetemethod

模式设计c#�Q�－行�ؓ型－�Q�interpreter

模式设计c#�Q�－�l�构型－�Q�proxy

模式设计c#�Q�－�l�构型－�Q�flyweight

模式设计c#�Q�－�l�构型－�Q�facade

模式设计c#�Q�－�l�构型－�Q�decorator

模式设计c#�Q�－�l�构型－�Q�composite

模式设计c#�Q�－�l�构型－�Q�Bridge

模式设计c#�Q�－�l�构型－�Q�Adapter

模式设计c#�Q�－创徏型－�Q�Singleton

模式设计c#�Q�－创徏型－�Q�Prototype

模式设计c#�Q�－创徏型－�Q�Builder

模式设计c#�Q�－创徏型－�Q�AbstractFactory

模式设计c#�Q�－创徏型－�Q�factory method