【转】10分钟了解设计模式（C#）

10分钟了解设计模式（C#）

最近把《大话设计模式》重温了下（看完序才知道原来作者是也是博客园园友，这本书的最早博客版本在这里）。体会最深的就是面向接口编程的重要性，如何在自己的项目中进行抽象，合理的利用各种设计模式。怎么样尽可能屏蔽switch分支、各种if else判断。具体还得自己品味，体会！整理各个模式的Demo，让不是很了解设计模式的小伙伴迅速有一个大概印象，也方便以后自己查阅。据说点赞的伙伴最近都能加薪，双11前，单身的小伙伴能顺利脱单~~

1、简单工厂模式：

namespace ConsoleApplication1
{
class 简单工厂模式
{
public void Main()
{
var oper = Factory.GetOperat("1");
oper.NumberA = 10;
oper.NumberB = 5;
oper.GetResult();
}
}
abstract  class Operat
{
public double NumberA { get; set; }
public double NumberB { get; set; }
public virtual double GetResult()
{
return 0;
}
}
class Add : Operat
{
public override double GetResult()
{
return NumberA + NumberB;
}
}
class Sub : Operat
{
public override double GetResult()
{
return this.NumberA - this.NumberB;
}
}
/// <summary>
/// 工厂类
/// </summary>
class Factory
{

public static Operat GetOperat(string flag)
{
switch (flag)
{
case "1":
return new Add();
case "2":
return new Sub();
default:
return null;
}
}
}
}

　　

2、策略模式

namespace ConsoleApplication1
{
/// <summary>
/// 什么是策略模式？
/// 策略模式就是在简单工厂模式的基础上，对factory内部同时封装具体的子类的方法实现，
/// 但是策略模式和工厂模式 还是没从根本上消除switch语句
/// </summary>
class 策略模式
{
public void Main()
{
var c = new Context_Cl("1");
c.GetResult(1,6);//这里调用相对于简单工厂模式就更加统一了
}
}
abstract class Operat_Cl
{
public double NumberA { get; set; }
public double NumberB { get; set; }

public virtual double GetResult()
{
return 0;
}
}
class Add_Cl:Operat_Cl
{
public Add_Cl(double numberA, double numberB)
{
}
public Add_Cl()
{}
public override double GetResult()
{
return NumberA+NumberB;
}
}
class Sub_Cl:Operat_Cl
{
public override double GetResult()
{
return NumberA-NumberB;
}
}
class Context_Cl
{
public Operat_Cl oper { get; set; }
public Context_Cl(string flag)
{
switch (flag)
{
case "1":
oper=new Add_Cl();
break;
case "2":
oper=new Sub_Cl();
break;
default:;
break;
}
}
public void GetResult(double numberA,double numberB)
{
oper.NumberA = numberA;
oper.NumberB = numberB;
oper.GetResult();
}
}

　　

3、装饰模式

namespace ConsoleApplication1
{
/// <summary>
/// 什么是装饰模式：动态的给一个对象添加一些额外的职责。
/// 用法：有一个类A实现了一个接口Ia，可以将一个类B实现了接口Ib，同时定义一个AddAAbout方法和Ia属性，用该方法接收一个实现了接口Ia的类，然后在类B内 调用A的方法或者属性。
/// </summary>
class 装饰模式
{
public  void Main()
{
}
}
/// <summary>
/// 抽象对象接口
/// </summary>
abstract class House
{
public abstract void Show();
}
/// <summary>
///
/// </summary>
class PingFangHouse:House
{
public override void Show()
{
Console.WriteLine("这是平房");
}
}
/// <summary>
///
/// </summary>
abstract class LouFangHouse:House
{
public override void Show()
{
Console.WriteLine("这是楼房");
}
}
class OuStyle:House
{
private House House;//1、将可能需要的一些别的类的定义在自己的类中，
public override void Show()
{
Console.WriteLine("这是欧式风格");
if(House!=null)//调用通过AddStyle方法传进来的类的方法，就对类OuStyle实现了动态添加方法职能
House.Show();
}
public void AddStyle(House house)//2、通过动态添加特定的实现了接口House的类，给OuStyle添加特定的实现了House接口的类，
{
this.House = house;
}
}
/// <summary>
/// 由于这四个类都实现了House接口，所以可以进一步的将OuStyle对象通过AddSytle方法传递给ChinaStyleHouse对象
/// </summary>
class ChinaStyleHouse:House
{
private House House;
public override void Show()
{
Console.Write("这是中式风格");
if(House!=null)
House.Show();
}
public void AddStyle(House house)
{
this.House = house;
}
}
}

　　

4、代理模式

namespace ConsoleApplication1
{
/// <summary>
/// 什么是代理模式：本来有一个类A可以直接执行自己的方法就可以实现一个功能，现在先将这个类A作为一个属性传递给一个代理类，代理类在通过自己的方法调用A对象的方法，同时可以添加一些新的功能
/// 为其他对象提供一种代理，用来控制对这个对象的访问。
/// </summary>
class _7_代理模式
{
public void Main()
{
}
}

public interface IGiveGift
{
void GiveDolls();
void GiveFlowers();
}
public class Pursuit:IGiveGift
{
public void GiveDolls()
{
Console.Write("Give Dolls");
}
public void GiveFlowers()
{
Console.Write("Give Flowers");
}
}
public class Proxy:IGiveGift
{
private IGiveGift IGift;
public Proxy(IGiveGift iGift)
{
this.IGift = iGift;
}
public void GiveDolls()
{
IGift.GiveFlowers();
Console.WriteLine("proxy can do some badthing in this lol");
}
public void GiveFlowers()
{
IGift.GiveFlowers();
Console.WriteLine("hello beauty,the flower is mine,not his");
}
}
}

　　

5、工厂方法模式

namespace ConsoleApplication1
{
/// <summary>
/// 工厂模式存在类与switch语句的高耦合，增加新的类 需要去增加case分支，违背了开放-封闭原则
/// 工厂方法模式可以解决这个问题。
/// </summary>
class 工厂方法模式
{
public void Main()
{
SubFactory sf=new SubFactory();
Operator op=sf.CreateOperator();
op.NumberA = 10;
op.NumberB = 5;
op.GetResult();
}
}
public abstract  class Operator
{
public double NumberA;
public double NumberB;
public virtual double GetResult()
{
return 0;
}
}
public class Add1:Operator
{
public override double GetResult()
{
return NumberA+NumberB;
}
}
public class Sub1:Operator
{
public override double GetResult()
{
return NumberA-NumberB;
}
}

interface IFactory
{
Operator CreateOperator();
}
class AddFactory:IFactory
{
public  Operator CreateOperator()
{
return new Add1();
}
}
class SubFactory:IFactory
{
public Operator CreateOperator()
{
return  new Sub1();
}
}
}

　　

6、原型模式

namespace ConsoleApplication1
{
/// <summary>
/// 原型模式：从一个对象创建另一个可以定制的对象，而且不需要知道任何创建的细节
/// </summary>
class 原型模式
{
public void Main()
{
var s = new ConcretePrototype1("id");
((ProtoType) s).Idd();//访问父类被隐藏的Idd方法
s.Idd();//默认访问新类的Idd方法
var sClone=s.Clone();
}
}
#region 例子1
abstract class ProtoType
{
private string Id;
protected ProtoType(string id)
{
this.Id = id;
}
public string Idd()
{
return Id;
}
public abstract ProtoType Clone();
}

class ConcretePrototype1:ProtoType
{
public ConcretePrototype1(string id) : base(id)
{
}
public override ProtoType Clone()
{
return (ProtoType)this.MemberwiseClone();//浅表复制，值类型复制具体的值，引用类型复制引用！
}
public new string Idd()
{
return "ConcretePrototype1";
}
}
#endregion
#region 例子2  深复制和浅复制
class WorkExperice:ICloneable
{
public string Name { get; set; }
public DateTime StarTime { get; set; }
public DateTime EndTime { get; set; }
public object Clone()
{
return new WorkExperice(){Name = this.Name,StarTime = StarTime,EndTime = EndTime};//深度复制
//return this.MemberwiseClone();如果属性只有值类型，用这个方法就可以实现浅表复制
}
}

#endregion
/// <summary>
/// 由于Clone非常常见，所以.Net已经提供了这个Clone接口
/// </summary>
class MyClass:ICloneable
{
public object Clone()
{
return this.MemberwiseClone();//浅复制
}
}
}

　　

7、模板模式

namespace ConsoleApplication1
{
/// <summary>
/// 模板模式：通过定义一个抽象类，抽象类里的一个方法A内部调用了另一个虚方法B，就可以通过继承这个抽象类，然后重写这个虚方法，达到控制方法A的目的。最大程度上减少了类B的代码重复量
/// 定义一个一个类的基本骨架，然后通过虚函数将部分差异性方法或者属性在子类中重新定义，使得子类可以不改变父类的基本骨架即可重新定义从父类继承过来的一些方法。
/// 也就是说模板方法通过将不变的行为搬移到父类中，去除了子类中的重复代码，代码复用程度较高。
/// </summary>
class _10_模板方法模式
{
public void Main()
{
var t = new TestPaper1();
t.QuestionOneAnswer("26");
t.QuestionOne();
}
}
abstract class TestPaper
{
protected string Age;
public void QuestionOne()
{
Console.WriteLine("how old are you!"+QuestionOneAnswer(Age));
}
public virtual string QuestionOneAnswer(string age)
{
return "";
}
}

class TestPaper1:TestPaper
{
public override string QuestionOneAnswer(string age)
{
this.Age = age;
return age;
}
}
}

　　

8、外观模式

namespace ConsoleApplication1
{
/// <summary>
/// 通过一个类对多个类进行集成，用户只需要知道一个方法，就可以调用多个被继承类的功能
/// 对于老系统，如果要进行扩展修改可以采用这种模式
/// </summary>
class _12_外观模式
{

}

class Facade
{
public Writer1 Writer1 { get; set; }
public Writer2 Writer2 { get; set; }
public void Write()
{
Writer1.Write();
Writer2.Write();
}
}

interface IWriter
{
void Write();
}
class Writer1:IWriter
{
public void Write()
{
Console.WriteLine("hello writer1");
}
}
class Writer2:IWriter
{
public void Write()
{
Console.WriteLine("hello writer2");
}
}
}

　　

9、建造者模式

namespace ConsoleApplication1
{
/// <summary>
/// 建造者模式：用于创建一些复杂的对象，这些对象内部构建间的建造顺序较稳定，但是内部的构建过程是复杂变化的。
/// 建造者模式的好处就是使得建造代码和具体的表示代码分离，由于建造者隐藏了该产品的具体实现，如果需要改变一个产品的内部表示，只需要重新再定义一个建造者就行了，或者在同一个建造者内部重新写一个方法
/// 建造者Builder更像是一种对现有方法的有顺序整合
/// </summary>
class _13_建造者模式
{
}
public abstract class Person
{
public abstract void BuildHead();
public abstract void BuildBody();
public abstract void BuildLag();
}
public class TinPerson:Person
{
public override void BuildHead()
{
Console.WriteLine("TinHead");
}
public override void BuildBody()
{
Console.WriteLine("TinBody");
}
public override void BuildLag()
{
Console.WriteLine("TinLag");
}
}
public class FatPerson:Person
{
public override void BuildHead()
{
throw new NotImplementedException();
}
public override void BuildBody()
{
throw new NotImplementedException();
}
public override void BuildLag()
{
throw new NotImplementedException();
}
}
public class Builder
{
public  Person Person {get; private set; }
public Builder(Person person)
{
this.Person = person;
}
public void Build(Person person)
{
person.BuildHead();
Person.BuildBody();
person.BuildLag();
}

}
}

　　

10、观察者模式

namespace ConsoleApplication1
{
/// <summary>
/// 观察者模式：定义了一种一对多的关系，让多个观察者对象同时监听同一个主题对象，当这个主题对象状态发生改变的时候，会通知所有的观察者对象，使所有的观察者对象执行特定操作
/// 参数传递尽量依赖于接口和抽象类
/// </summary>
class _14_观察者模式
{
public void Main()
{
ISubject boss=new Boss();
Observer observer=new Observer1("sss",boss);
boss.Attach(observer);
boss.Notify();
}
}
abstract class Observer
{
protected string Name;
protected ISubject Subject;
public abstract void Update();
}

class Observer1:Observer
{
public Observer1(string name,ISubject subject)//同样 参数也是接口传递，不依赖于具体的类
{
this.Name = name;
this.Subject = subject;
}
public override void Update()
{
Console.WriteLine(Name+Subject.Name+"在看股票呢");
}
}
interface ISubject
{
string Name { get; set; }
List<Observer> Observers { get; set; }
void Attach(Observer observer);//添加
void Detach(Observer observer);//剔除
void Notify();//通知
}
class Boss:ISubject
{
public string Name { get; set; }
public List<Observer> Observers { get; set; }//这里需要添加继承了Observe抽象类的对象，如果有的类没有继承Observe类，那么建造者模式就失效了！这时可以用委托来实现
public Boss()
{
this.Observers=new List<Observer>();
}
public void Attach(Observer observer)//Attach函数的参数 都是接口传递，而不是具体的类，降低类间耦合
{
Observers.Add(observer);
}
public void Detach(Observer observer)
{
Observers.Remove(observer);
}
public void Notify()
{
foreach (var observer in Observers)
{
observer.Update();
}
}
}

}

　　

11、抽象工厂方法

namespace ConsoleApplication1
{

class _15_抽象工厂方法
{
public void Main()
{
IFactoryDatabase factory=new SqlServerFac();
IDepartMent sqlServer=factory.GetInstance();
sqlServer.Insert("helloworld!");
}
}
interface IDepartMent
{
void Insert(string sql);//在数据库中插入一条记录
}
class SqlServer:IDepartMent
{
public void Insert(string sql)
{
Console.WriteLine("sqlServer执行sql插入语句！");
}
}

class Access:IDepartMent
{
public void Insert(string sql)
{
Console.WriteLine("Access执行sql插入语句！");
}
}

interface IFactoryDatabase
{
IDepartMent GetInstance();
}

class SqlServerFac:IFactoryDatabase
{
public IDepartMent GetInstance()
{
return new SqlServer();
}
}

class AccessFac:IFactoryDatabase
{
public IDepartMent GetInstance()
{
return new Access();
}
}
}

　　

12、状态模式

namespace ConsoleApplication1
{
/// <summary>
/// 状态模式：当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类一样
/// </summary>
class _16_状态模式
{

}
}

　　

13、适配器模式

namespace ConsoleApplication1
{
/// <summary>
/// 适配器模式：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作
/// 需要的东西在面前，但是却不能用，我们可以想办法适配它
/// 系统的数据和行为都正确，但是接口不符时，可以考虑适配器模式。目的是使控制范围外的一个原有对象与某个接口匹配。可以起到复用一些现存类的作用。
/// 有点亡羊补牢的意思~~
/// 应用场景：一般用在后期的系统维护阶段，接口改变的情况下使用！但是当我们设计一个系统，调用第三方组件时，第三方的组件往往和我们需要的接口是不一致的，此时就可以用适配器模式
/// </summary>
class _17_适配器模式
{
}
class Target
{
public virtual void Request()
{
Console.WriteLine("客户期待的接口");
}
}
class Adaptee
{
public void SpecificQuest()
{
Console.WriteLine("需要适配的接口，即现在已经存在的一些功能");
}
}
class Adapter:Target
{
//接口达到了Target的要求，同时调用了现有的Adaptee类功能
public override void Request()
{
new Adaptee().SpecificQuest();
}
}
#region 示例2

/// <summary>
/// 球员类
/// </summary>
abstract class Player
{
protected string Name;

protected Player(string name)
{
this.Name = name;
}
public abstract void Attratk();
public abstract void Defend();
}
/// <summary>
/// 前锋类
/// </summary>
class ForWard:Player
{
public ForWard(string name) : base(name)
{
this.Name = name;
}
public override void Attratk()
{
Console.WriteLine("ForWard Attrack");
}
public override void Defend()
{
Console.WriteLine("ForWard Defend!");
}
}
/// <summary>
/// 中国球员
/// </summary>
class ChinaPlayer
{
public string Name { get; set; }
public ChinaPlayer(string name)
{
Name = name;
}
public void ChineseStyleAttratk()
{
Console.WriteLine("中国球员式进攻！");
}
public void ChineseStyleDefend()
{
Console.WriteLine("中国球员式防守");
}
}
/// <summary>
/// 同化中国球员类ChinaPlayer，也就是复用ChinaPlayer
/// </summary>
class AssimilationChinesePlayer:Player
{
private ChinaPlayer Player;
public AssimilationChinesePlayer(string name) : base(name)
{
this.Name = name;
this.Player=new ChinaPlayer(name);
}
public override void Attratk()//接口保持了一致，同时内部调用了现有的ChinaPlayer
{
Player.ChineseStyleAttratk();
}
public override void Defend()
{
Player.ChineseStyleDefend();
}
}
#endregion
}

　　

14、备忘录模式

namespace ConsoleApplication1
{
/// <summary>
/// 备忘录模式：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外进行保存，以后可以将该对象恢复到原先保存的状态了。
///
/// </summary>
class _18_备忘录模式
{
public void Main()
{
var role = new MainRole(){RoleBlood = 10,RoleMagic = 10,RoleName = "name"};//创建一个角色
var mementoManager = new MementoManager();//创建一个管理备忘录的类
var roleMemento=role.SetMemento();//保存role角色的部分信息
mementoManager.Dictionary.Add(role.RoleName,roleMemento);
}
}
/// <summary>
/// 游戏角色抽象类
/// </summary>
abstract class GameRole
{
protected string Name;
protected int Magic;
protected int Blood;
public abstract void Display();//展示信息接口
public abstract Memento SetMemento();//设置备忘录
public abstract void ReCover(Memento memento);//根据备忘录Memento恢复角色信息

}
/// <summary>
/// 备忘录类
/// </summary>
class Memento
{
public string Name { get; set; }
public int Magic { get; set; }
public int Blood { get; set; }
}
class MainRole:GameRole
{
public string RoleName
{
get { return Name; }
set { Name = value; }
}
public int RoleMagic
{
get { return Magic; }
set { Magic = value; }
}
public int RoleBlood
{
get { return Blood; }
set { Blood = value; }
}
public override void Display()
{
Console.WriteLine(Name+Magic+Blood);
}
public override Memento SetMemento()
{
return  new Memento(){Blood = this.Blood,Magic = this.Magic,Name = this.Name};
}
public override void ReCover(Memento memento)
{
this.RoleBlood = memento.Blood;
this.RoleMagic = memento.Magic;
this.RoleName = memento.Name;
}
}

class MementoManager
{
/// <summary>
/// 存储一个dictionary key用name表示
/// </summary>
public Dictionary<string,Memento> Dictionary=new Dictionary<string, Memento>();
}
}

　　

15、组合模式

namespace ConsoleApplication1
{
/// <summary>
/// 组合模式：可以让客户一致的使用组合结构和单个对象
/// </summary>
class _19_组合模式
{
public void Main()
{
Company c=new ConcreteCompany("一个非叶子部门");
Company d=new HrCompany("人事部门");
c.Add(d);
c.LineOfDuty();
c.Display();
}
}
abstract class Company
{
protected string Name;
protected Company(string name)
{
this.Name = name;
}
public abstract void Add(Company a);//添加对象
public abstract void Remove(Company a);//删除对象
public abstract void LineOfDuty();//履行职能(整体)
public abstract void Display();//展示
}
/// <summary>
/// 一个具体的Company
/// </summary>
class ConcreteCompany:Company
{
private List<Company> children=new List<Company>();
public ConcreteCompany(string name):base(name)
{}
public override void Add(Company a)
{
children.Add(a);
}
public override void Remove(Company a)
{
children.Remove(a);
}
public override void LineOfDuty()
{
foreach (var company in children)
{
company.Display();
}
}
public override void Display()
{
Console.WriteLine("This is ConcreteCompany display!");
}
}

class HrCompany:Company
{
public HrCompany(string name):base(name)
{
this.Name = name;
}
public override void Add(Company a)
{
}
public override void Remove(Company a)
{
}
public override void LineOfDuty()
{
}
public override void Display()
{
Console.WriteLine("HR部门的职责是招人！");
}
}
}

　　

16、单例模式

namespace ConsoleApplication1
{
/// <summary>
/// 保证类的实例只有一个，并且提供一个全局访问方法
/// </summary>
class _21_单例模式
{
}
#region 单线程下可行操作
class Singleton
{
private static Singleton instance;
private Singleton()//构造函数私有化，防止外界创建新对象
{ }
public static Singleton GetInstance()//全局访问instance方法
{
return instance ?? (instance = new Singleton());//多线程下可能new多次
}
}
#endregion
#region 多线程可行操作 （lock锁）
class Singleton1
{
private static Singleton1 instance;
private static readonly  object myLock=new object();
private Singleton1()
{}
public static Singleton1 GetInstance()
{
lock (myLock)
{
return instance ?? (instance = new Singleton1());
}
}
}
#endregion
#region 多线程可行操作（双重lock锁）

class Singleton2
{
private static Singleton2 instance;
private static readonly object myLock=new object();
private Singleton2()
{}
public static Singleton2 GetInstance()
{
if (instance == null)
{
lock (myLock)
{
if(instance==null)
instance=new Singleton2();
}
}
return instance;
}
}
#endregion
#region 静态初始化
public sealed class Singleton3//密封类，防止派生该类
{
private static readonly Singleton3 instance=new Singleton3();
private Singleton3(){}
public static Singleton3 GetInstance()
{
return instance;
}
}
#endregion
}

　　

17、命令模式

namespace ConsoleApplication1
{
/// <summary>
/// 一个类有一些具体的功能（烤肉者）,将这些功能抽象出一个命令类，在通过每一个继承该命令类的具体类 调用  一个具体的功能，然后在定义一个中间类（服务员），接收客户端的命令请求，具体通知各个功能的所有者实现这些功能
/// </summary>
class _23_命令模式
{
public void Main()
{
Barbecuer boy=new Barbecuer();
Command com1=new BakeChikenCommand(boy);
Command com2=new BakeChikenCommand(boy);
Waiter girl=new Waiter();
girl.SetOrder(com1);
girl.SetOrder(com2);
girl.Execute();
}

}
/// <summary>
/// 抽象命令类
/// </summary>
public abstract class Command
{
protected Barbecuer receiver;
protected Command(Barbecuer barbecuer)
{
this.receiver = barbecuer;
}
public abstract void ExecuteCommand();
}

class BakeMuttonCommand:Command
{
public BakeMuttonCommand(Barbecuer barbecure) : base(barbecure)
{
this.receiver = barbecure;
}
public override void ExecuteCommand()
{
receiver.BakeMutton();
}
}

class BakeChikenCommand:Command
{
public BakeChikenCommand(Barbecuer barbecure) : base(barbecure)
{
this.receiver = barbecure;
}
public override void ExecuteCommand()
{
receiver.BakeChicken();
}
}
/// <summary>
/// 服务员类  可以添加更多的功能函数
/// </summary>
public class Waiter
{
private IList<Command> commands=new List<Command>();
public void SetOrder(Command command)
{
this.commands.Add(command);
}
public void Execute()
{
foreach (var  command in commands)
{
command.ExecuteCommand();
}
}
}
/// <summary>
/// 烤肉者
/// </summary>
public class Barbecuer
{
public void BakeMutton()
{
Console.WriteLine("烤肉");
}
public void BakeChicken()
{
Console.WriteLine("烤鸡翅");
}
}
}

　　

18、职责链模式

namespace ConsoleApplication1
{
/// <summary>
/// 使多个对象都有机会处理请求，将所有对象连成一个链，并且沿着这条链传递请求，直到有一个对象处理它为止
/// </summary>
class _24_职责链模式
{
public void Main()
{
Manager m3=new Manager3();
Manager m2 =new Manager2(m3);
Manager m1=new Manager1(m2);
m1.Handle("level2");
}
}

abstract class Manager
{
protected Manager MyBoss;
public abstract void Handle(string oneThing);
}
/// <summary>
/// 级别为1的Manager
/// </summary>
class Manager1:Manager
{
public Manager1(Manager boss)
{
MyBoss = boss;
}
//public void SetBoss(Manager boss)//代替构造函数初始化在 客户端调用的时候更加灵活，可以随意的更改传递顺序和请求处理节点
//{
//    this.MyBoss = boss;
//}
public override void Handle(string oneThing)
{
if (oneThing.Equals("level1"))
{
Console.WriteLine("I can handle the "+oneThing);
return;
}
Console.WriteLine("I can not handle the"+oneThing);
MyBoss.Handle(oneThing);
}
}

class Manager2:Manager
{
public Manager2(Manager boss)
{
MyBoss = boss;
}
public override void  Handle(string oneThing)
{
if (oneThing.Equals("level2"))
{
Console.WriteLine("I can handle"+oneThing);
return;
}
Console.WriteLine("I can not Handle the"+oneThing);
MyBoss.Handle(oneThing);
}
}

class Manager3:Manager
{
public Manager3()
{
MyBoss = null;
}
public override void Handle(string oneThing)
{
if (oneThing.Equals("level3"))
{
Console.WriteLine("I can handle the "+oneThing+"Because i am CEO");
return;
}
}
}
}

　　

19、中介者模式

namespace ConsoleApplication1
{
/// <summary>
/// 用一个中介者对象来封装一系列的对象交互，中介者使各对象不需要显示的相互引用，降低耦合，从而可以独立的改变他们之间的交互
/// </summary>
class _25_中介者模式
{

}
}

　　

20、享元模式

namespace ConsoleApplication1
{
/// <summary>
/// 通过共享实例对象，减少对象的创建，降低内存的损耗。
/// </summary>
class _26_享元模式
{
public void  Main()
{
FlyWeight a=new FlyWeightA();
FlyWeight b=new FlyWeightB();
FlyWeightFactory fac=new FlyWeightFactory();
fac.AddFlyWeight("a",a);
fac.AddFlyWeight("b",b);
var flyWeightA=  fac.Get("a") as FlyWeightA;//通过fac工厂的get方法在其他位置调用get方法 也会得到同一个对象，减少了创建对象的开销
flyWeightA.Operator(new Data());//通过客户端传递外部数据进行处理
}
}
public class Data
{
public string str;
}
abstract class FlyWeight
{
public abstract void Operator(Data data);
}
class FlyWeightA:FlyWeight
{
public override void Operator(Data data)
{
//使用data里的数据
Console.WriteLine("FlyWeightA");
}
}
class FlyWeightB:FlyWeight
{

public override void Operator(Data data)
{
//使用data里的数据
Console.WriteLine("FlyWeightB");
}
}

class FlyWeightFactory
{
private Dictionary<string,FlyWeight> dic=new Dictionary<string, FlyWeight>();
public void AddFlyWeight(string key,FlyWeight flyWeight)
{
if(!dic.Keys.Contains(key))
dic.Add(key,flyWeight);
}
public FlyWeight Get(string key)
{
return dic.Keys.Contains(key) ? dic[key] : null;
}
}
}

　　

21、解释器模式

namespace ConsoleApplication1
{
/// <summary>
///
/// </summary>
internal class _27_解释器模式
{
}

/// <summary>
/// 抽象解释器接口
/// </summary>
internal abstract class Expression
{
public abstract void Interpret(InterPretData data);
}

internal class NonExpression : Expression
{
public override void Interpret(InterPretData data)
{
Console.WriteLine("Non解释处理data数据");
}
}

internal class TerExpression : Expression
{
public override void Interpret(InterPretData data)
{
Console.WriteLine("Ter解释处理data数据");
}
}
}

　　

22、访问者模式

namespace ConsoleApplication1
{
/// <summary>
/// 一个作用于某对象结构中各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作
/// 利用双分派技术 实现处理与数据机构的分离
/// </summary>
class _28_访问者模式
{
public void Main()
{
//特点：Action和Human抽象类中的函数互为各自的参数，但是要保证Action中的方法是稳定的。是两个方法就是2个方法，万一增加了双性恋者，就不适用了
//如果要增加一种"结婚"状态，只要重写一个"结婚"类继承自Action就可以
}
}
/// <summary>
/// 状态类（访问者）（个人感觉将Action看成一种数据更易理解）  增加访问者很方便
/// </summary>
abstract class Action
{
public abstract void GetManConclusion(Human human);
public abstract void GetWomanConclusion(Human human);
}
abstract class Human
{
public abstract void Accept(Action action);
}
class Success:Action
{
public override void GetManConclusion(Human human)
{
Console.WriteLine("Man Success");
}
public override void GetWomanConclusion(Human human)
{
Console.WriteLine("Woman Sucess");
}
}
class Fail:Action
{
public override void GetManConclusion(Human human)
{
Console.WriteLine("Man Faile");
}
public override void GetWomanConclusion(Human human)
{
Console.WriteLine("Woman Fail");
}
}
class Man:Human
{
public override void Accept(Action action)
{
action.GetManConclusion(this);
}
}

class Woman:Human
{
public override void Accept(Action action)
{
action.GetWomanConclusion(this);
}
}
}

　　

原文地址：/content/4597756.html