使用c#實現(xiàn)23種常見的設計模式|全球新消息
設計模式通常分為三個主要類別：
創(chuàng)建型模式
結(jié)構(gòu)型模式
(相關資料圖)
行為型模式。
這些模式是用于解決常見的對象導向設計問題的最佳實踐。
以下是23種常見的設計模式并且提供c#代碼案例：
public sealed class Singleton{ //創(chuàng)建一個只讀的靜態(tài)Singleton實例 private static readonly Singleton instance = new Singleton(); // 記錄Singleton的創(chuàng)建次數(shù) private static int instanceCounter = 0; // 單例實例的公共訪問點 public static Singleton Instance { get { return instance; } } // 私有構(gòu)造函數(shù) private Singleton() { instanceCounter++; Console.WriteLine("Instances Created " + instanceCounter); } // 在此處添加其他的Singleton類方法 public void LogMessage(string message) { Console.WriteLine("Message: " + message); }}在這個例子中，我們有一個名為Singleton的類，它有一個私有的構(gòu)造函數(shù)和一個靜態(tài)的只讀屬性Instance，用于訪問Singleton類的唯一實例。我們還有一個LogMessage方法，用于模擬Singleton類的某個行為。
以下是一個使用這個Singleton類的控制臺應用程序：
class Program{ static void Main(string[] args) { Singleton fromEmployee = Singleton.Instance; fromEmployee.LogMessage("Message from Employee"); Singleton fromBoss = Singleton.Instance; fromBoss.LogMessage("Message from Boss"); Console.ReadLine(); }}工廠方法模式是一種創(chuàng)建型設計模式，它提供了一種創(chuàng)建對象的接口，但允許子類決定實例化哪個類。工廠方法讓類的實例化推遲到子類中進行。
下面是一個使用C#實現(xiàn)的工廠方法模式的簡單示例：
// 抽象產(chǎn)品public interface IProduct{ string Operation();}// 具體產(chǎn)品Apublic class ProductA : IProduct{ public string Operation() { return "{Result of ProductA}"; }}// 具體產(chǎn)品Bpublic class ProductB : IProduct{ public string Operation() { return "{Result of ProductB}"; }}// 抽象創(chuàng)建者public abstract class Creator{ public abstract IProduct FactoryMethod();}// 具體創(chuàng)建者Apublic class CreatorA : Creator{ public override IProduct FactoryMethod() { return new ProductA(); }}// 具體創(chuàng)建者Bpublic class CreatorB : Creator{ public override IProduct FactoryMethod() { return new ProductB(); }}以上代碼中定義了兩個產(chǎn)品ProductA和ProductB，這兩個產(chǎn)品都實現(xiàn)了IProduct接口。接著我們有兩個Creator類，CreatorA和CreatorB，它們都繼承自抽象基類Creator。CreatorA工廠創(chuàng)建ProductA，CreatorB工廠創(chuàng)建ProductB。
以下是一個使用這些工廠和產(chǎn)品的示例：
class Program{ static void Main(string[] args) { // 創(chuàng)建工廠對象 Creator creatorA = new CreatorA(); Creator creatorB = new CreatorB(); // 通過工廠方法創(chuàng)建產(chǎn)品對象 IProduct productA = creatorA.FactoryMethod(); IProduct productB = creatorB.FactoryMethod(); // 打印結(jié)果 Console.WriteLine("ProductA says: " + productA.Operation()); Console.WriteLine("ProductB says: " + productB.Operation()); Console.ReadLine(); }}當你運行這個程序時，它會顯示出ProductA和ProductB的Operation方法返回的結(jié)果。這說明我們已經(jīng)成功地使用工廠方法模式創(chuàng)建了產(chǎn)品實例。每個工廠類決定了它創(chuàng)建哪個產(chǎn)品的實例。這種方式使得客戶端代碼不需要直接實例化產(chǎn)品類，而只需要依賴工廠接口，增加了程序的靈活性。
抽象工廠模式是一種創(chuàng)建型設計模式，它提供了一種接口，用于創(chuàng)建相關或依賴對象的系列，而不指定這些對象的具體類。在這個模式中，客戶端通過他們的抽象接口使用類，允許該模式在不影響客戶端的情況下替換實現(xiàn)類。
以下是一個簡單的抽象工廠模式的C#實現(xiàn)：
// 抽象產(chǎn)品：動物public interface IAnimal{ string Speak();}// 具體產(chǎn)品：狗public class Dog : IAnimal{ public string Speak() { return "Bark Bark"; }}// 具體產(chǎn)品：貓public class Cat : IAnimal{ public string Speak() { return "Meow Meow"; }}// 抽象工廠public abstract class IAnimalFactory{ public abstract IAnimal CreateAnimal();}// 具體工廠：狗工廠public class DogFactory : IAnimalFactory{ public override IAnimal CreateAnimal() { return new Dog(); }}// 具體工廠：貓工廠public class CatFactory : IAnimalFactory{ public override IAnimal CreateAnimal() { return new Cat(); }}以上代碼定義了兩種動物Dog和Cat，它們都實現(xiàn)了IAnimal接口。然后我們有兩個工廠類，DogFactory和CatFactory，它們都繼承自IAnimalFactory。DogFactory生產(chǎn)Dog，而CatFactory生產(chǎn)Cat。
以下是一個使用這些工廠和產(chǎn)品的示例：
class Program{ static void Main(string[] args) { // 創(chuàng)建工廠 IAnimalFactory dogFactory = new DogFactory(); IAnimalFactory catFactory = new CatFactory(); // 使用工廠創(chuàng)建產(chǎn)品 IAnimal dog = dogFactory.CreateAnimal(); IAnimal cat = catFactory.CreateAnimal(); // 打印結(jié)果 Console.WriteLine("Dog says: " + dog.Speak()); Console.WriteLine("Cat says: " + cat.Speak()); Console.ReadLine(); }}當你運行這個程序時，會打印出Dog和Cat的Speak方法的結(jié)果，這顯示了我們已經(jīng)成功地使用了抽象工廠模式創(chuàng)建了產(chǎn)品實例。這種方式使得客戶端代碼不需要直接實例化產(chǎn)品類，而只需要依賴工廠接口，增加了程序的靈活性和擴展性。
4. 建造者模式（Builder）建造者模式是一種創(chuàng)建型設計模式，它提供了一種創(chuàng)建對象的接口，但是允許使用相同的構(gòu)建過程來創(chuàng)建不同的產(chǎn)品。
以下是在C#中實現(xiàn)建造者模式的一個簡單示例：
// 產(chǎn)品public class Car{ public string Engine { get; set; } public string Wheels { get; set; } public string Doors { get; set; }}// 建造者抽象類public abstract class CarBuilder{ protected Car car; public void CreateNewCar() { car = new Car(); } public Car GetCar() { return car; } public abstract void SetEngine(); public abstract void SetWheels(); public abstract void SetDoors();}// 具體建造者public class FerrariBuilder : CarBuilder{ public override void SetEngine() { car.Engine = "V8"; } public override void SetWheels() { car.Wheels = "18 inch"; } public override void SetDoors() { car.Doors = "2"; }}// 指揮者public class Director{ public Car Construct(CarBuilder carBuilder) { carBuilder.CreateNewCar(); carBuilder.SetEngine(); carBuilder.SetWheels(); carBuilder.SetDoors(); return carBuilder.GetCar(); }}以上代碼中，Car是我們要創(chuàng)建的產(chǎn)品，CarBuilder是抽象的建造者，定義了制造一個產(chǎn)品所需要的各個步驟，FerrariBuilder是具體的建造者，實現(xiàn)了CarBuilder定義的所有步驟，Director是指揮者，它告訴建造者應該按照什么順序去執(zhí)行哪些步驟。
以下是一個使用這個建造者模式的示例：
class Program{ static void Main(string[] args) { Director director = new Director(); CarBuilder builder = new FerrariBuilder(); Car ferrari = director.Construct(builder); Console.WriteLine($"Engine: {ferrari.Engine}, Wheels: {ferrari.Wheels}, Doors: {ferrari.Doors}"); Console.ReadLine(); }}當你運行這個程序時，會看到我們已經(jīng)成功地創(chuàng)建了一個Car實例，它的各個部分是按照FerrariBuilder所定義的方式創(chuàng)建的。這說明我們使用建造者模式成功地將一個復雜對象的構(gòu)造過程解耦，使得同樣的構(gòu)造過程可以創(chuàng)建不同的表示。
原型模式是一種創(chuàng)建型設計模式，它實現(xiàn)了一個原型接口，該接口用于創(chuàng)建當前對象的克隆。當直接創(chuàng)建對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的數(shù)據(jù)庫操作后被創(chuàng)建。
以下是在C#中實現(xiàn)原型模式的一個簡單示例：
// 抽象原型public interface IPrototype{ IPrototype Clone();}// 具體原型public class ConcretePrototype : IPrototype{ public string Name { get; set; } public int Value { get; set; } public IPrototype Clone() { // 實現(xiàn)深拷貝 return (ConcretePrototype)this.MemberwiseClone(); // Clones the concrete object. }}以上代碼定義了一個ConcretePrototype類，它實現(xiàn)了IPrototype接口。接口定義了一個Clone方法，用于復制對象。在ConcretePrototype類中，我們使用了MemberwiseClone方法來創(chuàng)建一個新的克隆對象。
以下是一個使用原型模式的示例：
class Program{ static void Main(string[] args) { ConcretePrototype prototype = new ConcretePrototype(); prototype.Name = "Original"; prototype.Value = 10; Console.WriteLine("Original instance: " + prototype.Name + ", " + prototype.Value); ConcretePrototype clone = (ConcretePrototype)prototype.Clone(); Console.WriteLine("Cloned instance: " + clone.Name + ", " + clone.Value); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個ConcretePrototype對象，并為其屬性賦值，然后我們調(diào)用Clone方法創(chuàng)建了一個新的ConcretePrototype對象。當我們運行這個程序時，會看到原始對象和克隆對象的屬性是相同的，這表明我們已經(jīng)成功地克隆了一個對象。
執(zhí)行流程如下：
創(chuàng)建一個具體的原型對象，為其屬性賦值。調(diào)用原型對象的Clone方法，創(chuàng)建一個新的對象，該對象的屬性與原型對象的屬性相同。打印原型對象和克隆對象的屬性，驗證它們是否相同。結(jié)構(gòu)型模式： 6. 適配器模式（Adapter）1. 橋接模式（Bridge）橋接模式是一種結(jié)構(gòu)型設計模式，用于將抽象部分與其實現(xiàn)部分分離，使它們都可以獨立地變化。
以下是在C#中實現(xiàn)橋接模式的一個簡單示例：
// 實現(xiàn)類接口public interface IImplementor{ void OperationImp();}// 具體實現(xiàn)類Apublic class ConcreteImplementorA : IImplementor{ public void OperationImp() { Console.WriteLine("Concrete Implementor A"); }}// 具體實現(xiàn)類Bpublic class ConcreteImplementorB : IImplementor{ public void OperationImp() { Console.WriteLine("Concrete Implementor B"); }}// 抽象類public abstract class Abstraction{ protected IImplementor implementor; public Abstraction(IImplementor implementor) { this.implementor = implementor; } public virtual void Operation() { implementor.OperationImp(); }}// 擴充的抽象類public class RefinedAbstraction : Abstraction{ public RefinedAbstraction(IImplementor implementor) : base(implementor) { } public override void Operation() { Console.WriteLine("Refined Abstraction is calling implementor"s method:"); base.Operation(); }}在這個代碼中，Abstraction是抽象類，它有一個IImplementor接口的實例，通過這個實例調(diào)用實現(xiàn)類的方法。RefinedAbstraction是擴充的抽象類，它繼承自Abstraction。ConcreteImplementorA和ConcreteImplementorB是實現(xiàn)類，它們實現(xiàn)了IImplementor接口。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { IImplementor implementorA = new ConcreteImplementorA(); Abstraction abstractionA = new RefinedAbstraction(implementorA); abstractionA.Operation(); IImplementor implementorB = new ConcreteImplementorB(); Abstraction abstractionB = new RefinedAbstraction(implementorB); abstractionB.Operation(); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了兩個實現(xiàn)類的實例，然后創(chuàng)建了兩個抽象類的實例，每個抽象類的實例都有一個實現(xiàn)類的實例。當我們調(diào)用抽象類的Operation方法時，它會調(diào)用實現(xiàn)類的OperationImp方法。
執(zhí)行流程如下：
創(chuàng)建實現(xiàn)類的實例。創(chuàng)建抽象類的實例，抽象類的實例有一個實現(xiàn)類的實例。調(diào)用抽象類的Operation方法，該方法會調(diào)用實現(xiàn)類的OperationImp方法。2. 組合模式（Composite）組合模式（Composite pattern）是一種結(jié)構(gòu)型設計模式，它可以使你將對象組合成樹形結(jié)構(gòu)，并且能像使用獨立對象一樣使用它們。這種模式的主要目的是使單個對象和組合對象具有一致性。
以下是在C#中實現(xiàn)組合模式的一個簡單示例：
// 抽象組件類public abstract class Component{ protected string name; public Component(string name) { this.name = name; } public abstract void Add(Component c); public abstract void Remove(Component c); public abstract void Display(int depth);}// 葉節(jié)點類public class Leaf : Component{ public Leaf(string name) : base(name) { } public override void Add(Component c) { Console.WriteLine("Cannot add to a leaf"); } public override void Remove(Component c) { Console.WriteLine("Cannot remove from a leaf"); } public override void Display(int depth) { Console.WriteLine(new String("-", depth) + name); }}// 構(gòu)件容器類public class Composite : Component{ private List _children = new List(); public Composite(string name) : base(name) { } public override void Add(Component component) { _children.Add(component); } public override void Remove(Component component) { _children.Remove(component); } public override void Display(int depth) { Console.WriteLine(new String("-", depth) + name); // 顯示每個節(jié)點的子節(jié)點 foreach (Component component in _children) { component.Display(depth + 2); } }} 在這個代碼中，Component是組件抽象類，它有一個名字，并定義了添加、刪除和顯示操作。Leaf是葉子節(jié)點，它實現(xiàn)了Component的操作。Composite是組件容器，它可以添加、刪除和顯示其子節(jié)點。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { Composite root = new Composite("root"); root.Add(new Leaf("Leaf A")); root.Add(new Leaf("Leaf B")); Composite comp = new Composite("Composite X"); comp.Add(new Leaf("Leaf XA")); comp.Add(new Leaf("Leaf XB")); root.Add(comp); Composite comp2 = new Composite("Composite XY"); comp2.Add(new Leaf("Leaf XYA")); comp2.Add(new Leaf("Leaf XYB")); comp.Add(comp2); root.Add(new Leaf("Leaf C")); // 在組合中添加和刪除 Leaf leaf = new Leaf("Leaf D"); root.Add(leaf); root.Remove(leaf); // 顯示樹形結(jié)構(gòu) root.Display(1); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個根節(jié)點，并在其中添加了兩個葉子節(jié)點。然后我們創(chuàng)建了一個復合節(jié)點，并在其中添加了兩個葉子節(jié)點，然后我們把復合節(jié)點添加到根節(jié)點中。我們還在復合節(jié)點中添加了另一個復合節(jié)點。最后，我們又在根節(jié)點中添加和刪除了一個葉子節(jié)點，然后顯示了樹的結(jié)構(gòu)。
執(zhí)行流程如下：
創(chuàng)建組合和葉子對象。通過調(diào)用組合對象的Add方法將葉子對象和其他組合對象添加到組合對象中。通過調(diào)用組合對象的Remove方法將葉子對象從組合對象中移除。調(diào)用組合對象的Display方法顯示組合對象的結(jié)構(gòu)。3. 裝飾模式（Decorator）裝飾模式是一種結(jié)構(gòu)型設計模式，它允許在運行時動態(tài)地將功能添加到對象中，這種模式提供了比繼承更有彈性的解決方案。
以下是在C#中實現(xiàn)裝飾模式的一個簡單示例：
// 抽象組件public abstract class Component{ public abstract string Operation();}// 具體組件public class ConcreteComponent : Component{ public override string Operation() { return "ConcreteComponent"; }}// 抽象裝飾器public abstract class Decorator : Component{ protected Component component; public Decorator(Component component) { this.component = component; } public override string Operation() { if (component != null) { return component.Operation(); } else { return string.Empty; } }}// 具體裝飾器Apublic class ConcreteDecoratorA : Decorator{ public ConcreteDecoratorA(Component comp) : base(comp) { } public override string Operation() { return $"ConcreteDecoratorA({base.Operation()})"; }}// 具體裝飾器Bpublic class ConcreteDecoratorB : Decorator{ public ConcreteDecoratorB(Component comp) : base(comp) { } public override string Operation() { return $"ConcreteDecoratorB({base.Operation()})"; }}在這個代碼中，Component是一個抽象組件，它定義了一個Operation方法。ConcreteComponent是具體組件，它實現(xiàn)了Component的Operation方法。Decorator是一個抽象裝飾器，它包含一個Component對象，并重寫了Operation方法。ConcreteDecoratorA和ConcreteDecoratorB是具體的裝飾器，它們繼承了Decorator并重寫了Operation方法，以添加新的功能。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { // 基本組件 Component component = new ConcreteComponent(); Console.WriteLine("Basic Component: " + component.Operation()); // 裝飾后的組件 Component decoratorA = new ConcreteDecoratorA(component); Console.WriteLine("A Decorated: " + decoratorA.Operation()); Component decoratorB = new ConcreteDecoratorB(decoratorA); Console.WriteLine("B Decorated: " + decoratorB.Operation()); Console.ReadLine(); }}在這個例子中，我們首先創(chuàng)建了一個ConcreteComponent對象，并調(diào)用它的Operation方法。然后我們創(chuàng)建了一個ConcreteDecoratorA對象，它裝飾了ConcreteComponent，并調(diào)用它的Operation方法。最后，我們創(chuàng)建了一個ConcreteDecoratorB對象，它裝飾了ConcreteDecoratorA，并調(diào)用它的Operation方法。這樣，我們就可以在運行時動態(tài)地添加功能。
執(zhí)行流程如下：
創(chuàng)建一個具體組件對象并調(diào)用其操作。創(chuàng)建一個裝飾器對象，該對象裝飾了具體組件，并調(diào)用其操作。在操作中，裝飾器首先調(diào)用具體組件的操作，然后執(zhí)行額外的操作。創(chuàng)建另一個裝飾器對象，裝飾前一個裝飾器，并調(diào)用其操作。在操作中，這個裝飾器首先調(diào)用前一個裝飾器的操作，然后執(zhí)行額外的操作。4. 外觀模式（Facade）外觀模式是一種結(jié)構(gòu)型設計模式，提供了一個統(tǒng)一的接口，用來訪問子系統(tǒng)中的一群接口。外觀模式定義了一個高層接口，讓子系統(tǒng)更容易使用。
以下是在C#中實現(xiàn)外觀模式的一個簡單示例：
// 子系統(tǒng)Apublic class SubSystemA{ public string OperationA() { return "SubSystemA, OperationA\n"; }}// 子系統(tǒng)Bpublic class SubSystemB{ public string OperationB() { return "SubSystemB, OperationB\n"; }}// 子系統(tǒng)Cpublic class SubSystemC{ public string OperationC() { return "SubSystemC, OperationC\n"; }}// 外觀類public class Facade{ private SubSystemA a = new SubSystemA(); private SubSystemB b = new SubSystemB(); private SubSystemC c = new SubSystemC(); public string OperationWrapper() { string result = "Facade initializes subsystems:\n"; result += a.OperationA(); result += b.OperationB(); result += c.OperationC(); return result; }}在這個代碼中，SubSystemA，SubSystemB和SubSystemC都是子系統(tǒng)，每個子系統(tǒng)都有一個操作。Facade是一個外觀類，它封裝了對子系統(tǒng)的操作，提供了一個統(tǒng)一的接口。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { Facade facade = new Facade(); Console.WriteLine(facade.OperationWrapper()); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個Facade對象，并調(diào)用了它的OperationWrapper方法。這個方法封裝了對子系統(tǒng)的操作，使得客戶端可以不直接操作子系統(tǒng)，而是通過外觀類操作子系統(tǒng)。
執(zhí)行流程如下：
創(chuàng)建一個外觀對象。
通過調(diào)用外觀對象的方法，間接地操作子系統(tǒng)。
子系統(tǒng)的操作被封裝在外觀對象的方法中，客戶端不需要直接操作子系統(tǒng)。
5. 享元模式（Flyweight）享元模式（Flyweight Pattern）是一種結(jié)構(gòu)型設計模式，該模式主要用于減少創(chuàng)建對象的數(shù)量，以減少內(nèi)存占用和提高性能。這種類型的設計模式屬于結(jié)構(gòu)型模式，它提供了一種減少對象數(shù)量從而改善應用所需的對象結(jié)構(gòu)的方式。
以下是在C#中實現(xiàn)享元模式的一個簡單示例：
// 享元類public class Flyweight{ private string intrinsicState; // 構(gòu)造函數(shù) public Flyweight(string intrinsicState) { this.intrinsicState = intrinsicState; } // 業(yè)務方法 public void Operation(string extrinsicState) { Console.WriteLine($"Intrinsic State = {intrinsicState}, Extrinsic State = {extrinsicState}"); }}// 享元工廠類public class FlyweightFactory{ private Dictionary flyweights = new Dictionary(); public Flyweight GetFlyweight(string key) { if (!flyweights.ContainsKey(key)) { flyweights[key] = new Flyweight(key); } return flyweights[key]; } public int GetFlyweightCount() { return flyweights.Count; }} 在這個代碼中，Flyweight是享元類，它有一個內(nèi)在狀態(tài)intrinsicState，這個狀態(tài)是不變的。FlyweightFactory是享元工廠類，它維護了一個享元對象的集合。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { FlyweightFactory factory = new FlyweightFactory(); Flyweight flyweightA = factory.GetFlyweight("A"); flyweightA.Operation("A operation"); Flyweight flyweightB = factory.GetFlyweight("B"); flyweightB.Operation("B operation"); Flyweight flyweightC = factory.GetFlyweight("A"); flyweightC.Operation("C operation"); Console.WriteLine($"Total Flyweights: {factory.GetFlyweightCount()}"); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個FlyweightFactory對象，并通過它創(chuàng)建了兩個享元對象。注意，當我們試圖創(chuàng)建第三個享元對象時，工廠實際上返回了第一個享元對象的引用，因為這兩個對象的內(nèi)在狀態(tài)是相同的。
執(zhí)行流程如下：
創(chuàng)建一個享元工廠對象。通過享元工廠獲取享元對象。如果對象已經(jīng)存在，則返回現(xiàn)有對象；否則，創(chuàng)建新對象。執(zhí)行享元對象的操作。顯示當前享元對象的數(shù)量。6. 代理模式（Proxy）代理模式是一種結(jié)構(gòu)型設計模式，它提供了一個對象代替另一個對象來控制對它的訪問。代理對象可以在客戶端和目標對象之間起到中介的作用，并添加其他的功能。
以下是在C#中實現(xiàn)代理模式的一個簡單示例：
// 抽象主題接口public interface ISubject{ void Request();}// 真實主題public class RealSubject : ISubject{ public void Request() { Console.WriteLine("RealSubject: Handling Request."); }}// 代理public class Proxy : ISubject{ private RealSubject _realSubject; public Proxy(RealSubject realSubject) { this._realSubject = realSubject; } public void Request() { if (this.CheckAccess()) { this._realSubject.Request(); this.LogAccess(); } } public bool CheckAccess() { // 檢查是否有權(quán)限訪問 Console.WriteLine("Proxy: Checking access prior to firing a real request."); return true; } public void LogAccess() { // 記錄請求 Console.WriteLine("Proxy: Logging the time of request."); }}在這個代碼中，ISubject是一個接口，定義了Request方法。RealSubject是實現(xiàn)了ISubject接口的類，Proxy是代理類，它也實現(xiàn)了ISubject接口，并持有一個RealSubject對象的引用。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { Console.WriteLine("Client: Executing the client code with a real subject:"); RealSubject realSubject = new RealSubject(); realSubject.Request(); Console.WriteLine(); Console.WriteLine("Client: Executing the same client code with a proxy:"); Proxy proxy = new Proxy(realSubject); proxy.Request(); Console.ReadLine(); }}在這個例子中，我們首先直接調(diào)用了RealSubject的Request方法，然后我們通過代理調(diào)用了相同的方法。注意，在通過代理調(diào)用Request方法時，代理還執(zhí)行了其他的操作，如檢查訪問權(quán)限和記錄日志。
執(zhí)行流程如下：
創(chuàng)建一個真實主題對象，并直接調(diào)用其Request方法。創(chuàng)建一個代理對象，代理對象包含一個真實主題的引用。通過代理對象調(diào)用Request方法。在這個方法中，代理首先檢查訪問權(quán)限，然后調(diào)用真實主題的Request方法，最后記錄日志。行為型模式： 13. 責任鏈模式（Chain of Responsibility）1. 命令模式（Command）命令模式（Command Pattern）是一種數(shù)據(jù)驅(qū)動的設計模式，它屬于行為型模式。在命令模式中，請求在對象中封裝成為一個操作或行為，這些請求被送到調(diào)用對象，調(diào)用對象尋找可以處理該命令的合適的對象，并把命令直接送達到對應的對象，該對象會執(zhí)行這些命令。
以下是在C#中實現(xiàn)命令模式的一個簡單示例：
// 命令接口public interface ICommand{ void Execute();}// 具體命令類public class ConcreteCommand : ICommand{ private Receiver receiver; public ConcreteCommand(Receiver receiver) { this.receiver = receiver; } public void Execute() { receiver.Action(); }}// 接收者類public class Receiver{ public void Action() { Console.WriteLine("Receiver performs an action"); }}// 調(diào)用者或發(fā)送者類public class Invoker{ private ICommand command; public void SetCommand(ICommand command) { this.command = command; } public void ExecuteCommand() { command.Execute(); }}在這個代碼中，ICommand是命令接口，定義了Execute方法。ConcreteCommand是具體的命令類，它實現(xiàn)了ICommand接口，并持有一個Receiver對象的引用。Invoker是調(diào)用者或發(fā)送者類，它持有一個ICommand對象的引用，并可以通過SetCommand方法設置命令，通過ExecuteCommand方法執(zhí)行命令。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { Receiver receiver = new Receiver(); ICommand command = new ConcreteCommand(receiver); Invoker invoker = new Invoker(); invoker.SetCommand(command); invoker.ExecuteCommand(); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個Receiver對象、一個ConcreteCommand對象和一個Invoker對象。然后我們通過Invoker的SetCommand方法設置了命令，并通過ExecuteCommand方法執(zhí)行了命令。
執(zhí)行流程如下：
創(chuàng)建一個接收者對象。創(chuàng)建一個具體命令對象，并將接收者對象傳遞給它。創(chuàng)建一個調(diào)用者或發(fā)送者對象。通過調(diào)用者對象的SetCommand方法設置命令。通過調(diào)用者對象的ExecuteCommand方法執(zhí)行命令。2. 解釋器模式（Interpreter）解釋器模式（Interpreter Pattern）是一種行為型設計模式，用于解決一些固定語法格式的需求。它定義了如何在語言中表示和解析語法。
以下是在C#中實現(xiàn)解釋器模式的一個簡單示例：
// 抽象表達式public interface IExpression{ bool Interpret(string context);}// 終結(jié)符表達式public class TerminalExpression : IExpression{ private string data; public TerminalExpression(string data) { this.data = data; } public bool Interpret(string context) { if (context.Contains(data)) { return true; } return false; }}// 非終結(jié)符表達式public class OrExpression : IExpression{ private IExpression expr1 = null; private IExpression expr2 = null; public OrExpression(IExpression expr1, IExpression expr2) { this.expr1 = expr1; this.expr2 = expr2; } public bool Interpret(string context) { return expr1.Interpret(context) || expr2.Interpret(context); }}在這個代碼中，IExpression是抽象表達式，定義了Interpret方法。TerminalExpression是終結(jié)符表達式，它實現(xiàn)了IExpression接口。OrExpression是非終結(jié)符表達式，它也實現(xiàn)了IExpression接口。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { IExpression isMale = GetMaleExpression(); IExpression isMarriedWoman = GetMarriedWomanExpression(); Console.WriteLine($"John is male? {isMale.Interpret("John")}"); Console.WriteLine($"Julie is a married women? {isMarriedWoman.Interpret("Married Julie")}"); Console.ReadLine(); } // 規(guī)則：Robert 和 John 是男性 public static IExpression GetMaleExpression() { IExpression robert = new TerminalExpression("Robert"); IExpression john = new TerminalExpression("John"); return new OrExpression(robert, john); } // 規(guī)則：Julie 是一個已婚的女性 public static IExpression GetMarriedWomanExpression() { IExpression julie = new TerminalExpression("Julie"); IExpression married = new TerminalExpression("Married"); return new OrExpression(julie, married); }}在這個例子中，我們定義了兩個規(guī)則，"Robert和John是男性"和"Julie是一個已婚的女性"。我們?nèi)缓髣?chuàng)建了兩個表達式對象，分別表示這兩個規(guī)則，并使用這兩個對象來解析輸入。
執(zhí)行流程如下：
創(chuàng)建終結(jié)符表達式對象和非終結(jié)符表達式對象，用于表示規(guī)則。調(diào)用表達式對象的Interpret方法，解析輸入的字符串。輸出解析結(jié)果。3. 迭代器模式（Iterator）迭代器模式（Iterator Pattern）是一種行為型設計模式，它提供了一種方法來訪問一個對象的元素，而不需要暴露該對象的內(nèi)部表示。以下是在C#中實現(xiàn)迭代器模式的一個簡單示例：
// 抽象聚合類public interface IAggregate{ IIterator CreateIterator(); void Add(string item); int Count { get; } string this[int index] { get; set; }}// 具體聚合類public class ConcreteAggregate : IAggregate{ private List items = new List(); public IIterator CreateIterator() { return new ConcreteIterator(this); } public int Count { get { return items.Count; } } public string this[int index] { get { return items[index]; } set { items.Insert(index, value); } } public void Add(string item) { items.Add(item); }}// 抽象迭代器public interface IIterator{ string First(); string Next(); bool IsDone { get; } string CurrentItem { get; }}// 具體迭代器public class ConcreteIterator : IIterator{ private ConcreteAggregate aggregate; private int current = 0; public ConcreteIterator(ConcreteAggregate aggregate) { this.aggregate = aggregate; } public string First() { return aggregate[0]; } public string Next() { string ret = null; if (current < aggregate.Count - 1) { ret = aggregate[++current]; } return ret; } public string CurrentItem { get { return aggregate[current]; } } public bool IsDone { get { return current >= aggregate.Count; } }} 在這個代碼中，IAggregate是抽象聚合類，定義了CreateIterator等方法，ConcreteAggregate是具體聚合類，實現(xiàn)了IAggregate接口。IIterator是抽象迭代器，定義了First、Next等方法，ConcreteIterator是具體迭代器，實現(xiàn)了IIterator接口。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { IAggregate aggregate = new ConcreteAggregate(); aggregate.Add("Item A"); aggregate.Add("Item B"); aggregate.Add("Item C"); aggregate.Add("Item D"); IIterator iterator = aggregate.CreateIterator(); Console.WriteLine("Iterating over collection:"); string item = iterator.First(); while (item != null) { Console.WriteLine(item); item = iterator.Next(); } Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個ConcreteAggregate對象，并添加了幾個元素。然后我們通過CreateIterator方法創(chuàng)建了一個迭代器，并使用這個迭代器遍歷了集合中的所有元素。
執(zhí)行流程如下：
創(chuàng)建一個聚合對象，并添加一些元素。通過聚合對象的CreateIterator方法創(chuàng)建一個迭代器。通過迭代器的First方法獲取第一個元素，然后通過Next方法獲取后續(xù)的元素，直到獲取不到元素為止。4. 中介者模式（Mediator）中介者模式是一種行為設計模式，它讓你能減少一組對象之間復雜的通信。它提供了一個中介者對象，此對象負責在組中的對象之間進行通信，而不是這些對象直接進行通信。
首先，讓我們定義一個中介者接口和一個具體的中介者：
// Mediator 接口聲明了與組件交互的方法。public interface IMediator{ void Notify(object sender, string ev);}// 具體 Mediators 實現(xiàn)協(xié)作行為，它負責協(xié)調(diào)多個組件。public class ConcreteMediator : IMediator{ private Component1 _component1; private Component2 _component2; public ConcreteMediator(Component1 component1, Component2 component2) { _component1 = component1; _component1.SetMediator(this); _component2 = component2; _component2.SetMediator(this); } public void Notify(object sender, string ev) { if (ev == "A") { Console.WriteLine("Mediator reacts on A and triggers following operations:"); this._component2.DoC(); } if (ev == "D") { Console.WriteLine("Mediator reacts on D and triggers following operations:"); this._component1.DoB(); this._component2.DoC(); } }}接著，我們定義一個基礎組件類和兩個具體組件：
public abstract class BaseComponent{ protected IMediator _mediator; public BaseComponent(IMediator mediator = null) { _mediator = mediator; } public void SetMediator(IMediator mediator) { this._mediator = mediator; }}// 具體 Components 實現(xiàn)各種功能。它們不依賴于其他組件。// 它們也不依賴于任何具體 Mediator 類。public class Component1 : BaseComponent{ public void DoA() { Console.WriteLine("Component 1 does A."); this._mediator.Notify(this, "A"); } public void DoB() { Console.WriteLine("Component 1 does B."); this._mediator.Notify(this, "B"); }}public class Component2 : BaseComponent{ public void DoC() { Console.WriteLine("Component 2 does C."); this._mediator.Notify(this, "C"); } public void DoD() { Console.WriteLine("Component 2 does D."); this._mediator.Notify(this, "D"); }}最后，我們來創(chuàng)建一個客戶端代碼：
class Program{ static void Main(string[] args) { // The client code. Component1 component1 = new Component1(); Component2 component2 = new Component2(); new ConcreteMediator(component1, component2); Console.WriteLine("Client triggers operation A."); component1.DoA(); Console.WriteLine(); Console.WriteLine("Client triggers operation D."); component2.DoD(); }}這個示例中的各個組件通過中介者來進行通信，而不是直接通信，這樣就可以減少組件之間的依賴性，使得它們可以更容易地被獨立修改。當一個組件發(fā)生某個事件（例如"Component 1 does A"）時，它會通過中介者來通知其他組件，這樣其他組件就可以根據(jù)這個事件來做出響應（例如"Component 2 does C"）。
5. 備忘錄模式（Memento）備忘錄模式是一種行為設計模式，它能保存對象的狀態(tài)，以便在后面可以恢復它。在大多數(shù)情況下，這種模式可以讓你在不破壞對象封裝的前提下，保存和恢復對象的歷史狀態(tài)。
以下是一個簡單的備忘錄模式的實現(xiàn)，其中有三個主要的類：Originator（保存了一個重要的狀態(tài)，這個狀態(tài)可能會隨著時間改變），Memento（保存了Originator的一個快照，這個快照包含了Originator的狀態(tài)），以及Caretaker（負責保存Memento）。
// Originator 類可以生成一個備忘錄，并且可以通過備忘錄恢復其狀態(tài)。public class Originator{ private string _state; public Originator(string state) { this._state = state; Console.WriteLine($"Originator: My initial state is: {_state}"); } public void DoSomething() { Console.WriteLine("Originator: I"m doing something important."); _state = GenerateRandomString(30); Console.WriteLine($"Originator: and my state has changed to: {_state}"); } private string GenerateRandomString(int length = 10) { string allowedSymbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; string result = string.Empty; while (length > 0) { result += allowedSymbols[new Random().Next(0, allowedSymbols.Length)]; length--; } return result; } public IMemento Save() { return new ConcreteMemento(_state); } public void Restore(IMemento memento) { _state = memento.GetState(); Console.WriteLine($"Originator: My state has changed to: {_state}"); }}// 備忘錄接口提供了獲取備忘錄和原發(fā)器狀態(tài)的方法。但在該接口中并未聲明所有的方法，一些方法只在原發(fā)器中聲明。public interface IMemento{ string GetName(); string GetState(); DateTime GetDate();}// Concrete Memento 存儲原發(fā)器狀態(tài)，并通過原發(fā)器實現(xiàn)備份。備忘錄是不可變的，因此，沒有 set 方法。public class ConcreteMemento : IMemento{ private string _state; private DateTime _date; public ConcreteMemento(string state) { _state = state; _date = DateTime.Now; } public string GetState() { return _state; } public string GetName() { return $"{_date} / ({_state.Substring(0, 9)})..."; } public DateTime GetDate() { return _date; }}// Caretaker 不依賴于具體備忘錄類。結(jié)果，它不會有任何訪問原發(fā)器狀態(tài)的權(quán)利，它只能獲取備忘錄的元數(shù)據(jù)。public class Caretaker{ private List _mementos = new List(); private Originator _originator = null; public Caretaker(Originator originator) { this._originator = originator; } public void Backup() { Console.WriteLine("\nCaretaker: Saving Originator"s state..."); _mementos.Add(_originator.Save()); } public void Undo() { if (_mementos.Count == 0) { return; } var memento = _mementos.Last(); _mementos.Remove(memento); Console.WriteLine("Caretaker: Restoring state to: " + memento.GetName()); try { _originator.Restore(memento); } catch (Exception) { Undo(); } } public void ShowHistory() { Console.WriteLine("Caretaker: Here"s the list of mementos:"); foreach (var memento in _mementos) { Console.WriteLine(memento.GetName()); } }}// 客戶端代碼class Program{ static void Main(string[] args) { Originator originator = new Originator("Super-duper-super-puper-super."); Caretaker caretaker = new Caretaker(originator); caretaker.Backup(); originator.DoSomething(); caretaker.Backup(); originator.DoSomething(); caretaker.Backup(); originator.DoSomething(); Console.WriteLine(); caretaker.ShowHistory(); Console.WriteLine("\nClient: Now, let"s rollback!\n"); caretaker.Undo(); Console.WriteLine("\nClient: Once more!\n"); caretaker.Undo(); }} 以上的代碼中，Originator 持有一些重要的狀態(tài)，并且提供了方法去保存它的狀態(tài)到一個備忘錄對象以及從備忘錄對象中恢復它的狀態(tài)。Caretaker 負責保存?zhèn)渫洠撬荒懿僮鱾渫泴ο笾械臓顟B(tài)。當用戶執(zhí)行操作時，我們先保存當前的狀態(tài)，然后執(zhí)行操作。如果用戶后來不滿意新的狀態(tài)，他們可以方便地從舊的備忘錄中恢復狀態(tài)。
6. 觀察者模式（Observer）觀察者模式（Observer Pattern）是一種行為型設計模式，當一個對象的狀態(tài)發(fā)生變化時，依賴它的所有對象都會得到通知并被自動更新。以下是在C#中實現(xiàn)觀察者模式的一個簡單示例：
// 抽象觀察者public interface IObserver{ void Update();}// 具體觀察者public class ConcreteObserver : IObserver{ private string name; public ConcreteObserver(string name) { this.name = name; } public void Update() { Console.WriteLine($"{name} received an update!"); }}// 抽象主題public interface ISubject{ void RegisterObserver(IObserver observer); void RemoveObserver(IObserver observer); void NotifyObservers();}// 具體主題public class ConcreteSubject : ISubject{ private List observers = new List(); public void RegisterObserver(IObserver observer) { observers.Add(observer); } public void RemoveObserver(IObserver observer) { if (observers.Contains(observer)) { observers.Remove(observer); } } public void NotifyObservers() { foreach (var observer in observers) { observer.Update(); } } public void ChangeState() { // 觸發(fā)狀態(tài)變化，通知所有觀察者 NotifyObservers(); }} 在這個代碼中，IObserver是抽象觀察者，定義了Update方法，ConcreteObserver是具體觀察者，實現(xiàn)了IObserver接口。ISubject是抽象主題，定義了RegisterObserver、RemoveObserver和NotifyObservers方法，ConcreteSubject是具體主題，實現(xiàn)了ISubject接口。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { ConcreteSubject subject = new ConcreteSubject(); subject.RegisterObserver(new ConcreteObserver("Observer 1")); subject.RegisterObserver(new ConcreteObserver("Observer 2")); subject.RegisterObserver(new ConcreteObserver("Observer 3")); subject.ChangeState(); Console.ReadLine(); }}在這個例子中，我們創(chuàng)建了一個ConcreteSubject對象，并注冊了三個觀察者。然后我們通過ChangeState方法改變了主題的狀態(tài)，這會觸發(fā)主題通知所有觀察者。
執(zhí)行流程如下：
創(chuàng)建一個具體主題對象。創(chuàng)建幾個具體觀察者對象，并通過主題的RegisterObserver方法將這些觀察者注冊到主題中。通過主題的ChangeState方法改變主題的狀態(tài)，這會觸發(fā)主題通知所有觀察者。7. 狀態(tài)模式（State）狀態(tài)模式在面向?qū)ο缶幊讨校且环N允許對象在其內(nèi)部狀態(tài)改變時改變其行為的設計模式。這種類型的設計模式屬于行為型模式。在狀態(tài)模式中，我們創(chuàng)建對象表示各種狀態(tài)，以及一個行為隨狀態(tài)改變而改變的上下文對象。
以下是一個狀態(tài)模式的示例。這個示例中，我們將創(chuàng)建一個銀行賬戶，它有兩個狀態(tài)：正常狀態(tài)（NormalState）和透支狀態(tài)（OverdrawnState）。當用戶執(zhí)行操作（存款和取款）時，賬戶狀態(tài)將相應地進行更改。
首先，我們定義一個表示狀態(tài)的接口：
public interface IAccountState{ void Deposit(Action addToBalance); void Withdraw(Action subtractFromBalance); void ComputeInterest();}然后，我們創(chuàng)建兩個表示具體狀態(tài)的類：
public class NormalState : IAccountState{ public void Deposit(Action addToBalance) { addToBalance(); Console.WriteLine("Deposit in NormalState"); } public void Withdraw(Action subtractFromBalance) { subtractFromBalance(); Console.WriteLine("Withdraw in NormalState"); } public void ComputeInterest() { Console.WriteLine("Interest computed in NormalState"); }}public class OverdrawnState : IAccountState{ public void Deposit(Action addToBalance) { addToBalance(); Console.WriteLine("Deposit in OverdrawnState"); } public void Withdraw(Action subtractFromBalance) { Console.WriteLine("No withdraw in OverdrawnState"); } public void ComputeInterest() { Console.WriteLine("Interest and fees computed in OverdrawnState"); }}然后，我們創(chuàng)建一個Context類，它使用這些狀態(tài)來執(zhí)行其任務：
public class BankAccount{ private IAccountState _state; private double _balance; public BankAccount(IAccountState state) { _state = state; _balance = 0; } public void Deposit(double amount) { _state.Deposit(() => _balance += amount); StateChangeCheck(); } public void Withdraw(double amount) { _state.Withdraw(() => _balance -= amount); StateChangeCheck(); } public void ComputeInterest() { _state.ComputeInterest(); } private void StateChangeCheck() { if (_balance < 0.0) _state = new OverdrawnState(); else _state = new NormalState(); }}現(xiàn)在，你可以創(chuàng)建一個實例并運行一個Demo來測試這個狀態(tài)模式的代碼：
public class Program{ public static void Main(string[] args) { var account = new BankAccount(new NormalState()); account.Deposit(1000); // Deposit in NormalState account.Withdraw(2000); // Withdraw in NormalState; No withdraw in OverdrawnState account.Deposit(100); // Deposit in OverdrawnState account.ComputeInterest(); // Interest and fees computed in OverdrawnState Console.ReadKey(); }}這個程序首先在正常狀態(tài)下進行存款操作，然后嘗試進行取款操作。由于取款金額超過賬戶余額，所以賬戶進入透支狀態(tài)，并阻止進一步的取款操作。但存款仍然被允許，以使賬戶回歸到正常狀態(tài)。計算利息的行為也根據(jù)賬戶的狀態(tài)變化而變化。
8. 策略模式（Strategy）策略模式定義了一系列的算法，并將每一個算法封裝起來，使得它們可以相互替換。策略模式讓算法獨立于使用它的客戶而獨立變化。
以下是一個簡單的策略模式的C#實現(xiàn)。這個例子中，我們將創(chuàng)建一個排序策略，比如快速排序和冒泡排序，它們實現(xiàn)同一個接口，然后創(chuàng)建一個Context類，它使用這些策略來執(zhí)行排序操作。
首先，我們定義一個表示排序策略的接口：
public interface ISortStrategy{ void Sort(List list);} 然后，我們創(chuàng)建兩個表示具體策略的類：
public class QuickSort : ISortStrategy{ public void Sort(List list) { list.Sort(); // Quick sort is in-place but here we are using built-in method Console.WriteLine("QuickSorted list "); }}public class BubbleSort : ISortStrategy{ public void Sort(List list) { int n = list.Count; for (int i = 0; i < n - 1; i++) for (int j = 0; j < n - i - 1; j++) if (list[j] > list[j + 1]) { // swap temp and list[i] int temp = list[j]; list[j] = list[j + 1]; list[j + 1] = temp; } Console.WriteLine("BubbleSorted list "); }} 然后，我們創(chuàng)建一個Context類，它使用這些策略來執(zhí)行其任務：
public class SortedList{ private List _list = new List(); private ISortStrategy _sortstrategy; public void SetSortStrategy(ISortStrategy sortstrategy) { this._sortstrategy = sortstrategy; } public void Add(int num) { _list.Add(num); } public void Sort() { _sortstrategy.Sort(_list); // Print sorted list foreach (int num in _list) { Console.Write(num + " "); } Console.WriteLine(); }} 現(xiàn)在，你可以創(chuàng)建一個實例并運行一個Demo來測試這個策略模式的代碼：
public class Program{ public static void Main(string[] args) { SortedList sortedList = new SortedList(); sortedList.Add(1); sortedList.Add(5); sortedList.Add(3); sortedList.Add(4); sortedList.Add(2); sortedList.SetSortStrategy(new QuickSort()); sortedList.Sort(); // Output: QuickSorted list 1 2 3 4 5 sortedList.SetSortStrategy(new BubbleSort()); sortedList.Sort(); // Output: BubbleSorted list 1 2 3 4 5 Console.ReadKey(); }}這個程序首先創(chuàng)建了一個未排序的列表，然后它首先使用快速排序策略進行排序，接著又使用冒泡排序策略進行排序。
9. 模板方法模式（Template Method）模板方法模式定義了一個操作中算法的骨架，將這些步驟延遲到子類中。模板方法使得子類可以不改變算法的結(jié)構(gòu)即可重定義該算法的某些特定步驟。
以下是一個模板方法模式的示例。這個示例中，我們將創(chuàng)建一個烹飪食物的過程，這個過程有一些固定的步驟（例如準備材料，清理），但是具體的烹飪步驟則取決于具體的食物。
首先，我們定義一個抽象的模板類：
public abstract class CookingProcedure{ // The "Template method" public void PrepareDish() { PrepareIngredients(); Cook(); CleanUp(); } public void PrepareIngredients() { Console.WriteLine("Preparing the ingredients..."); } // These methods will be overridden by subclasses public abstract void Cook(); public void CleanUp() { Console.WriteLine("Cleaning up..."); }}然后，我們創(chuàng)建兩個具體的子類，它們分別實現(xiàn)了具體的烹飪步驟：
public class CookPasta : CookingProcedure{ public override void Cook() { Console.WriteLine("Cooking pasta..."); }}public class BakeCake : CookingProcedure{ public override void Cook() { Console.WriteLine("Baking cake..."); }}現(xiàn)在，你可以創(chuàng)建一個實例并運行一個Demo來測試這個模板方法模式的代碼：
public class Program{ public static void Main(string[] args) { CookingProcedure cookingProcedure = new CookPasta(); cookingProcedure.PrepareDish(); Console.WriteLine(); cookingProcedure = new BakeCake(); cookingProcedure.PrepareDish(); Console.ReadKey(); }}在這個程序中，我們首先創(chuàng)建了一個CookPasta對象，然后調(diào)用其PrepareDish方法。然后，我們創(chuàng)建了一個BakeCake對象，再次調(diào)用其PrepareDish方法。這兩個對象雖然具有不同的Cook方法，但是它們的PrepareDish方法的結(jié)構(gòu)（即算法的骨架）是相同的。
訪問者模式（Visitor Pattern）是一種將算法與對象結(jié)構(gòu)分離的軟件設計模式。這種模式的基本想法就是通過所謂的"訪問者"來改變元素的操作。這樣一來，元素的類可以用于表示元素結(jié)構(gòu)，而具體的操作則可以在訪問者類中定義。
以下是一個使用C#實現(xiàn)的訪問者模式示例，包括了詳細的注釋和執(zhí)行流程。
這個示例中有三個主要部分：訪問者（IVisitor）、可訪問元素（IElement）和元素結(jié)構(gòu)（ObjectStructure）。同時有具體訪問者（ConcreteVisitor）和具體元素（ConcreteElement）。
// 訪問者接口public interface IVisitor{ void VisitConcreteElementA(ConcreteElementA concreteElementA); void VisitConcreteElementB(ConcreteElementB concreteElementB);}// 具體訪問者Apublic class ConcreteVisitorA : IVisitor{ public void VisitConcreteElementA(ConcreteElementA concreteElementA) { Console.WriteLine($"{concreteElementA.GetType().Name} is being visited by {this.GetType().Name}"); } public void VisitConcreteElementB(ConcreteElementB concreteElementB) { Console.WriteLine($"{concreteElementB.GetType().Name} is being visited by {this.GetType().Name}"); }}// 具體訪問者Bpublic class ConcreteVisitorB : IVisitor{ public void VisitConcreteElementA(ConcreteElementA concreteElementA) { Console.WriteLine($"{concreteElementA.GetType().Name} is being visited by {this.GetType().Name}"); } public void VisitConcreteElementB(ConcreteElementB concreteElementB) { Console.WriteLine($"{concreteElementB.GetType().Name} is being visited by {this.GetType().Name}"); }}// 元素接口public interface IElement{ void Accept(IVisitor visitor);}// 具體元素Apublic class ConcreteElementA : IElement{ public void Accept(IVisitor visitor) { visitor.VisitConcreteElementA(this); }}// 具體元素Bpublic class ConcreteElementB : IElement{ public void Accept(IVisitor visitor) { visitor.VisitConcreteElementB(this); }}// 對象結(jié)構(gòu)public class ObjectStructure{ private List _elements = new List(); public void Attach(IElement element) { _elements.Add(element); } public void Detach(IElement element) { _elements.Remove(element); } public void Accept(IVisitor visitor) { foreach (var element in _elements) { element.Accept(visitor); } }} 執(zhí)行流程如下：
創(chuàng)建具體元素ConcreteElementA和ConcreteElementB的實例。創(chuàng)建對象結(jié)構(gòu)ObjectStructure的實例，并將步驟1創(chuàng)建的具體元素添加到對象結(jié)構(gòu)中。創(chuàng)建具體訪問者ConcreteVisitorA和ConcreteVisitorB的實例。調(diào)用對象結(jié)構(gòu)的Accept方法，傳入步驟3創(chuàng)建的具體訪問者，使具體訪問者訪問對象結(jié)構(gòu)中的所有元素。以下是一個使用上述代碼的示例：
public class Program{ public static void Main() { ObjectStructure objectStructure = new ObjectStructure(); objectStructure.Attach(new ConcreteElementA()); objectStructure.Attach(new ConcreteElementB()); ConcreteVisitorA visitorA = new ConcreteVisitorA(); ConcreteVisitorB visitorB = new ConcreteVisitorB(); objectStructure.Accept(visitorA); objectStructure.Accept(visitorB); Console.ReadKey(); }}這個程序會打印出訪問者A和訪問者B分別訪問具體元素A和具體元素B的信息。
技術交流.NET Core交流群：737776595
來自token的分享
標簽：
推薦
-
-
-
-
-
-
-
-
-
-
-
全球報道:收評：指數(shù)走勢分化創(chuàng)指跌1.39% 景點及旅游漲幅居前
收評：指數(shù)走勢分化創(chuàng)指跌1 39%景點及旅游漲幅居前---中國經(jīng)濟網(wǎng)北京6
來源： -
-
環(huán)球播報:中經(jīng)資料：巴基斯坦證券市場一周回顧(2023.5.29-6.2)
中經(jīng)資料：巴基斯坦證券市場一周回顧(2023 5 29-6 2)---1 巴基斯坦國家
來源： -
-
-
-
-
-
-
-
-
-
北通阿修羅2刷機（北通阿修羅2pro恢復出廠設置）
每日小編都會為大家?guī)硪恍┲R類的文章，那么為大家?guī)淼氖潜蓖ò⑿?/p>
來源： -
-
-
半藏森林克隆人暫下線 此前小冰公司推出“GPT克隆人計劃”|環(huán)球熱門
近日有網(wǎng)友發(fā)現(xiàn)，虛擬人休閑娛樂平臺XEva下架了網(wǎng)紅“半藏森林”等AI克
來源： -
-
-
-
-
-
世界最資訊丨聚焦新形勢新要求 多方共話互聯(lián)網(wǎng)發(fā)展新篇章
聚焦新形勢新要求多方共話互聯(lián)網(wǎng)發(fā)展新篇章---人民網(wǎng)北京6月5日電（記
來源： -
-
-
-
-
-
-
-
-
-
-
電腦網(wǎng)頁打不開怎么回事？電腦網(wǎng)頁怎么清理緩存？
電腦網(wǎng)頁打不開怎么回事？1、首先打開電腦，點擊電腦左下角的開始菜單。2、在彈出的界面中找到windows系...
來源： -
-
-
-
-
-
-
-
-
-
-
-
如何調(diào)節(jié)電腦屏幕亮度？電腦屏幕保護怎么取消？
如何調(diào)節(jié)電腦屏幕亮度1、鼠標放在桌面電源圖標上方，右擊鼠標，選擇Windows移動中心。2、在彈出的對話框...
來源：
財富更多》
-
全國“三夏”大規(guī)模小麥機收全面展開|每日焦點
全國“三夏”大規(guī)模小麥機收全面展開---...
-
專家：我國胃癌診療水平穩(wěn)步提升
專家：我國胃癌診療水平穩(wěn)步提升---近日...
-
當前視點！兩部門：開展“春雨潤苗”專項行動 助力小微經(jīng)營主體發(fā)展
兩部門：開展“春雨潤苗”專項行動助力...
-
全球報道:收評：指數(shù)走勢分化創(chuàng)指跌1.39% 景點及旅游漲幅居前
收評：指數(shù)走勢分化創(chuàng)指跌1 39%景點及...
-
環(huán)球播報:中經(jīng)資料：巴基斯坦證券市場一周回顧(2023.5.29-6.2)
中經(jīng)資料：巴基斯坦證券市場一周回顧(20...
動態(tài)更多》
熱點
- realme10系列正式宣布 采用雙曲面屏正面頂部居中挖孔
- 五菱全新微型電動車內(nèi)飾官圖發(fā)布 座椅采用星際形打孔工藝
- 努比亞Z40星空典藏版正式開售 采用微米級油畫筆觸紋理技術
- iQOO11系列正式官宣 首批搭載驍龍8Gen2機型之一
- 海信34英寸帶魚屏顯示器發(fā)布 支持165Hz刷新率
- OPPO明年將商用240W超級閃充 新一代電芯支持更高倍率充電
- 第一款Android手機渲染圖曝光 橫向滑蓋設計和全尺寸鍵盤
- 吉利首款純電皮卡11月9日上市 車輛續(xù)航里程超過610公里
- 努比亞Z40SPro星空典藏版正式公布 堪稱窄邊框天花板
- vivo無線運動耳機2今日正式上市 首銷只要119元
- 最高檢：截至2022年底全國共辦理生態(tài)環(huán)境和資源保護公益訴訟案件40余萬件
- 電腦屏保時間怎么設置？電腦屏保后無法喚醒怎么辦？
- 筆記本屏幕亮度怎么調(diào)？筆記本屏幕的灰塵怎么清理？
- 志愿星光點亮社區(qū)“微治理”-焦點速遞
- 電腦防火墻在哪里設置？電腦防火墻怎么全部關閉？
- 電腦護眼模式怎么設置？電腦護眼模式真的護眼嗎？
- 瑞幸開出第一萬家店，咖啡殺到9.9元時代
- 電腦開機密碼怎么取消？電腦開機密碼鎖住了怎么解鎖？
- windows7一鍵還原在哪？windows7的設置在哪里找？
- 錦華新材掛牌新三板
- 無線路由器怎么連接？無線路由器怎么連接無線網(wǎng)絡？
- 藍牙耳機怎么連接電腦？藍牙耳機充不進去電怎么辦？
- 谷歌推設計神器“StyleDrop”，給一張圖就能復刻作品風格-天天訊息
- 電腦設備管理器在哪？電腦設備管理器顯卡在哪兒？
- 多地對網(wǎng)約車按下“暫停鍵”|世界最資訊
- 香腸太陽曬干好還是烘干好_香腸是太陽曬干好還是陰干好_全球最新
- 手機第一次充電要充多久？手機充電突然變慢是怎么回事？
- 北美票房：《蜘蛛俠：縱橫宇宙》登頂周末票房，《小美人魚》《柜魔》分居二三-當前觀點
- 電腦垃圾怎么清理?電腦垃圾多了怎么清理電腦？
- 比亞迪海洋網(wǎng)車型5月銷量達102572輛 世界熱訊
- 2023年“全國科技工作者日”法律服務系列活動啟動
- 蘋果怎么換自定義圖標?蘋果手機突然黑屏打不開怎么辦?
- 寧德時代回應供貨變動傳聞：與客戶戰(zhàn)略合作關系沒有發(fā)生變化 要聞
- 蘋果電腦沒聲音按哪個鍵恢復?蘋果電腦怎么切換系統(tǒng)?
- 香腸派對怎么添加好友？香腸派對的糖果怎么免費獲得?
- 抖音為什么要出極速版？抖音極速版和抖音有什么區(qū)別？
- 小雅智能音箱怎么使用？小雅智能音箱怎么連接手機？
- 蘋果手機下載軟件密碼忘了怎么辦？蘋果手機軟件更新不了怎么辦？
- 當前資訊!在家也能復刻的廣式腸粉，秘訣全在這個洲星腸粉粉
- 耳機插電腦上沒聲音怎么設置？耳機沒有聲音是怎么回事？
- 黎明覺醒河豚怎么釣？黎明覺醒的安全繩怎么放？
- 蘋果11快充傷電池嗎？蘋果11快充需要多長時間？
- 陳喬恩游日本，在大阪機場和老公Alan會合撒嬌，又親又抱甜如初戀-每日頭條
- 手提電腦開不了機怎么辦？筆記本電腦開機進不了系統(tǒng)怎么辦?
- 電腦管家有必要裝嗎？電腦管家是電腦自帶的嗎？
- qq音樂一起聽歌怎么用？qq音樂會員怎么取消自動續(xù)費？
- 平板怎么清理內(nèi)存垃圾？平板電腦的操作系統(tǒng)有哪些？
- qq聊天記錄怎么發(fā)給別人？qq聊天記錄的視頻在哪個文件夾？
- 順利交付！神十五航天員帶回了20多公斤實驗樣品_焦點速看
- 鍵盤沒有反應是怎么回事？電腦鍵盤失靈怎么解決？
- 朋友圈內(nèi)容太多怎么刪除？微信朋友圈可以看訪客記錄嗎？
- 阿里元境總經(jīng)理王矛：AI加持，元宇宙將為內(nèi)容創(chuàng)作降本提效 | 最前線-當前關注
- 電話加入黑名單后還能收到信息嗎？電話黑名單發(fā)信息能收到嗎？
- 【熱聞】西門子醫(yī)療在德國福希海姆建設新工廠，預計創(chuàng)造100個工作崗位
- 每日焦點！午評：創(chuàng)業(yè)板指跌1.48% 景點及旅游、傳媒板塊活躍
- 筆記本鍵帽可以扣下來嗎？筆記本鍵帽能直接掰下來嗎？
- 未來十天西南地區(qū)東部等地多降雨 華南地區(qū)高溫天氣將緩解
- 北海康成邁芮倍獲準上市，治療ALGS膽汁淤積性瘙癢
- 陜西扶風：“云端”綻放就業(yè)夢-每日時訊
- 打游戲用什么軸的機械鍵盤？機械鍵盤按鍵失靈怎么修？
- 快手家居數(shù)據(jù)行業(yè)迎618爆發(fā) 前三天GMV同比去年增長超139% 天天熱文
- 騰訊視頻可以掃碼登錄嗎？騰訊視頻可以登錄幾個設備？
- 杭州部分小區(qū)房價跌回2017年 跌了但還是賣不出去？！
- 雞蛋便宜了！未來價格怎么走？ 每日視訊
- 怎么找回清空微信聊天記錄？微信聊天記錄怎么備份？
- 六五環(huán)境日·手繪海報|挑剔的TA們，為何偏愛山東？ 世界熱點評
- 屏幕上的圓圈怎樣取消？手機屏幕失靈點不動怎么辦？
- win10網(wǎng)絡連接不見了？win10網(wǎng)絡類型在哪里設置？
- 教育部：加強實驗教學，將實驗操作納入中考
- 手機上怎么登錄官網(wǎng)？手機官網(wǎng)的手機是正品嗎？
- ipad屏幕變暗了怎么恢復？ipad屏幕旋轉(zhuǎn)怎么設置？
- 仙佑膏藥：互聯(lián)網(wǎng)+膏藥產(chǎn)業(yè)：電商與移動互聯(lián)網(wǎng)跨界融合
- 今年云夢2863人參加高考 快播報
- 我區(qū)發(fā)布總部經(jīng)濟高質(zhì)量發(fā)展實施意見_最新
- 越“聰明”的代碼，越是“一次性” 全球播資訊
- 加盟店負增長凈利潤連年大降，海瀾之家請張頌文能否破解“老化”難題_環(huán)球要聞 今日聚焦
- 每日視訊：重啟天涯第一步失敗！7 × 24 小時直播，僅募集 14.99 萬元！投資人潘海東：天涯已被時代拋棄，只剩下品牌和腦殘粉
- 全球今日報丨起亞聘請前寶馬設計師John Buckingham，以加強設計能力
- 環(huán)球速看：moto razr 40 Ultra斬獲京東手機榜TOP1
- 角力動力電池TWh時代，智能化或成制勝關鍵_全球觀天下
- 【環(huán)球快播報】眾泰董事長黃繼宏辭職
- 5月新勢力蔚來、理想、小鵬、哪吒、零跑銷量盤點，你看好哪家？_天天時訊
- 愛爾眼科手術器械破損生銹被罰 愛爾眼科手術器械消毒不合規(guī)被罰 每日看點
- 山東省煙臺市萊山區(qū)：開展“虎門硝煙日” 禁毒宣傳活動
- 今日熱門!7月3日開工！張店這些主干路路口要變樣……
- 農(nóng)業(yè)周觀點：養(yǎng)豬連虧5個月，寵物618拉序幕 世界新視野
- 當前速看：向AI提問 這個新職業(yè)火了
- 全球今熱點：民族團結(jié)一家親 反詐宣傳同步行
- 王自如被強制執(zhí)行198萬
- 全球熱門:清廉七里河 · 每日廉語（324）
- win10如何設置屏保圖片（win10如何設置屏保）
- 熱資訊！亞馬遜可能會增加 Prime 移動服務
- 起底疑吃出老鼠頭高校食堂運營方 #江西一高校食堂飯菜中疑吃出老鼠頭
- 環(huán)球熱議:郭明錤：蘋果 MR 頭戴設備成功關鍵因素在于能否與 AI、AIGC 高度整合 投資人更關注何時推出類 ChatGPT 服務
- 重慶市經(jīng)濟信息委開展“滿天星”行動計劃“拉網(wǎng)式”調(diào)研
- VELOTRIC完成千萬級A+輪融資|每日報道
- 目標300萬僅完成約20萬，直播也救不了天涯？
- 視焦點訊！海天味業(yè)增資至55.61億 增幅20%
- 嚴管施工噪音 “護航模式”助力高考
- 隱藏居民樓里的偽中醫(yī)：號稱“老中醫(yī)” 穴位卻分不清_全球關注
- 淄博太暖了吧！這樣的助考方式......助夢高考，請將這條藍絲帶占屏朋友圈！
- 五菱繽果5月銷量18015輛 環(huán)比增長10%-環(huán)球即時
- 今日報丨2023年“慈心一日捐”活動公示（一）
- 水立方足浴店技師山寨“閱兵”步操，網(wǎng)民：老板以前當兵？
- 環(huán)球熱資訊！機構(gòu)：電子特氣市場未來數(shù)年持續(xù)面臨供應短缺風險
- 新潮創(chuàng)投于雷：半導體并購不是目的，核心是服務企業(yè)長期發(fā)展
- 科諾美完成近億元A輪融資_最新資訊
- 【走進區(qū)域看發(fā)展】生態(tài)“雙城” 新顏新貌-今日報
- 特賽發(fā)科技獲得天使輪投資
- 吉野家雙拼飯含異物被罰 吉野家餐食含異物被罰5萬 全球看熱訊
- 全球滾動:華為手機用4G打敗5G，向世界證明什么才叫創(chuàng)新
- 【天天聚看點】邁入2.0時代！無人零售行業(yè)重新進入快車道
- “采取一切必要措施”！沙特減產(chǎn)100萬桶，意味著什么？ 天天時快訊
- 省“六一”少兒文藝調(diào)演精彩呈現(xiàn)
- 人民幣兌美元中間價報7.0904 調(diào)升35個基點 熱頭條
- 起底葉音背后公司 起底葉音工作室
- 星鯨科技獲數(shù)千萬元天使輪融資 今日熱議
- 北交所、全國股轉(zhuǎn)公司出臺“十八條”優(yōu)化市場服務—— 強化資本市場對中小企業(yè)創(chuàng)新發(fā)展|環(huán)球快資訊
- 暖心！來自銀行的“小蜜蜂驛站”......
- AI識別技術讓雪豹有了專屬“身份證”
- 印度列車脫軌相撞事故現(xiàn)場|環(huán)球新消息
- 焦點速訊：蘋果iOS 17發(fā)布時間正式官宣，這些功能提前知曉
- 超七千輛出租車公交車參與福建高考保障 天天快訊
- 杭州路口一車輛喇叭一直響 民警打開車門發(fā)現(xiàn)......_獨家
- 工業(yè)富聯(lián)：已著手開發(fā)下一代AI服務器
- 外國人都在搶購中國車！出口量反超日本 這些車有多強？
- 阿里云部分云服務器價格將下調(diào)
- 環(huán)球熱議:中物聯(lián)：5月份我國大宗商品供應持續(xù)增加
- 全球觀點：科創(chuàng)50ETF期權(quán)今日上市，標的ETF規(guī)模超650億元
- 暑期高考生學車注意事項|世界熱文
- 世界觀點：注意！學生購票有變化
- 承壓、韌性、破局 阿里影業(yè)(1060.HK)2023財年業(yè)績深度解讀
- 索尼CEO：云游戲存在延遲、服務器浪費等障礙 環(huán)球微資訊
- 科技創(chuàng)新推動模式變革 行業(yè)加速探索未來新水務 當前速訊
- 騰勢汽車成為首個MPV單月冠軍的中國豪華品牌