你必须知道的10种设计模式！
创建型设计模式：单例、原型、工厂方法、抽象工厂、建造者等5种。
结构型设计模式：代理、适配器、桥接、装饰、享元、组合、外观等7种。
行为型设计模式：模板方法、策略命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器、命令等11种。
01.单例模式（创建型）
类只能有一个实例，提供一个全局的访问点。
public sealed class SingletonFirst{private SingletonFirst() { }private static SingletonFirst _Instance = null;public static SingletonFirst Instance{get{if (_Instance == null){_Instance = new SingletonFirst();Console.WriteLine(nameof(SingletonFirst) + "实例化了");}return _Instance;}}}
02.简单工厂模式（创建型）
一个工厂类根据传入的参量决定创建出哪一种产品类的实例。
public enum FoodType {Patato, TomatoWithEggs, Chicken}public abstract class Food {public abstract void Make();}public class Patato : Food {public override void Make(){Console.WriteLine("土豆做好了！");}}public class TomatoWithEggs:Food {public override void Make(){Console.WriteLine("西红柿炒蛋做好了！");}}public class Chicken : Food {public override void Make(){Console.WriteLine("鸡肉做好了！");}}
public class SimpleFactory{public static Food MakeFood(FoodType foodType){Food food = null;if (foodType == FoodType.Patato){food = new Patato();}else if (foodType == FoodType.TomatoWithEggs){food = new TomatoWithEggs();}else if (foodType == FoodType.Chicken){food = new Chicken();}return food;}}
/// <summary>/// 模拟使用简单工厂的场景介绍：/// 比如吃饭，想要吃什么菜都得自己去炒，我自己得全方位照顾到，这是单纯的需要什么去做什么/// 使用简单工厂的思路就是：///我要吃饭，我去饭馆吃，我想要吃什么我点菜，饭馆给我做就好了，至于怎么做是饭馆的事（此时饭馆就相当于简单工厂）/// 相当于把做饭的细节从我身上推迟给饭馆/// </summary>static void Main(string[] args){var food1 = SimpleFactory.MakeFood(FoodType.Patato);food1.Make();var food2 = SimpleFactory.MakeFood(FoodType.Chicken);food2.Make();var food3 = SimpleFactory.MakeFood(FoodType.TomatoWithEggs);}
02.工厂方法模式（创建型）
public abstract class FactoryCreator {public abstract Food CreateFactory();}public class ChickenFactoryCreator : FactoryCreator {public override Food CreateFactory(){return new Chicken();}}public class PatatoFactoryCreator : FactoryCreator {public override Food CreateFactory(){return new Patato();}}public class TomatoWithEggsFactoryCreator : FactoryCreator {public override Food CreateFactory(){return new TomatoWithEggs();}}
/// <summary>/// 工厂方法模式：/// 在简单工厂模式中，我们需要吃什么菜，由最开始的自己做，到后面的将如何做推迟到简单工厂中/// 也就是饭馆做什么菜，还是需要听我们的，我们说做啥菜，饭馆给我们做啥菜，如果要加新菜，需要饭馆去加，有点麻烦/// 在工厂方法模式中，我们点的菜由哪个饭馆做，可以由我们自己定义，/// 比如A饭馆有土豆和西红柿炒蛋，我要吃西红柿炒蛋或者土豆就让A做/// 但是我要吃鸡肉，只有C饭馆有，此时我就可以让C去给我做/// 这就是所谓的具体哪个饭馆做，由我来定义，/// 每个饭馆都是一个工厂，具体需要哪个工厂，由我来定义/// </summary>static void Main(string[] args) {//初始化工厂方法var patatoFactory = new PatatoFactoryCreator();var tomatoWithEggsFactory = new TomatoWithEggsFactoryCreator();var chickenFactory = new ChickenFactoryCreator();//通过工厂方法去创建工厂var food1 = patatoFactory.CreateFactory();food1.Make();var food2 = tomatoWithEggsFactory.CreateFactory();food2.Make();var food3 = chickenFactory.CreateFactory();food3.Make();}
03.抽象工厂模式（创建型）
创建相关或依赖对象的家族，而无需明确指定具体类。
public abstract class Xiaolongkan{public abstract void MakeHotpot();}public class ShanghaiXiaolongkan : Xiaolongkan {public override void MakeHotpot(){Console.WriteLine("上海的小龙坎，很甜，不好吃");}}public class ChongqingXiaolongkan : Xiaolongkan {public override void MakeHotpot(){Console.WriteLine("重庆的小龙坎，很辣，好吃刺激");}}
public abstract class Yuanlaosi{public abstract void MakeHotpot();}public class ShanghaiYuanlaosi : Yuanlaosi{public override void MakeHotpot(){Console.WriteLine("上海的袁老四，甜的，不好吃");}}public class ChongqingYuanlaosi : Yuanlaosi{public override void MakeHotpot(){Console.WriteLine("重庆的袁老四，很辣，好吃刺激");}}
public abstract class AbstractFactory {public abstract Xiaolongkan CreateXiaolongkan();public abstract Yuanlaosi CreateYuanlaosi();}public class ShanghaiFactory : AbstractFactory {public override Xiaolongkan CreateXiaolongkan(){return new ShanghaiXiaolongkan();}public override Yuanlaosi CreateYuanlaosi(){return new ShanghaiYuanlaosi();}}public class ChongqingFactory : AbstractFactory {public override Xiaolongkan CreateXiaolongkan(){return new ChongqingXiaolongkan();}public override Yuanlaosi CreateYuanlaosi(){return new ChongqingYuanlaosi();}}
/// <summary>/// 抽象工厂模式：/// 学习了简单工厂和工厂方法之后，再来看抽象工厂，就非常简单，基本上无需写代码/// 工厂方法是为了创建一个单一对象，而抽象工厂就是为了创建一系列的对象/// 举例子我就全国不同城市的火锅吧，因为不同城市的口味是不同的/// </summary>/// <param name="args"></param>static void Main(string[] args){//上海工厂AbstractFactory shanghaiFactory = new ShanghaiFactory();//上海小龙坎Xiaolongkan shanghaiXiaolongkan = shanghaiFactory.CreateXiaolongkan();shanghaiXiaolongkan.MakeHotpot();//上海袁老四Yuanlaosi shanghaiYuanlaosi = shanghaiFactory.CreateYuanlaosi();shanghaiYuanlaosi.MakeHotpot();//重庆工厂AbstractFactory chongqingFactory = new ChongqingFactory();//重庆小龙坎Xiaolongkan chongqingXiaolongkan = chongqingFactory.CreateXiaolongkan();chongqingXiaolongkan.MakeHotpot();//重庆袁老四Yuanlaosi chongqingYuanlaosi = chongqingFactory.CreateYuanlaosi();chongqingYuanlaosi.MakeHotpot();Console.WriteLine("End");Console.ReadKey();}
04.建造者模式（创建型）
封装一个复杂对象的创建过程，并可以按步骤构造。
public abstract class Programmer{public abstract void Develop();public abstract void Test();public abstract void Commit();}public class NetProgrammer : Programmer{public override void Develop(){Console.WriteLine("开发.Net项目");}public override void Test(){Console.WriteLine("开发完毕，测试.Net项目");}public override void Commit(){Console.WriteLine("开发测试完毕，交付.Net项目");}}public class JavaProgrammer : Programmer {public override void Develop() {Console.WriteLine("开发Java项目");}public override void Test() {Console.WriteLine("开发完毕，测试Java项目");}public override void Commit() {Console.WriteLine("开发测试完毕，交付Java项目");}}
public class Boss{public void MakeProject(Programmer programmer){programmer.Develop();programmer.Test();programmer.Commit();}}
/// <summary>/// 建造者模式：/// 建造者模式分为：1.指挥者；2.建造者/// 指挥者直接跟客户端打交道，拿到客户端的请求后，再交给指定的建造者去响应这个请求/// 举例为：/// 公司老板跟客户打交道，客户需要java项目，.net项目，Python项目，php项目等等.../// 老板从客户那里接到需求后，再交给公司指定语言开发者去开发，然后交付/// </summary>/// <param name="args"></param>static void Main(string[] args){//初始化老板：可以理解为成立公司（指挥者）Boss boss = new Boss();//初始化java开发：可以理解为公司招聘了一个java开发（建造者）Programmer javaProgrammer = new JavaProgrammer();//初始化.Net开发：可以理解为公司招聘了一个.Net开发（建造者）Programmer netProgrammer = new NetProgrammer();//这个时候来了一个java项目，老板让java开发去做boss.MakeProject(javaProgrammer);//这个时候又来了一个.Net项目，老板让.Net开发去做boss.MakeProject(netProgrammer);}
二、结构型设计模式：
05.适配器模式（结构型模式）
将一个类的方法接口转换成客户希望的另一个接口。
//已经存在的方法：我会开车public class Car{public void Drive(){Console.WriteLine("开汽车！");}}
类适配：
//开飞机（新方法）我不会，所以我需要将这个适配到我会的（已有的方法）public interface IAirplane{void Fly();}public class AirplaneClassAdapter : Car, IAirplane{public void Fly(){this.Drive();}}
对象适配：
public class Airplane{public virtual void Fly(){ }}public class AirplaneModelAdapter : Airplane{//此时的readonly与java的final等效private readonly Car _Car = new Car();public override void Fly() {_Car.Drive();}}
/// <summary>/// 适配器模式：/// 将已实现的方法适配到未实现的方法上/// 分为：1.类适配器；2.对象适配/// 例如：我会开汽车，但是我不会开飞机，但是现在客户要求会开飞机的，我可以使用适配器模式将开汽车适配到开飞机上（不恰当的比喻）/// </summary>/// <param name="args"></param>static void Main(string[] args) {TestAdapterClass();TestAdapterModel();}private static void TestAdapterClass() {//类适配器：//1.我会开车，不会开飞机，但是现在客户要求开飞机//2.定义开飞机的接口，客户要我开，也就是我必须要实现开飞机的接口//3.继承开车的类，同时实现开飞机的接口//4.在实现开飞机的方法中调用开车类中的开车的方法（将没有的转换到有的）var airplaneAdapter = new AirplaneClassAdapter();airplaneAdapter.Fly();}private static void TestAdapterModel() {//对象适配器：//1.我会开车，不会开飞机，但是现在客户要求开飞机//2.定义飞机对象，里面有一个开飞机的方法，不做任何实现（因为我不会开飞机），注意：一定要是虚方法（可以被子类重写）//3.定义飞机适配器对象，继承飞机类//4.在飞机适配器对象中重写父类的开飞机的方法：在适配器对象内部定义一个开车对象，然后开飞机方法调用开车对象的开车方法（将没有的转换到有的）var airplaneAdapter = new AirplaneModelAdapter();airplaneAdapter.Fly();}
06.装饰者模式（结构型模式）
动态的给对象添加新的功能。
/// <summary>/// 人类/// </summary>public abstract class Person{public abstract void Develop();}/// <summary>/// 这个是我本人，我也是人类，所以要继承人类/// </summary>public class Lingbug : Person{public override void Develop(){//原来我只会.Net开发Console.WriteLine("我会开发.Net程序！");}}
/// <summary>/// 装饰类：也就是装饰者/// </summary>public class Decorator : Person{private Person _Person;//需要传入参数：我需要装饰谁public Decorator(Person person){this._Person = person;}public override void Develop(){_Person.Develop();}}/// <summary>/// 具体的装饰者：将.Net core装饰到我的身上/// </summary>public class NetCoreDecorator : Decorator{public NetCoreDecorator(Person person) : base(person){}public override void Develop(){base.Develop();Console.WriteLine("我会开发.Net core程序！");//装饰}}/// <summary>/// 具体的装饰者：将Java装饰到我的身上/// </summary>public class JavaDecorator : Decorator{public JavaDecorator(Person person) : base(person){}public override void Develop() {base.Develop();Console.WriteLine("我会开发Java程序！");//装饰}}
/// <summary>/// 装饰者模式：/// 1.如果想要为一类对象添加新的功能，有两种方法：/// ①开发新的类去继承原来的来，来扩展新的方法，缺点：会导致子类繁多/// ②使用装饰者模式去装饰员原来的对象/// 此文中的例子：/// 我原来只会.Net开发，现在我学会了.Net core的开发，也学会了java开发，就需要将新学会的两个技能添加到我的身上/// </summary>/// <param name="args"></param>static void Main(string[] args){//其实可以不用实例化新的对象，一直修改最初始的那个人也是可以的（因为都是Person类），也是最符合业务逻辑的Person lingbugNew = new Lingbug();lingbugNew.Develop();Console.WriteLine("--------------------------------------------");lingbugNew = new NetCoreDecorator(lingbugNew);lingbugNew.Develop();Console.WriteLine("--------------------------------------------");lingbugNew = new JavaDecorator(lingbugNew);lingbugNew.Develop();}
07.代理模式（结构型模式）
为其它对象提供一个代理以便控制这个对象的访问。
/// <summary>/// 代理模式必须代理类和真实类实现同样的接口/// </summary>public abstract class Person{public abstract void Buy();}/// <summary>/// 真实想要操作的人（客户端）/// </summary>public class NeedBuyPerson : Person{public override void Buy(){Console.WriteLine("帮我买一个iPhone 11 pro max");}}/// <summary>/// 代理对象/// </summary>public class ProxyPerson : Person{public override void Buy(){Console.WriteLine("大家好，我是代购");Console.WriteLine("代购买之前的操作：我需要将这次需要帮忙买的清单列一下...");Person needBuyPerson = new NeedBuyPerson();needBuyPerson.Buy();Console.WriteLine("代购买之后的操作：我需要将买的东西核对检查一下...");}}
/// <summary>/// 代理模式：/// 我们想要访问某个资源，但是我们由于种种原因访问不到，需要找一个中间人来帮忙我们访问，这就是代理模式的精髓所在/// 代理需要注意一点：我们只能真实对象去扩展，比如AOP操作，但是无法去覆盖点真实对象的实现（无法改变真实购买者的意图）////// 日常生活的代理模式的例子：黄牛，代购，各种外卖配送员，产品经销商都是代理...代理无处不在////// 代理模式按照使用目的可以分为以下几种：/// 1.远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象，这个不同的地址空间可以是本电脑中，也可以在另一台电脑中。最典型的例子就是：客户端调用后端系统的webservice，wcf，webapi等等/// 2.虚拟（Virtual）代理：根据需要创建一个资源消耗较大的对象，使得对象只在需要时才会被真正创建。/// 3.Copy-on-Write代理：虚拟代理的一种，把复制（或者叫克隆）拖延到只有在客户端需要时，才真正采取行动。/// 4.保护（Protect or Access）代理：控制一个对象的访问，可以给不同的用户提供不同级别的使用权限。/// 5.防火墙（Firewall）代理：保护目标不让恶意用户接近。/// 6.智能引用（Smart Reference）代理：当一个对象被引用时，提供一些额外的操作，比如将对此对象调用的次数记录下来等。/// 7.Cache代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以这些结果。////// 上面的4,5,6,7其实有些小伙伴就看得出来，特别是第6条，暗示已经很明显了，这不就是AOP嘛，对的，没错/// 在上面所有种类的代理模式中，虚拟代理、远程代理、智能引用代理和保护代理较为常见的代理模式。////// 此文中的例子：/// 我就举个代购的例子吧，太多了，随时随地都是在代理/// </summary>/// <param name="args"></param>static void Main(string[] args){//通过代理去购买Person proxy = new ProxyPerson();proxy.Buy();Console.WriteLine("End");Console.ReadKey();}
三、行为型设计模式：
行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。
08.模板方法模式（行为型模式）
定义一个算法结构，而将一些步骤延迟到子类实现。
/// <summary>/// 第一种实现：抽象类/// </summary>public abstract class MakeFood{public void Make(){PourOil();WaitOilHot();PourFood();StartPot();}public void PourOil(){Console.WriteLine("炒菜第一步：倒油");}public void WaitOilHot(){Console.WriteLine("炒菜第二步：等油热");}/// <summary>/// 具体往锅里倒哪个菜，交给子类，子类必须实现/// </summary>public abstract void PourFood();public void StartPot(){Console.WriteLine("最后一步：等菜热了，起锅");}}
/// <summary>/// 炒土豆/// </summary>public class MakePatato : MakeFood{public override void PourFood() {Console.WriteLine("将土豆倒入锅中");}}public class MakeChicken : MakeFood{public override void PourFood() {Console.WriteLine("将鸡肉倒入锅中");}}
private static void TestAbstract(){MakeFood makePatato = new MakePatato();makePatato.Make();MakeFood makeChicken = new MakeChicken();makeChicken.Make();}
/// <summary>/// 模板方法模式：/// 日常生活中我们有很多东西都有规定好的模板，我们只需要在模板的基础上修改下就可以变成我们自己所需要的的东西/// 比如简历，我们在网上下载个简历模板，然后将自己的信息修改上去，这个就是我们自己的简历了////// 模板方法也是如此：/// 定义好一个模板骨架（下载简历模板），然后将一些具体的步骤延迟到子类中去实现（修改简历信息）////// 模板方法的模板骨架：/// 1.可以是抽象类：提供抽象方法，具体子类去实现（简历模板中是空白，你自己去填）/// 2.可以是虚方法：提供默认实现，子类可以去修改，也可以不修改（简历模板中已经填写了内容，根据需要是否修改）////// 此文中的例子：/// 我们炒菜时大部分步骤都是相同的，但是有些细节，不同的菜的做法有点不一样，此时就可以使用模板方法模式/// </summary>/// <param name="args"></param>static void Main(string[] args){MakeFood makePatato = new MakePatato();makePatato.Make();MakeFood makeChicken = new MakeChicken();makeChicken.Make();}
9.观察者模式（行为型模式）
对象间的一对多的依赖关系。
/// <summary>/// 腾讯（被观察者）：腾讯下面也有很多业务（公众号，游戏等等...）/// </summary>public abstract class TengXun{public string Title { get; set; }public string Content { get; set; }/// <summary>/// 存储观察我的人（粉丝）/// </summary>private List<IObserver> ObserverList = new List<IObserver>();/// <summary>/// 新增观察者（比如有新粉丝关注了我）/// </summary>/// <param name="observer"></param>public void Add(IObserver observer) {Console.WriteLine(observer.Name + "成为了你的新粉丝");ObserverList.Add(observer);}/// <summary>/// 移除观察者（比如有人取关了我）/// </summary>/// <param name="observer"></param>public void Remove(IObserver observer) {Console.WriteLine(observer.Name + "取消关注了你");ObserverList.Remove(ObserverList.First(r => r.Name == observer.Name));}/// <summary>/// 发送消息（我这边发送消息，我会给所有的观察者（粉丝）推送我的消息）/// </summary>public void SendMessage(string title, string content) {this.Title = title;this.Content = content;ObserverList.ForEach(r => r.ReceiveMessage(this));}}
/// <summary>/// 微信公众号（腾讯的一个项目）/// </summary>public class WeChatArticle : TengXun { }/// <summary>/// 和平精英（腾讯游戏）/// </summary>public class PeaceElite : TengXun { }
/// <summary>/// 观察者接口/// </summary>public interface IObserver{string Name { get; set; }/// <summary>/// 观察者接收消息/// </summary>/// <param name="tengxun"></param>void ReceiveMessage(TengXunEvent tengxun);}/// <summary>/// 微信公众号的粉丝（观察者）：观察微信公众号/// </summary>public class WeChatArticleFans : IObserver{public WeChatArticleFans(string name) {this.Name = name;}public string Name { get; set; }public void ReceiveMessage(TengXunEvent tengxun) {Console.WriteLine("{0}收到了微信公众号推送的一篇文章：标题：{1}，内容：{2}", this.Name, tengxun.Title, tengxun.Content);}}/// <summary>/// 腾讯游戏玩家（观察者）：观察腾讯游戏/// </summary>public class TengXunGamer : IObserver{public TengXunGamer(string name){this.Name = name;}public string Name { get; set; }public void ReceiveMessage(TengXunEvent tengxun){Console.WriteLine("{0}收到了和平精英推送的一条消息：标题：{1}，内容：{2}", this.Name, tengxun.Title, tengxun.Content);}}
/// <summary>/// 观察者模式：/// 生活中处处可见观察者模式，例如：/// 微博，如果我发送一篇微博，系统得把我发送的新微博推送给我的每一个粉丝/// 微信公众号，公众号发送一篇文章，系统会把这篇文章推送给所有关注该公众号的用户/// ......很多很多////// 像这样子的一对多的关系，我们都可以使用观察者模式去实现它/// 观察者模式分为：1.观察者；2.被观察者////// 在上面的例子中，观察者就是那些粉丝们（多个），被观察者就是微信公众号或者我本人（一个）/// 他们一直观察着，一旦被观察者发生变化（发送微博/文章），观察者会立马做出响应（推送微博/文章）////// 此文中我会用两种方式去实现观察者模式：/// 1.常规实现：基本所有开发语言都可以去实现观察者模式/// 2..Net方式实现：基于.Net里面的事件机制去实现观察者模式/// </summary>/// <param name="args"></param>static void Main(string[] args){TestCommon();}private static void TestCommon(){//初始化被观察者（微信公众号）TengXun wechatArticle = new WeChatArticle();//初始化被观察者（和平精英）TengXun game = new PeaceElite();//给微信公众号添加粉丝（观察者）wechatArticle.Add(new WeChatArticleFans("微信公众号粉丝：张三"));wechatArticle.Add(new WeChatArticleFans("微信公众号粉丝：李四"));wechatArticle.Add(new WeChatArticleFans("微信公众号粉丝：王五"));wechatArticle.Add(new WeChatArticleFans("微信公众号粉丝：赵柳"));Console.WriteLine("----------------------------------------------------------");//给和平精英添加玩家（观察者）game.Add(new TengXunGamer("和平精英玩家：张无忌"));game.Add(new TengXunGamer("和平精英玩家：秋刀"));game.Add(new TengXunGamer("和平精英玩家：琅琊榜"));game.Add(new TengXunGamer("和平精英玩家：金箍棒"));game.Add(new TengXunGamer("和平精英玩家：紧箍咒"));Console.WriteLine("----------------------------------------------------------");//微信公众号发通知（发表新文章）wechatArticle.SendMessage("一篇新文章", "来学习设计模式至观察者模式吧");Console.WriteLine("----------------------------------------------------------");//和平精英发通知（新动态）game.SendMessage("和平精英更新啦", "新玩法：火力模式，精英们快来保卫和平吧！");Console.WriteLine("----------------------------------------------------------");//取消关注game.Remove(new TengXunGamer("和平精英玩家：张无忌"));Console.WriteLine("----------------------------------------------------------");//再发送新的通知，取消关注的人就收不到推送了game.SendMessage("（和平精英）您有一条新消息", "万圣节，大家放开嗨");Console.WriteLine("----------------------------------------------------------");}
10.策略者模式（行为型模式）
定义一系列算法，把他们封装起来，并且使它们可以相互替换。
/// <summary>/// 计算税后工资接口/// </summary>public interface ICalcSalaryAfterTaxStrategy{decimal CalcSalary(decimal money);}
不同策略实现类
1. <=5000
/// <summary>/// 5000以下的计算策略/// </summary>public class CalcSalaryLessthan5000 : ICalcSalaryAfterTaxStrategy{public decimal CalcSalary(decimal money){//5000以下不用缴纳税return money;}}
2. <=8000
/// <summary>/// 8000以下的计算策略/// </summary>public class CalcSalaryLessthan8000 : ICalcSalaryAfterTaxStrategy{public decimal CalcSalary(decimal money){//5000到8000的部分缴纳10%，然后工资减去税得到税后工资return CoreService.MoneyFormat(Convert.ToDecimal(money - ((money - 5000) * Convert.ToDecimal(0.1))));}}
3. <13000
/// <summary>/// 13000以下的计算策略/// </summary>public class CalcSalaryLessthan13000 : ICalcSalaryAfterTaxStrategy{public decimal CalcSalary(decimal money){return CoreService.MoneyFormat(money - (8000 - 5000) * Convert.ToDecimal(0.1) - (money - 8000) * Convert.ToDecimal(0.2));}}
/// <summary>/// 策略者模式：/// 这是个很简单的模式，也是大家很常用的一个模式/// 上一个状态者模式说的是，一个对象通过不同的状态来展示出不同的形态，不同的业务逻辑/// 策略者模式也是如此，不同的策略展示出不同的结果////// 例如：/// 在计算税后工资时，我们需要根据税前工资计算出我们需要缴纳的税，减去这个税，才是我们的税后工资/// 但是不同的工资所需要的缴纳的税是不一样的，算法也是不一样的/// 比如现在5000以下不用缴税，5000到8000的部分是10%，8000到13000是20%等等/// 所以不同的工资计算的策略是不一样的////// 还有一个在开发中最常见的例子：/// 我们有很多数据库，如sqlserver，oracle，mysql，sqllite等等.../// 每个数据库都可以做增删改查，但是每个数据库如何去实现增删改查的策略是不一样的，这也是策略者模式////// 此文中的例子：计算税后工资/// 1.定义一个抽象类或者接口，在接口中定义一个行为：计算税后工资/// 2.分几个不同的类去实现这个接口，不同的类当然算法策略是不同的/// 3.然后客户端调用时，传递不同的策略，计算出不同的结果/// </summary>/// <param name="args"></param>static void Main(string[] args){var calcService1 = new CalcSalaryService(new CalcSalaryLessthan5000());calcService1.CalcSalaryAfterTax(4800);Console.WriteLine("-----------------------------------------------------");var calcService2 = new CalcSalaryService(new CalcSalaryLessthan8000());calcService2.CalcSalaryAfterTax(7750);Console.WriteLine("-----------------------------------------------------");var calcService3 = new CalcSalaryService(new CalcSalaryLessthan13000());calcService3.CalcSalaryAfterTax(12500);Console.WriteLine("-----------------------------------------------------");Console.ReadKey();}