设计模式C#描述之——简单工厂模式、抽象工厂模式、单例与多例模式

简单工厂模式是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。一般涉及到三种角色（如下图）：

工厂类：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的类实现。
抽象产品角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或她们共同拥有的接口。一般由接口或抽象类实现。
具体产品角色：工厂方法模式所创建的任何对
象都是这个角色的实例，由具体类实现。


简单工厂模式优缺点：
模式的核心是工厂类，这个类负责产品的创建，而客户端可以免去产品创建的责任，这实现了责任的分割。但由于工厂类集中了所有产品创建逻辑的，如果不能正常工作的话会对系统造成很大的影响。如果增加新产品必须修改工厂角色的源码。

以园丁种植水果为例讨论该模式的具体实现：
Fruit 水果接口，规定水果具有的一些共同特性
Apple 苹果类 派生自Fruit接口
Strawberry 草莓类 派生自Fruit接口
FruitGardener 园丁类 负责草莓与苹果的创建工作。
当Client要创建水果（苹果或草莓对象）的时候调用园丁类的factory方法创建：ＵＭＬ图如下：

代码如下：
Fruit.cs
namespace Simple_Factory
{
public interface Fruit
{
//生长
void grow;
//收获
void harvest;
//种植
void plant;
}
}
Apple.cs
namespace Simple_Factory
{
public class Apple:Fruit
{
public Apple
{
}
#region Fruit 成员
public void grow
{
Console.WriteLine 'Apple is growing.......';
}
public void harvest
{
Console.WriteLine 'Apple is harvesting.......';
}
public void plant
{
Console.WriteLine 'Apple is planting.......';
}
#endregion
}
}
Strawberry.cs
namespace Simple_Factory
{
public class Strawberry:Fruit
{
public Strawberry
{
}
#region Fruit 成员
public void grow
{
Console.WriteLine 'Strawberry is growing.......';
}
public void harvest
{
Console.WriteLine 'Strawberry is harvesting.......';
}
public void plant
{
Console.WriteLine 'Strawberry is planting.......';
}
#endregion
}
}
FruitGardener.cs
namespace Simple_Factory
{
public class FruitGardener
{
//静态工厂方法
public static Fruit factorystring which
{
ifwhich.Equals 'Apple'
{
return new Apple;
}
else ifwhich.Equals 'Strawberry'
{
return new Strawberry ;
}
else
{
return null;
}
}
}
}
Client.cs
using System;
namespace Simple_Factory
{
class Client
{
[STAThread]
static void Mainstring[] args
{
Fruit aFruit=FruitGardener.factory 'Apple';//creat apple
aFruit.grow ;
aFruit.harvest ;
aFruit.plant;
aFruit=FruitGardener.factory 'Strawberry';//creat strawberry
aFruit.grow ;
aFruit.harvest ;
aFruit.plant;
}
}
}
输出如下：
Apple is growing.......
Apple is harvesting.......
Apple is planting.......
Strawberry is growing.......
Strawberry is harvesting.......
Strawberry is planting.......

设计模式C#描述——抽象工厂模式

<script language="javascript" src="http://blog.csdn.net/ad/js/edu_left_300-300.js" type="text/javascript"></script> 设计模式C#描述——抽象工厂模式 阅读此文应先阅读简单工厂模式与工厂方法模式 抽象工厂模式是对象的创建模式，它是工厂方法模式的进一步推广。 假 设一个子系统需要一些产品对象，而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分开，可以引进抽象 工厂模式。这样的话，消费产品的客户不需要直接参与产品的创建工作，而只需要向一个公用的工厂接口请求所需要的产品。 采用抽象工厂模式设计出的系统类图如下。 从上图可以看到，抽象工厂模式设计到以下的角色： 抽象工厂角色：担任这个角色的是工厂方法模式的核心，它是与应用系统的商业逻辑无关的。通常使用接口或抽象类实现。 具体工厂角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。通常使用具体的类实现。 抽象产品角色：担任这个角色的类是抽象工厂方法模式所创建的对象的父类，或它们共同拥有的接口。通常使用接口或抽象类实现这一角色。 具体产品角色：抽象工厂模式所创建的任何产品对象都是某一具体产品类的实例。这是客户端最终需要的东西。通常使用具体类实现这个角色。 下面给出这个系统的原代码： Creator: public interface Creator { ProductA factoryA; ProductB factoryB; } ConcreteCreator1: public class ConcreteCreator1:Creator { public ProductA factoryA { return new ProductA1; } public ProductB factoryB { return new ProductB1; } } ConcreteCreator2: public class ConcreteCreator2:Creator { public ProductA factoryA { return new ProductA2; } public ProductB factoryB { return new ProductB2; } } ProductA: public interface ProductA { } ProductA1: public class ProductA1:ProductA { public ProductA1 { } } ProductA2: public class ProductA2:ProductA { public ProductA2 { } } ProductB: public interface ProductB { } ProductB1: public class ProductB1:ProductB { public ProductB1 { } } ProductB2: public class ProductB2:ProductB { public ProductB2 { } } 在以下情况下应该使用抽象工厂模式： 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。 这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

设计模式C#描述——单例与多例模式

<script language="javascript" src="http://blog.csdn.net/ad/js/edu_left_300-300.js" type="text/javascript"></script> 设计模式C#描述——单例与多例模式 作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式有以下特点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 一个典型的单例类的实现如下所示：其中构造子私有表示子类不能被继承。 public class Singleton { private static Singleton m_instance = null; private Singleton { } public static Singleton getInstance { ifm_instance==null { m_instance=new Singleton; } return m_instance; } } 所谓多例模式，实际上就是单例模式的自然推广，单例类一般情况下只可以有一个实例，但单例类也可以推广到允许有限个实例，这种模式就是多例模式。作为对象的创建模式，多例模式有以下特点： 多例类可以有多个实例。 多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。 多例类分为有上限多例类与无上限多例类。 一个有上限的多例类已经把实例的上限当作逻辑的一部分，并建造到了多例类的内部。如下： public class Multiton { private static Multiton instance1=null; private static Multiton instance2=null; private Multiton { } public static Multiton getInstanceint whichOne { ifwhichOne==1 { ifinstance1==null { instance1=new Multiton ; } return instance1; } else { ifinstance2==null { instance2=new Multiton ; } return instance2; } } } 多例类的实例数目不需要有上限，实例数目没有上限的多例模式就叫做无上限多例模式。由于没有上限的多例类对实例的数目是没有限制的，因此，虽然这种多例模式是单例模式的推广，但是这种多例类并不一定能够回到单例类。一般采用聚集管理所有的实例。