用C详细讲解23种设计模式

　　工厂方法模式（FactoryMethodPattern）
　　工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法把对象的实例化推迟到子类。
　　代码示例：csharpCopycodepublicinterfaceIProduct｛voidOperation（）；｝publicclassProductA：IProduct｛publicvoidOperation（）｛Console。WriteLine（ProductAoperation）；｝｝publicclassProductB：IProduct｛publicvoidOperation（）｛Console。WriteLine（ProductBoperation）；｝｝publicabstractclassCreator｛publicabstractIProductFactoryMethod（）；｝publicclassConcreteCreatorA：Creator｛publicoverrideIProductFactoryMethod（）｛returnnewProductA（）；｝｝publicclassConcreteCreatorB：Creator｛publicoverrideIProductFactoryMethod（）｛returnnewProductB（）；｝｝抽象工厂模式（AbstractFactoryPattern）
　　抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。
　　代码示例：csharpCopycodepublicinterfaceIProductA｛voidOperationA（）；｝publicinterfaceIProductB｛voidOperationB（）；｝publicclassProductA1：IProductA｛publicvoidOperationA（）｛Console。WriteLine（ProductA1operation）；｝｝publicclassProductA2：IProductA｛publicvoidOperationA（）｛Console。WriteLine（ProductA2operation）；｝｝publicclassProductB1：IProductB｛publicvoidOperationB（）｛Console。WriteLine（ProductB1operation）；｝｝publicclassProductB2：IProductB｛publicvoidOperationB（）｛Console。WriteLine（ProductB2operation）；｝｝publicinterfaceIAbstractFactory｛IProductACreateProductA（）；IProductBCreateProductB（）；｝publicclassConcreteFactory1：IAbstractFactory｛publicIProductACreateProductA（）｛returnnewProductA1（）；｝publicIProductBCreateProductB（）｛returnnewProductB1（）；｝｝publicclassConcreteFactory2：IAbstractFactory｛publicIProductACreateProductA（）｛returnnewProductA2（）；｝publicIProductBCreateProductB（）｛returnnewProductB2（）；｝｝单例模式（SingletonPattern）
　　单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点。
　　代码示例：csharpCopycodepublicsealedclassSingleton｛privatestaticSingletoninstancenull；privateSingleton（）｛｝publicstaticSingletonInstance｛get｛if（instancenull）｛instancenewSingleton（）；｝returninstance；｝｝｝建造者模式（BuilderPattern）
　　建造者模式是一种创建型设计模式，它可以将一个复杂对象的构建过程和它的表示分离，使得同样的构建过程可以创建不同的表示。
　　代码示例：csharpCopycodepublicclassProduct｛publicstringPartA｛get；set；｝publicstringPartB｛get；set；｝publicstringPartC｛get；set；｝publicoverridestringToString（）｛return34；｛PartA｝，｛PartB｝，｛PartC｝；｝｝publicinterfaceIBuilder｛voidBuildPartA（）；voidBuildPartB（）；voidBuildPartC（）；ProductGetResult（）；｝publicclassConcreteBuilder：IBuilder｛privateProductproductnewProduct（）；publicvoidBuildPartA（）｛product。PartAPartA；｝publicvoidBuildPartB（）｛product。PartBPartB；｝publicvoidBuildPartC（）｛product。PartCPartC；｝publicProductGetResult（）｛returnproduct；｝｝publicclassDirector｛privateIBuilderbuilder；publicDirector（IBuilderbuilder）｛this。builderbuilder；｝publicvoidConstruct（）｛builder。BuildPartA（）；builder。BuildPartB（）；builder。BuildPartC（）；｝｝原型模式（PrototypePattern）
　　原型模式是一种创建型设计模式，它允许通过复制现有对象来创建新对象，而不是通过实例化的方式。
　　代码示例：csharpCopycodepublicclassPrototype：ICloneable｛publicstringValue｛get；set；｝publicobjectClone（）｛returnMemberwiseClone（）；｝｝适配器模式（AdapterPattern）
　　适配器模式是一种结构型设计模式，它可以将一种类的接口转换成客户端希望的另一种接口。适配器模式允许接口不兼容的类能够合作。
　　代码示例：csharpCopycodepublicinterfaceITarget｛voidRequest（）；｝publicclassAdaptee｛publicvoidSpecificRequest（）｛Console。WriteLine（Adapteespecificrequest）；｝｝publicclassAdapter：ITarget｛privatereadonlyAdapteeadaptee；publicAdapter（Adapteeadaptee）｛this。adapteeadaptee；｝publicvoidRequest（）｛adaptee。SpecificRequest（）；｝｝桥接模式（BridgePattern）
　　桥接模式是一种结构型设计模式，它可以将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构，从而能在开发时分别使用。
　　代码示例：csharpCopycodepublicinterfaceIImplementor｛voidOperationImp（）；｝publicclassConcreteImplementorA：IImplementor｛publicvoidOperationImp（）｛Console。WriteLine（ConcreteImplementorAOperationImp）；｝｝publicclassConcreteImplementorB：IImplementor｛publicvoidOperationImp（）｛Console。WriteLine（ConcreteImplementorBOperationImp）；｝｝publicabstractclassAbstraction｛protectedIImplementorimplementor；protectedAbstraction（IImplementorimplementor）｛this。implementorimplementor；｝publicabstractvoidOperation（）；｝publicclassRefinedAbstraction：Abstraction｛publicRefinedAbstraction（IImplementorimplementor）：base（implementor）｛｝publicoverridevoidOperation（）｛implementor。OperationImp（）；｝｝组合模式（CompositePattern）
　　组合模式是一种结构型设计模式，它允许将对象组合成树形结构来表现整体部分关系。组合能让客户端统一处理单个对象和对象组合。
　　代码示例：csharpCopycodepublicabstractclassComponent｛protectedreadonlystringname；publicComponent（stringname）｛this。namename；｝publicabstractvoidOperation（）；｝publicclassLeaf：Component｛publicLeaf（stringname）：base（name）｛｝publicoverridevoidOperation（）｛Console。WriteLine（34；Leaf｛name｝Operation）；｝｝publicclassComposite：Component｛privatereadonlyListComponentchildrennewListComponent（）；publicComposite（stringname）：base（name）｛｝publicoverridevoidOperation（）｛Console。WriteLine（34；Composite｛name｝Operation）；foreach（varchildinchildren）｛child。Operation（）；｝｝publicvoidAdd（Componentcomponent）｛children。Add（component）；｝publicvoidRemove（Componentcomponent）｛children。Remove（component）；｝｝桥接模式（BridgePattern）
　　桥接模式是一种结构型设计模式，它将抽象与实现分离，以便它们可以独立地进行变化。
　　代码示例：csharpCopycodepublicinterfaceIImplementor｛voidOperationImp（）；｝publicclassConcreteImplementorA：IImplementor｛publicvoidOperationImp（）｛Console。WriteLine（ConcreteImplementorAOperationImp）；｝｝publicclassConcreteImplementorB：IImplementor｛publicvoidOperationImp（）｛Console。WriteLine（ConcreteImplementorBOperationImp）；｝｝publicabstractclassAbstraction｛protectedIImplementorimplementor；publicAbstraction（IImplementorimplementor）｛this。implementorimplementor；｝publicabstractvoidOperation（）；｝publicclassRefinedAbstraction：Abstraction｛publicRefinedAbstraction（IImplementorimplementor）：base（implementor）｛｝publicoverridevoidOperation（）｛implementor。OperationImp（）；｝｝外观模式（FacadePattern）
　　外观模式是一种结构型设计模式，它为复杂的子系统提供简单的接口，从而使子系统更易于使用。
　　代码示例：csharpCopycodepublicclassSubsystemA｛publicvoidOperationA（）｛Console。WriteLine（SubsystemAOperationA）；｝｝publicclassSubsystemB｛publicvoidOperationB（）｛Console。WriteLine（SubsystemBOperationB）；｝｝publicclassFacade｛privatereadonlySubsystemAsubsystemA；privatereadonlySubsystemBsubsystemB；publicFacade（SubsystemAsubsystemA，SubsystemBsubsystemB）｛this。subsystemAsubsystemA；this。subsystemBsubsystemB；｝publicvoidOperation（）｛subsystemA。OperationA（）；subsystemB。OperationB（）；｝｝享元模式（FlyweightPattern）
　　享元模式是一种结构型设计模式，它通过共享尽可能多的数据来最小化内存使用和计算开销。享元模式适用于需要大量对象的情况，同时又要求对象能够轻量化。
　　代码示例：csharpCopycodepublicclassFlyweightFactory｛privatereadonlyDictionarychar，FlyweightflyweightsnewDictionarychar，Flyweight（）；publicFlyweightGetFlyweight（charkey）｛if（！flyweights。TryGetValue（key，outvarflyweight））｛flyweightnewConcreteFlyweight（key）；flyweights〔key〕flyweight；｝returnflyweight；｝｝publicabstractclassFlyweight｛publicabstractvoidOperation（）；｝publicclassConcreteFlyweight：Flyweight｛privatereadonlycharintrinsicState；publicConcreteFlyweight（charintrinsicState）｛this。intrinsicStateintrinsicState；｝publicoverridevoidOperation（）｛Console。WriteLine（34；ConcreteFlyweight｛intrinsicState｝Operation）；｝｝publicclassUnsharedConcreteFlyweight：Flyweight｛privatereadonlystringextrinsicState；publicUnsharedConcreteFlyweight（stringextrinsicState）｛this。extrinsicStateextrinsicState；｝publicoverridevoidOperation（）｛Console。WriteLine（34；UnsharedConcreteFlyweight｛extrinsicState｝Operation）；｝｝组合模式（CompositePattern）
　　组合模式是一种结构型设计模式，允许你将对象组合成树状结构，并且能像使用独立对象一样使用它们。
　　适用场景：
　　1。当你想表示对象的部分整体层次结构时。
　　2。当你希望用户可以忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象时。
　　组合模式中的关键类：Component（组件）：是组合中的对象声明接口，在适当情况下，实现所有类共有的接口默认行为。声明一个接口用于访问和管理Component子部件。Leaf（叶子）：在组合中表示子节点对象，叶子节点没有子节点。Composite（容器）：定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关的操作，比如增加Add和删除Remove。
　　代码示例：
　　下面是一个组合模式的示例，我们以一个目录结构为例来实现组合模式。目录中可以包含文件和文件夹，文件夹中又可以包含文件和文件夹。csharpCopycode抽象构件publicabstractclassComponent｛protectedstringname；publicComponent（stringname）｛this。namename；｝publicabstractvoidAdd（Componentc）；publicabstractvoidRemove（Componentc）；publicabstractvoidDisplay（intdepth）；｝叶子节点publicclassLeaf：Component｛publicLeaf（stringname）：base（name）｛｝publicoverridevoidAdd（Componentc）｛Console。WriteLine（不能向叶子节点添加节点）；｝publicoverridevoidRemove（Componentc）｛Console。WriteLine（不能从叶子节点移除节点）；｝publicoverridevoidDisplay（intdepth）｛Console。WriteLine（newstring（，depth）name）；｝｝容器节点publicclassComposite：Component｛privateListComponentchildrennewListComponent（）；publicComposite（stringname）：base（name）｛｝publicoverridevoidAdd（Componentc）｛children。Add（c）；｝publicoverridevoidRemove（Componentc）｛children。Remove（c）；｝publicoverridevoidDisplay（intdepth）｛Console。WriteLine（newstring（，depth）name）；foreach（Componentcomponentinchildren）｛component。Display（depth2）；｝｝｝客户端代码classClient｛staticvoidMain（string〔〕args）｛CompositerootnewComposite（C：）；CompositewindowsnewComposite（Windows）；CompositeprogramFilesnewComposite（ProgramFiles）；Leaffile1newLeaf（a。txt）；Leaffile2newLeaf（b。txt）；Leaffile3newLeaf（c。txt）；root。Add（windows）；root。Add（programFiles）；windows。Add（file1）；windows。Add（file2）；programFiles。Add（file3）；root。Display（0）；Console。ReadKey（）；｝｝Proxy（代理模式）
　　代理模式为其他对象提供一种代理以控制对这个对象的访问。代理类与实际类具有相同的接口，这样就可以使用代理来代替实际类，使得在不改变原始代码的情况下增加了一些额外的功能。常用的代理模式有远程代理、虚拟代理、保护代理、缓存代理等。
　　代码示例：csharpCopycode实际类publicclassRealSubject：ISubject｛publicvoidRequest（）｛Console。WriteLine（RealSubject：HandlingRequest。）；｝｝代理类publicclassProxy：ISubject｛privatereadonlyRealSubjectrealSubject；publicProxy（RealSubjectrealSubject）｛realSubjectrealSubject；｝publicvoidRequest（）｛if（CheckAccess（））｛realSubject。Request（）；LogAccess（）；｝｝privateboolCheckAccess（）｛Console。WriteLine（Proxy：Checkingaccesspriortofiringarealrequest。）；returntrue；｝privatevoidLogAccess（）｛Console。WriteLine（Proxy：Loggingthetimeofrequest。）；｝｝接口类publicinterfaceISubject｛voidRequest（）；｝使用代理staticvoidMain（string〔〕args）｛varrealSubjectnewRealSubject（）；varproxynewProxy（realSubject）；proxy。Request（）；｝Command（命令模式）
　　命令模式是一种行为型模式，它通过将请求封装为一个对象来实现请求的发送者和接收者之间的解耦。命令对象包含了要执行的操作以及其相关的数据，可以把命令对象看成是一个操作的载体。常用的命令模式有简单命令、复杂命令、队列请求等。
　　代码示例：csharpCopycode命令接口publicinterfaceICommand｛voidExecute（）；｝具体命令publicclassConcreteCommand：ICommand｛privatereadonlyReceiverreceiver；publicConcreteCommand（Receiverreceiver）｛receiverreceiver；｝publicvoidExecute（）｛receiver。Action（）；｝｝接收者publicclassReceiver｛publicvoidAction（）｛Console。WriteLine（Receiver：Action。）；｝｝发送者publicclassInvoker｛privateICommandcommand；publicvoidSetCommand（ICommandcommand）｛commandcommand；｝publicvoidExecuteCommand（）｛command。Execute（）；｝｝使用命令模式staticvoidMain（string〔〕args）｛varreceivernewReceiver（）；varcommandnewConcreteCommand（receiver）；varinvokernewInvoker（）；invoker。SetCommand（command）；invoker。ExecuteCommand（）；｝责任链模式（ChainofResponsibilityPattern）
　　责任链模式是一种行为型设计模式，它通过将请求的发送者和接收者解耦，使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理为止。
　　在责任链模式中，每个处理器都只关心它自己能够处理的请求，并把它转发给下一个处理器。这样，请求者与处理器之间的耦合就被解除了，可以动态地改变请求的处理顺序或者增加删除处理器。
　　代码示例：
　　下面是一个简单的例子，用来演示使用责任链模式实现不同等级的员工申请加薪请求的处理：csharpCopycodeabstractclassApprover｛protectedApproversuccessor；publicvoidSetSuccessor（Approversuccessor）｛this。successorsuccessor；｝publicabstractvoidProcessRequest（Requestrequest）；｝classManager：Approver｛publicoverridevoidProcessRequest（Requestrequest）｛if（request。TypeRequestType。RaiseSalaryrequest。Amount500）｛Console。WriteLine（34；Managerapprovedtherequestforraiseofamount｛request。Amount｝）；｝elseif（successor！null）｛successor。ProcessRequest（request）；｝｝｝classDepartmentHead：Approver｛publicoverridevoidProcessRequest（Requestrequest）｛if（request。TypeRequestType。RaiseSalaryrequest。Amount1000）｛Console。WriteLine（34；Departmentheadapprovedtherequestforraiseofamount｛request。Amount｝）；｝elseif（successor！null）｛successor。ProcessRequest（request）；｝｝｝classCEO：Approver｛publicoverridevoidProcessRequest（Requestrequest）｛if（request。TypeRequestType。RaiseSalaryrequest。Amount5000）｛Console。WriteLine（34；CEOapprovedtherequestforraiseofamount｛request。Amount｝）；｝else｛Console。WriteLine（34；Therequestforraiseofamount｛request。Amount｝cannotbeapprovedbyanyone。）；｝｝｝classRequest｛publicRequestTypeType｛get；set；｝publicintAmount｛get；set；｝｝enumRequestType｛RaiseSalary｝staticvoidMain（string〔〕args）｛ManagermanagernewManager（）；DepartmentHeaddepartmentHeadnewDepartmentHead（）；CEOceonewCEO（）；manager。SetSuccessor（departmentHead）；departmentHead。SetSuccessor（ceo）；Requestrequest1newRequest（）｛TypeRequestType。RaiseSalary，Amount400｝；manager。ProcessRequest（request1）；Requestrequest2newRequest（）｛TypeRequestType。RaiseSalary，Amount1500｝；manager。ProcessRequest（request2）；Requestrequest3newRequest（）｛TypeRequestType。RaiseSalary，Amount6000｝；manager。ProcessRequest（request3）；｝
　　输出结果：pythonCopycodeManagerapprovedtherequestforraiseofamount400Departmentheadapprovedtherequestforraiseofamount1500Therequestforraiseofamount6000cannotbeapprovedbyanyone。迭代器模式（IteratorPattern）
　　描述：迭代器模式是一种行为型设计模式，它可以在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。示例：csharpCopycodepublicclassIteratorPatternExample｛staticvoidMain（string〔〕args）｛varcollectionnewConcreteAggregatestring（）；collection〔0〕One；collection〔1〕Two；collection〔2〕Three；collection〔3〕Four；variteratorcollection。CreateIterator（）；Console。WriteLine（Iteratingovercollection：）；while（iterator。MoveNext（））｛varelementiterator。Current；Console。WriteLine（element）；｝｝｝publicinterfaceIIteratorT｛boolMoveNext（）；TCurrent｛get；｝voidReset（）；｝publicinterfaceIAggregateT｛IIteratorTCreateIterator（）；｝publicclassConcreteAggregateT：IAggregateT｛privateListTitemsnewListT（）；publicIIteratorTCreateIterator（）｛returnnewConcreteIteratorT（this）；｝publicintCount｛get｛returnitems。Count；｝｝publicTthis〔intindex〕｛get｛returnitems〔index〕；｝set｛items。Insert（index，value）；｝｝｝publicclassConcreteIteratorT：IIteratorT｛privateConcreteAggregateTaggregate；privateintcurrentIndex0；publicConcreteIterator（ConcreteAggregateTaggregate）｛aggregateaggregate；｝publicTCurrent｛get｛returnaggregate〔currentIndex〕；｝｝publicboolMoveNext（）｛if（currentIndexaggregate。Count）｛currentIndex；returntrue；｝returnfalse；｝publicvoidReset（）｛currentIndex0；｝｝中介者模式（MediatorPattern）
　　中介者模式用于降低多个对象之间的通信复杂性。该模式定义一个中介者对象，使得各个对象不需要显式地相互引用，从而降低耦合度，同时可以独立地改变对象之间的交互。
　　代码示例：csharpCopycodepublicabstractclassMediator｛publicabstractvoidSend（stringmessage，Colleaguecolleague）；｝publicclassConcreteMediator：Mediator｛privateConcreteColleague1colleague1；privateConcreteColleague2colleague2；publicConcreteColleague1Colleague1｛set｛colleague1value；｝｝publicConcreteColleague2Colleague2｛set｛colleague2value；｝｝publicoverridevoidSend（stringmessage，Colleaguecolleague）｛if（colleaguecolleague1）｛colleague2。Notify（message）；｝else｛colleague1。Notify（message）；｝｝｝publicabstractclassColleague｛protectedMediatormediator；publicColleague（Mediatormediator）｛this。mediatormediator；｝publicabstractvoidSend（stringmessage）；publicabstractvoidNotify（stringmessage）；｝publicclassConcreteColleague1：Colleague｛publicConcreteColleague1（Mediatormediator）：base（mediator）｛｝publicoverridevoidSend（stringmessage）｛mediator。Send（message，this）；｝publicoverridevoidNotify（stringmessage）｛Console。WriteLine（Colleague1getsmessage：message）；｝｝publicclassConcreteColleague2：Colleague｛publicConcreteColleague2（Mediatormediator）：base（mediator）｛｝publicoverridevoidSend（stringmessage）｛mediator。Send（message，this）；｝publicoverridevoidNotify（stringmessage）｛Console。WriteLine（Colleague2getsmessage：message）；｝｝备忘录模式（MementoPattern）
　　备忘录模式用于保存一个对象的状态，以便在以后可以恢复到该状态。该模式有三个角色：备忘录（Memento）负责存储对象的状态，原发器（Originator）负责创建备忘录和恢复备忘录，管理者（Caretaker）负责保存和恢复备忘录。
　　代码示例：csharpCopycodepublicclassMemento｛privatestringstate；publicMemento（stringstate）｛this。statestate；｝publicstringState｛get｛returnstate；｝｝｝publicclassOriginator｛privatestringstate；publicstringState｛get｛returnstate；｝set｛statevalue；｝｝publicMementoCreateMemento（）｛returnnewMemento（state）；｝publicvoidSetMemento（Mementomemento）｛statememento。State；｝｝publicclassCaretaker｛privateMementomemento；publicMementoMemento｛get｛returnmemento；｝set｛mementovalue；｝｝｝观察者模式（ObserverPattern）观察者模式（ObserverPattern）：定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，所有依赖它的观察者都会自动收到通知并进行更新。csharpCopycodepublicinterfaceIObserver｛voidUpdate（ISubjectsubject）；｝publicinterfaceISubject｛voidAttach（IObserverobserver）；voidDetach（IObserverobserver）；voidNotify（）；｝publicclassConcreteSubject：ISubject｛privateListIObserverobserversnewListIObserver（）；privateintstate；publicvoidAttach（IObserverobserver）｛observers。Add（observer）；｝publicvoidDetach（IObserverobserver）｛observers。Remove（observer）；｝publicvoidNotify（）｛foreach（varobserverinobservers）｛observer。Update（this）；｝｝publicintGetState（）｛returnstate；｝publicvoidSetState（intstate）｛this。statestate；Notify（）；｝｝publicclassConcreteObserver：IObserver｛privatestringname；publicConcreteObserver（stringname）｛this。namename；｝publicvoidUpdate（ISubjectsubject）｛Console。WriteLine（34；｛name｝receivedthemessagefrom｛subject。GetType（）。Name｝，thenewstateis｛（（ConcreteSubject）subject）。GetState（）｝）；｝｝classProgram｛staticvoidMain（string〔〕args）｛ISubjectsubjectnewConcreteSubject（）；IObserverobserver1newConcreteObserver（Observer1）；IObserverobserver2newConcreteObserver（Observer2）；subject。Attach（observer1）；subject。Attach（observer2）；（（ConcreteSubject）subject）。SetState（1）；subject。Detach（observer1）；（（ConcreteSubject）subject）。SetState（2）；Console。ReadLine（）；｝｝状态模式（StatePattern）
　　状态模式（StatePattern）是一种行为型设计模式，它允许对象在内部状态发生改变时改变它的行为。状态模式通过将复杂的条件语句转换为对象的形式，使得代码更加灵活、可维护和可扩展。
　　在状态模式中，一个对象的行为取决于其内部状态，对象会根据不同的状态来执行不同的操作。这种模式是一种行为型模式。
　　在状态模式中，主要有三种角色：上下文（Context）、抽象状态（State）、具体状态（ConcreteState）。其中，上下文是一个包含状态的对象，抽象状态是一个定义所有具体状态的接口，具体状态是实现状态的具体类。
　　下面以电视遥控器为例，使用状态模式进行设计。当电视遥控器处于不同状态时，它会对按下的按钮产生不同的响应，例如当电视遥控器处于开机状态时，按下换台按钮会切换频道；当电视遥控器处于关机状态时，按下换台按钮则没有任何响应。
　　首先，定义一个抽象状态接口：csharpCopycodepublicinterfaceITvState｛voidTurnOn（）；voidTurnOff（）；voidNextChannel（）；voidPrevChannel（）；｝
　　接下来，定义具体的状态类，这里定义了两个具体状态类，分别代表电视开机状态和电视关机状态：csharpCopycodepublicclassTvOnState：ITvState｛publicvoidTurnOn（）｛Console。WriteLine（电视已经开机）；｝publicvoidTurnOff（）｛Console。WriteLine（电视关机）；｝publicvoidNextChannel（）｛Console。WriteLine（下一个频道）；｝publicvoidPrevChannel（）｛Console。WriteLine（上一个频道）；｝｝publicclassTvOffState：ITvState｛publicvoidTurnOn（）｛Console。WriteLine（电视开机）；｝publicvoidTurnOff（）｛Console。WriteLine（电视已经关机）；｝publicvoidNextChannel（）｛Console。WriteLine（电视已经关机，无法切换频道）；｝publicvoidPrevChannel（）｛Console。WriteLine（电视已经关机，无法切换频道）；｝｝
　　最后，定义上下文类，它包含了当前电视的状态，并提供了一些接口供外界使用：csharpCopycodepublicclassTvContext｛privateITvStatestate；publicTvContext（）｛statenewTvOffState（）；｝publicvoidSetState（ITvStatestate）｛this。statestate；｝publicvoidTurnOn（）｛state。TurnOn（）；SetState（newTvOnState（））；｝publicvoidTurnOff（）｛state。TurnOff（）；SetState（newTvOffState（））；｝publicvoidNextChannel（）｛state。NextChannel（）；｝publicvoidPrevChannel（）｛state。PrevChannel（）；｝｝
　　现在，我们就可以使用上下文类来操作电视遥控器了，例如：csharpCopycodeTvContextcontextnewTvContext（）；context。TurnOn（）；context。NextChannel（）；context。NextChannel（）；context。PrevChannel（）；context。TurnOff（）；
　　输出结果为：Copycode电视开机下一个频道下一个频道上一个频道电视关机策略模式（StrategyPattern）
　　策略模式（StrategyPattern）是一种行为设计模式，它允许在运行时选择算法的行为。该模式定义了一组算法，将每个算法封装起来，并使它们之间可以相互替换。
　　下面是使用C实现策略模式的示例代码：csharpCopycode抽象策略publicinterfaceIStrategy｛voidExecute（）；｝具体策略publicclassConcreteStrategyA：IStrategy｛publicvoidExecute（）｛Console。WriteLine（执行策略A）；｝｝具体策略publicclassConcreteStrategyB：IStrategy｛publicvoidExecute（）｛Console。WriteLine（执行策略B）；｝｝上下文publicclassContext｛privateIStrategystrategy；publicContext（IStrategystrategy）｛strategystrategy；｝publicvoidSetStrategy（IStrategystrategy）｛strategystrategy；｝publicvoidExecuteStrategy（）｛strategy。Execute（）；｝｝客户端代码publicclassClient｛publicstaticvoidMain（）｛创建上下文并设置初始策略ContextcontextnewContext（newConcreteStrategyA（））；执行策略Acontext。ExecuteStrategy（）；切换策略context。SetStrategy（newConcreteStrategyB（））；执行策略Bcontext。ExecuteStrategy（）；｝｝
　　在这个示例中，IStrategy是抽象策略，定义了策略的接口。ConcreteStrategyA和ConcreteStrategyB是具体策略，实现了策略接口。Context是上下文，维护了一个策略对象，并且提供了一些方法来使用该策略。Client是客户端代码，使用上下文对象来执行策略。在客户端代码中，我们首先创建了一个上下文对象并设置了一个初始策略。然后我们执行了策略A，接着我们切换了策略并执行了策略B。模板方法模式（TemplateMethodPattern）
　　在模板方法模式中，有一个抽象类定义了一些抽象的方法和模板方法，模板方法是一个固定的算法流程，而抽象的方法则需要子类去实现。模板方法模式的目的是让子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
　　下面是一个简单的示例代码：csharpCopycodeusingSystem；abstractclassAbstractClass｛publicvoidTemplateMethod（）｛Operation1（）；Operation2（）；｝publicabstractvoidOperation1（）；publicabstractvoidOperation2（）；｝classConcreteClassA：AbstractClass｛publicoverridevoidOperation1（）｛Console。WriteLine（ConcreteClassA。Operation1）；｝publicoverridevoidOperation2（）｛Console。WriteLine（ConcreteClassA。Operation2）；｝｝classConcreteClassB：AbstractClass｛publicoverridevoidOperation1（）｛Console。WriteLine（ConcreteClassB。Operation1）；｝publicoverridevoidOperation2（）｛Console。WriteLine（ConcreteClassB。Operation2）；｝｝classProgram｛staticvoidMain（string〔〕args）｛AbstractClassc1newConcreteClassA（）；AbstractClassc2newConcreteClassB（）；c1。TemplateMethod（）；c2。TemplateMethod（）；Console。ReadKey（）；｝｝
　　在上面的代码中，AbstractClass是一个抽象类，它有一个TemplateMethod方法，该方法调用了两个抽象方法Operation1和Operation2。具体的子类ConcreteClassA和ConcreteClassB分别实现了这两个抽象方法，并且可以在模板方法中按照特定的流程调用它们。
　　当我们运行这个程序时，输出如下：CopycodeConcreteClassA。Operation1ConcreteClassA。Operation2ConcreteClassB。Operation1ConcreteClassB。Operation2
　　这表明模板方法模式确实在两个具体的子类中分别执行了它们的Operation1和Operation2方法，但是并没有改变模板方法的算法流程。访问者模式（VisitorPattern）
　　访问者模式（VisitorPattern）是一种行为型设计模式，它允许你定义算法（访问者），并将其与一组对象分离。访问者模式最常见的应用场景是在对象结构比较稳定的情况下，需要对对象结构中的对象进行各种不同的操作，且经常添加新的操作。
　　下面是一个使用访问者模式的示例代码：csharpCopycodeusingSystem；usingSystem。Collections。Generic；访问者接口interfaceIVisitor｛voidVisit（ConcreteElementAelementA）；voidVisit（ConcreteElementBelementB）；｝抽象元素类abstractclassElement｛publicabstractvoidAccept（IVisitorvisitor）；｝具体元素类AclassConcreteElementA：Element｛publicoverridevoidAccept（IVisitorvisitor）｛visitor。Visit（this）；｝publicvoidOperationA（）｛Console。WriteLine（ConcreteElementA。OperationA（））；｝｝具体元素类BclassConcreteElementB：Element｛publicoverridevoidAccept（IVisitorvisitor）｛visitor。Visit（this）；｝publicvoidOperationB（）｛Console。WriteLine（ConcreteElementB。OperationB（））；｝｝具体访问者类classConcreteVisitor：IVisitor｛publicvoidVisit（ConcreteElementAelementA）｛elementA。OperationA（）；｝publicvoidVisit（ConcreteElementBelementB）｛elementB。OperationB（）；｝｝对象结构类classObjectStructure｛privateListElementelementsnewListElement（）；publicvoidAttach（Elementelement）｛elements。Add（element）；｝publicvoidDetach（Elementelement）｛elements。Remove（element）；｝publicvoidAccept（IVisitorvisitor）｛foreach（Elementelementinelements）｛element。Accept（visitor）；｝｝｝客户端代码classClient｛staticvoidMain（）｛ObjectStructureobjectStructurenewObjectStructure（）；objectStructure。Attach（newConcreteElementA（））；objectStructure。Attach（newConcreteElementB（））；ConcreteVisitorvisitornewConcreteVisitor（）；objectStructure。Accept（visitor）；Console。ReadKey（）；｝｝
　　在上面的示例中，IVisitor定义了访问者的接口，包含了对每个具体元素类的访问方法。Element是抽象元素类，定义了Accept方法，接受访问者的访问。ConcreteElementA和ConcreteElementB是具体元素类，实现了Accept方法，并且定义了各自的操作方法。ConcreteVisitor是具体访问者类，实现了IVisitor接口，实现了对每个具体元素的操作。ObjectStructure是对象结构类，包含了元素对象集合，并提供了Accept方法，接受访问者的访问。客户端代码通过创建ObjectStructure对象，向其中添加具体元素对象，并创建ConcreteVisitor对象进行访问操作。
　　文章来源于token的技术分享，作者tokengo
　　token的技术分享。
　　分享。NET生态技术，和。NET相关知识