设计模式

1、单件模式Singleton：

public class LogWriter

{
//申明一个静态的变量，类型为类本身
private static LogWriter _instance = null;

//将类的构造函数私有化，使得这个类不可以被外界创建
private LogWriter()
{
}

//提供静态的方法，创建类的实例
public static LogWriter GetInstance()
{
if (_instance == null)
{
_instance = new LogWriter();
}
return _instance;
}

//下面实现类的其他功能
//....
}

调用者不可以通过new的形式得到Singleton的实例，调用的例子如下：
LogWriter log = LogWriter.GetInstance();
log.Debug("hello world");

 

单件模式适用于整个系统中某个对象是唯一的，或者是有固定数量的情况

2、工厂模式Factory

工厂模式的要点：

    1：存在一个创建对象的工厂；

    2：调用者从工厂中取得某些对象；

    3：由工厂决定如何创建对象；

    4：客户不知道对象是如何生成的。

Namer对象是FirstFirst和LastFirst的基类，用户调用Namer类的时候，不直接new出Namer类或者他的子类，而是使用NameFactory的getName方法得到具体的对象。这样在用户就不用关心自己正在使用的是哪一个Namer，正在调用哪一个方法。用户只针对Namer进行工作，而不用关心具体的类型。在实际工程中可以将Namer类的子类的构造函数只对NameFactory开放，进一步限制程序员。

C＃代码如下：
1：Namer的实现
using System; 
namespace NameFactory
{
      /// <summary>
     /// Summary description for Namer.
    /// </summary>
    //Base class for getting split names
    public class Namer 

    {
         //parts stored here
         protected string frName, lName; 

         //return first name
         public string getFrname()

         {
              return frName;
        }

        //return last name
        public string getLname()

        {
             return lName;
       }
    }
}

2：FirstFirst类的实现

using System;
namespace NameFactory
{
/// <summary>
/// Summary description for FirstFirst.

/// </summary>
public class FirstFirst : Namer
{
public FirstFirst(string name)
{

int i = name.IndexOf (" ");
if(i > 0) {
frName = name.Substring (0, i).Trim ();
lName = name.Substring (i + 1).Trim ();
}
else {
lName = name;
frName = "";
}
}
}
}

3：LastFirst类的实现
using System;
namespace NameFactory
{
/// <summary>
/// Summary description for LastFirst.
/// </summary>
public class LastFirst : Namer
{
public LastFirst(string name) {
int i = name.IndexOf (",");
if(i > 0) {
lName = name.Substring (0, i);
frName = name.Substring (i + 1).Trim ();
}
else {
lName = name;
frName = "";
}
}
}
}

4：NameFactory，工厂的实现

using System;
namespace NameFactory
{
/// <summary>
/// Summary description for NameFactory.
/// </summary>

public class NameFactory {
public NameFactory() {}
public Namer getName(string name) {
int i = name.IndexOf (",");
if(i > 0)
return new LastFirst (name);
else
return new FirstFirst (name);
}
}
} 

3、组合模式Composite

GameBox的代码：
public class GameBox
{
public void PlayGame()
{
Console.WriteLine("plaly game");
}
}

InternetBox的代码：
public class InternetBox
{
public void ConnectToInternet()
{
Console.WriteLine("connect to internet");
}
public void GetMail()
{
Console.WriteLine("check email");
}
}

XBox的代码：
public class XBox
{
private GameBox mGameBox=null;
private InternetBox mInternetBox=null;

public XBox()
{
mGameBox = new GameBox();
mInternetBox = new InternetBox();
}
public void PlayGame()
{
mGameBox.PlayGame();
}

public void ConnectToInternet()
{
mInternetBox.ConnectToInternet();
}

public void GetMail()
{
mInternetBox.GetMail();
}
}


XBox中封装了GameBox和InternetBox的方法，这样，用户面对的情况就大大的简化了，调用的代码如下：
public class CSComposite
{
static void Main (string[] args)
{
XBox x = new XBox();
Console.WriteLine("PlayGame!");
x.PlayGame();
Console.WriteLine();
Console.WriteLine("Internet Play Game!");
x.ConnectToInternet();
x.PlayGame();
Console.WriteLine();
Console.WriteLine("E-Mail!");
x.GetMail();
}
}

4、 命令模式Command

Command类是ICommand的实现，Command类实现了execute方法，其他命令类都是Command方法的子类。这样激发者接受者和接受者面临的环境就非常简单了：统一作为Command类型就可以处理了。

最简单的命令模式的实现代码如下：

///定义Command接口
public interface ICommand
{
void execute();
}

///实现ICommand接口
///Command类是所有命令的基类，在这里实现一些命令的共同处理过程
public abstract class Command : ICommand
{
public virtual void execute()
{
}
//实现其他的方法....
}

///实现一个具体的Command1
public class Command1 : Command
{
public void override execute()
{
//具体的处理过程
}
}

///实现一个具体的Command2
public class Command2 : Command
{
public void override execute()
{
//具体的处理过程
}
}

///实现一个具体的Command3
public class Command3 : Command
{
public void override execute()
{
//具体的处理过程
}
}