设计模式：原型模式C#实现,源代码

原型模式也属于创建型模式中的一种，面向对象系统中，原型模式在创建一些有固定样子的对象非常有效，这一节主要总结各个网站（csdn、博客园等）对原型模式的探讨，并且给出一个C#实现原型设计模式的代码。
1、原型模式定义
（1）、用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.
（2）、 原型模式多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；或者创建值相等，只是命名不一样的同类数据。
2、原型模式的优点
（1）、Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
（2）、我们在设计软件的时候，面临的产品类是动态变化的，这些产品类又具有一定得等级结构，如何封装这种变化，从而使这些容易变化的产品对象不随产品类变化，就需要原型模式了
3、原型模式的UML类图
4、C#代码实现
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace Prototype.Design.Pattern
{
class Program
{//运行主程序
static void Main(string[] args)
{
ConcretePotoType1 p1 = new ConcretePotoType1("I");
ConcretePotoType1 c1 = (ConcretePotoType1)p1.Clone();
Console.WriteLine("Cloned:{0}", c1.ID);
ConcretePotoType2 p2 = new ConcretePotoType2("II");
ConcretePotoType2 c2 = (ConcretePotoType2)p2.Clone();
Console.WriteLine("Cloned:{0}", c2.ID);
ColorManager colorm = new ColorManager();
colorm["red"] = new Color(255, 0, 0);
colorm["green"] = new Color(0, 255, 0);
colorm["blue"] = new Color(0, 0, 255);
colorm["angry"] = new Color(255, 54, 0);
colorm["peace"] = new Color(128, 211, 128);
colorm["flame"] = new Color(245, 124, 157);
string colorName = "red";
Color cc1 = (Color)colorm[colorName].Clone();
cc1.Display();
colorName = "flame";
cc1 = (Color)colorm[colorName].Clone();
cc1.Display();
Console.ReadKey();
}
}
//抽象原型
public abstract class PotoType
{
private string id;
public PotoType(string id)
{this.id = id;}
public string ID
{get { return id; }}
abstract public PotoType Clone();
}
//具体实现的原型
public class ConcretePotoType1 : PotoType
{
public ConcretePotoType1(string id) : base(id) { }
public override PotoType Clone()
{
return (PotoType)this.MemberwiseClone();
}
}
//具体实现的原型
public class ConcretePotoType2 : PotoType
{
public ConcretePotoType2(string id) : base(id) { }
public override PotoType Clone()
{
return (PotoType)this.MemberwiseClone();
}
}
#region 扩展性的模式
public abstract class ColorPrototype
{
public abstract ColorPrototype Clone();
}
public class Color : ColorPrototype
{
private int red, green, blue;
public Color(int red, int green, int blue)
{
this.red = red;this.green = green;this.blue = blue;
}
public override ColorPrototype Clone()
{
return (ColorPrototype)this.MemberwiseClone();
}
public void Display()
{
Console.WriteLine("RGB values are: {0},{1},{2}",
red, green, blue);}
}
public class ColorManager
{
Hashtable colors = new Hashtable();
public ColorPrototype this[string name]
{
set { colors.Add(name, value); }
get { return (ColorPrototype)colors[name]; }
}
}
#endregion
}

设计模式：抽象工厂模式C#实现,源代码

前一篇文章介绍了简单工厂和工厂方法模式,这次讨论抽象工厂模式。
1、抽象工厂模式定义
抽象工厂模式也叫Abstract Factory模式，是由GoF提出的23种设计模式中的一种，也是对象创建型模式之一。它提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它提供一个接口，以创建多个相关联的对象，而无需具体指定其具体的类。形象地说，它是一个工厂，能够生产众多产品。当用户需要某种产品的时候，不需要去关心这个产品的具体实现，而只需要指定产品的名称，抽象工厂就能够按你的要求进行生产。这里所指的产品，在C#中我们代表的是一个实例的类。
2、在什么情况下使用抽象工厂模式
在面向对象的程序设计中，我们经常会定义许多类，并通过new对其进行实例化。一旦类对象较多，且在实例化的时候，要做的初始化工作比较复杂的时候，我们就可以通过抽象工厂来管理。根据对象的性质和内容分别抽象成类，同时定义接口和接口方法。一旦定义了抽象工厂，实例类的工作就交给工厂，使用者只需要告诉工厂，你实例化的对象是什么就行了。
3、抽象工厂模式实现原理
抽象工厂模式（Abstract Factory）强调的是对象组合机制，由在父工厂内定义不同的“子工厂”对象来负责不同的目标对象的创建。请注意下面要点：
（1）、 抽象工厂模式中，产品（目标对象）的使用者可能需要使用具体的子工厂来生成该产品；
（2）、抽象工厂模式采用传参数的形式直接在父工厂内决定该产品对象应该由哪一个子工厂生产。即Abstract Factory模式中，跟客户打交道的只有抽象工厂与抽象产品，客户不需要知道产品由哪个工厂生产，也不需要知道被生产的是哪一种具体的产品；
（3）、Factory Method模式中，省城的对象产品只限定于某一类产品；Abstract Factory模式则可以提供多个生产接口生成多类产品；
（4） 、Abstract Factory模式Factory Method模式的更高层次的抽象，也更最具一般性。可以把Factory Method模式看作是Abstract Factory模式的一种特殊情况。
4、C#实现代码
using System;
using System.Collections.Generic;
using System.Text;
namespace AbstractFactory.Design.Pattern
{
class Program
{
static void Main(string[] args)
{
IAbstratFactory factory1 = new ConcreteFactory1();
IAbstratFactory factory2 = new ConcreteFactory2();
Evironment e1 = new Evironment(factory1);
Evironment e2 = new Evironment(factory2);
e1.Show();
e2.Show();
e1.Run();
e2.Run();
Console.ReadKey();
}
}
//抽象产品
public interface IAbstractProduceA
{
void MakeProduce();
}
public interface IAbstractProduceB
{
void InterTract(IAbstractProduceA a);
}
//具体产品
public class ProduceA1:IAbstractProduceA
{
public void MakeProduce()
{
Console.WriteLine("ProduceA1 is Created now!");
}
}
public class ProduceB1 : IAbstractProduceB
{
public void InterTract(IAbstractProduceA a)
{
Console.WriteLine(this + " contact with " + a);
}
}
public class ProduceA2 : IAbstractProduceA
{
public void MakeProduce()
{
Console.WriteLine("ProduceA2 is Created now!");
}
}
public class ProduceB2 : IAbstractProduceB
{
public void InterTract(IAbstractProduceA a)
{
Console.WriteLine(this+" contact with "+a);
}
}
//抽象工厂
public interface IAbstratFactory
{
IAbstractProduceA CreateProduceA();
IAbstractProduceB CreateProduceB();
}
//具体工厂
public class ConcreteFactory1 : IAbstratFactory
{
public IAbstractProduceA CreateProduceA()
{
return new ProduceA1();
}
public IAbstractProduceB CreateProduceB()
{
return new ProduceB1();
}
}
public class ConcreteFactory2 : IAbstratFactory
{
public IAbstractProduceA CreateProduceA()
{
return new ProduceA2();
}
public IAbstractProduceB CreateProduceB()
{
return new ProduceB2();
}
}
//客户端
public class Evironment
{
private IAbstractProduceA abstractProdueA;
private IAbstractProduceB abstractProdueB;
public Evironment(IAbstratFactory factory)
{
abstractProdueA = factory.CreateProduceA();
abstractProdueB = factory.CreateProduceB();
}
public void Show()
{
abstractProdueA.MakeProduce();
}
public void Run()
{
abstractProdueB.InterTract(abstractProdueA);
}
}

设计模式：单件模式C#实现,源代码

单件模式属于创建型模式，创造性模式主要是关注于如何以及何时创建对象。Singleton 模式可以保证一个类有且只有一个实例，并提供一个访问它的全局访问点。在程序设计过程中，有很多情况需要确保一个类只能有一个实例。
namespace Singleton.Design.Pattern
{
class Program
{
static void Main(string[] args)
{
//Singleton e = new Singleton(); 这是错误的，因为已经设定为保护类型了
Singleton instance = Singleton.Instance();
instance.Show();
Console.ReadKey();
}
}
public class Singleton
{
private static Singleton instance;
protected Singleton()
{
}
public static Singleton Instance()
{
if (instance == null)
{
instance = new Singleton();
}
return instance;
}
public void Show()
{
Console.WriteLine("Singleton is Show now!");
}
}
}

设计模式：简单工厂和工厂方法的C#实现

设计模式中工厂方法包括了：简单工厂，工厂方法和抽象工厂，下面给出简单工厂和工厂方法的C#实现，你可以直接拷贝运行。
namespace Factory.Design.Pattern
{
class Program
{
static void Main(string[] args)
{
//设计模式之简单工厂
//LightSimpleFactory lsf = new LightSimpleFactory();
//Light lsb= lsf.Create("Blue");
//Light lsr = lsf.Create("Red");
//lsb.TurnOn();
//lsr.TurnOn();

//设计模式之工厂方法
CreatorMethod cb = new BlueCreator();
CreatorMethod cr = new RedCreator();
Light lb = cb.factory();
Light lr = cr.factory();
lb.TurnOn();
lr.TurnOn();
Console.ReadKey();
}
}
public abstract class Light
{
public abstract void TurnOn();
}
public class BlueLight : Light
{
public override void TurnOn()
{
Console.WriteLine("Blue Light is turn on!");
}
}
public class RedLight : Light
{
public override void TurnOn()
{
Console.WriteLine("Red Light is turn on!");
}
}
#region 简单工厂
public class LightSimpleFactory
{
public Light Create(string LightType)
{
switch (LightType)
{
case "Blue":
{
return new BlueLight();
}
case "Red":
{
return new RedLight();
}
default:
{
return null;
}
}
}
}
#endregion
#region 工厂方法
public abstract class CreatorMethod
{
public abstract Light factory();
}
public class BlueCreator : CreatorMethod
{
public override Light factory()
{
return new BlueLight();
}
}
public class RedCreator : CreatorMethod
{
public override Light factory()
{
return new RedLight();
}
}
#endregion
}

什么叫设计模式

现在网上有大量的文章写设计模式，无论是Gof的23种设计模式，还是其他自己创造处理的模式，但是在做这些工作之前应该深入理解什么叫设计模式。
总的来说，设计模式是一各个编程套路，类似于建筑设计，网上也有关于什么叫设计模式的经典分析，下面仅仅作为摘要简述：
1、来自豆瓣网的声音：
　　设计模式并不是什么新的东西。有些模式，你或许已经在实际项目中应用了很多年了，只是不知道人家原来是这么称呼它的！
2、来自博客园的分析：
设计模式就是解决问题的一种方式，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样你就可以一次又一次的使用该解决方案而不做重复性的劳动。设计模式有四个基本要素：模式名称、问题、解决方案、效果。
按照模式的目的性准则，模式可以分为创建型模式、结构型模式和行为型模式。创建型模式与对象的创建有关；结构型模式处理类和对象的组合；行为型模式对类和对象怎样交互和怎样分配职责进行描述。
按照模式的范围准则，模式可以分为类模式和对象模式。类模式处理类和子类的关系，这些关系通过继承建立，是静态的，在编译时就确定下来。对象模式是处理对象之间的关系，这些关系在运行时刻是可以变化的，更具动态性。
创建型类模式将对象的创建工作部分延迟到子类。创建型对象模式则是将它延迟到另一个对象中。
结构型类模式使用继承机制来组合类。结构型对象模式则描述了对象的组装方式。
行为型类模式使用继承描述算法和控制流。行为型对象模式描述使用一组对象怎样协作完成单个对象无法完成的任务。