使用c#實現23種常見的設計模式|全球新消息
設計模式通常分為三個主要類別：
創建型模式
結構型模式
(相關資料圖)
行為型模式。
這些模式是用于解決常見的對象導向設計問題的最佳實踐。
以下是23種常見的設計模式并且提供c#代碼案例：
public sealed class Singleton{ //創建一個只讀的靜態Singleton實例 private static readonly Singleton instance = new Singleton(); // 記錄Singleton的創建次數 private static int instanceCounter = 0; // 單例實例的公共訪問點 public static Singleton Instance { get { return instance; } } // 私有構造函數 private Singleton() { instanceCounter++; Console.WriteLine("Instances Created " + instanceCounter); } // 在此處添加其他的Singleton類方法 public void LogMessage(string message) { Console.WriteLine("Message: " + message); }}在這個例子中，我們有一個名為Singleton的類，它有一個私有的構造函數和一個靜態的只讀屬性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(); }}工廠方法模式是一種創建型設計模式，它提供了一種創建對象的接口，但允許子類決定實例化哪個類。工廠方法讓類的實例化推遲到子類中進行。
下面是一個使用C#實現的工廠方法模式的簡單示例：
// 抽象產品public interface IProduct{ string Operation();}// 具體產品Apublic class ProductA : IProduct{ public string Operation() { return "{Result of ProductA}"; }}// 具體產品Bpublic class ProductB : IProduct{ public string Operation() { return "{Result of ProductB}"; }}// 抽象創建者public abstract class Creator{ public abstract IProduct FactoryMethod();}// 具體創建者Apublic class CreatorA : Creator{ public override IProduct FactoryMethod() { return new ProductA(); }}// 具體創建者Bpublic class CreatorB : Creator{ public override IProduct FactoryMethod() { return new ProductB(); }}以上代碼中定義了兩個產品ProductA和ProductB，這兩個產品都實現了IProduct接口。接著我們有兩個Creator類，CreatorA和CreatorB，它們都繼承自抽象基類Creator。CreatorA工廠創建ProductA，CreatorB工廠創建ProductB。
以下是一個使用這些工廠和產品的示例：
class Program{ static void Main(string[] args) { // 創建工廠對象 Creator creatorA = new CreatorA(); Creator creatorB = new CreatorB(); // 通過工廠方法創建產品對象 IProduct productA = creatorA.FactoryMethod(); IProduct productB = creatorB.FactoryMethod(); // 打印結果 Console.WriteLine("ProductA says: " + productA.Operation()); Console.WriteLine("ProductB says: " + productB.Operation()); Console.ReadLine(); }}當你運行這個程序時，它會顯示出ProductA和ProductB的Operation方法返回的結果。這說明我們已經成功地使用工廠方法模式創建了產品實例。每個工廠類決定了它創建哪個產品的實例。這種方式使得客戶端代碼不需要直接實例化產品類，而只需要依賴工廠接口，增加了程序的靈活性。
抽象工廠模式是一種創建型設計模式，它提供了一種接口，用于創建相關或依賴對象的系列，而不指定這些對象的具體類。在這個模式中，客戶端通過他們的抽象接口使用類，允許該模式在不影響客戶端的情況下替換實現類。
以下是一個簡單的抽象工廠模式的C#實現：
// 抽象產品：動物public interface IAnimal{ string Speak();}// 具體產品：狗public class Dog : IAnimal{ public string Speak() { return "Bark Bark"; }}// 具體產品：貓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，它們都實現了IAnimal接口。然后我們有兩個工廠類，DogFactory和CatFactory，它們都繼承自IAnimalFactory。DogFactory生產Dog，而CatFactory生產Cat。
以下是一個使用這些工廠和產品的示例：
class Program{ static void Main(string[] args) { // 創建工廠 IAnimalFactory dogFactory = new DogFactory(); IAnimalFactory catFactory = new CatFactory(); // 使用工廠創建產品 IAnimal dog = dogFactory.CreateAnimal(); IAnimal cat = catFactory.CreateAnimal(); // 打印結果 Console.WriteLine("Dog says: " + dog.Speak()); Console.WriteLine("Cat says: " + cat.Speak()); Console.ReadLine(); }}當你運行這個程序時，會打印出Dog和Cat的Speak方法的結果，這顯示了我們已經成功地使用了抽象工廠模式創建了產品實例。這種方式使得客戶端代碼不需要直接實例化產品類，而只需要依賴工廠接口，增加了程序的靈活性和擴展性。
4. 建造者模式（Builder）建造者模式是一種創建型設計模式，它提供了一種創建對象的接口，但是允許使用相同的構建過程來創建不同的產品。
以下是在C#中實現建造者模式的一個簡單示例：
// 產品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是我們要創建的產品，CarBuilder是抽象的建造者，定義了制造一個產品所需要的各個步驟，FerrariBuilder是具體的建造者，實現了CarBuilder定義的所有步驟，Director是指揮者，它告訴建造者應該按照什么順序去執行哪些步驟。
以下是一個使用這個建造者模式的示例：
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(); }}當你運行這個程序時，會看到我們已經成功地創建了一個Car實例，它的各個部分是按照FerrariBuilder所定義的方式創建的。這說明我們使用建造者模式成功地將一個復雜對象的構造過程解耦，使得同樣的構造過程可以創建不同的表示。
原型模式是一種創建型設計模式，它實現了一個原型接口，該接口用于創建當前對象的克隆。當直接創建對象的代價比較大時，則采用這種模式。例如，一個對象需要在一個高代價的數據庫操作后被創建。
以下是在C#中實現原型模式的一個簡單示例：
// 抽象原型public interface IPrototype{ IPrototype Clone();}// 具體原型public class ConcretePrototype : IPrototype{ public string Name { get; set; } public int Value { get; set; } public IPrototype Clone() { // 實現深拷貝 return (ConcretePrototype)this.MemberwiseClone(); // Clones the concrete object. }}以上代碼定義了一個ConcretePrototype類，它實現了IPrototype接口。接口定義了一個Clone方法，用于復制對象。在ConcretePrototype類中，我們使用了MemberwiseClone方法來創建一個新的克隆對象。
以下是一個使用原型模式的示例：
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(); }}在這個例子中，我們創建了一個ConcretePrototype對象，并為其屬性賦值，然后我們調用Clone方法創建了一個新的ConcretePrototype對象。當我們運行這個程序時，會看到原始對象和克隆對象的屬性是相同的，這表明我們已經成功地克隆了一個對象。
執行流程如下：
創建一個具體的原型對象，為其屬性賦值。調用原型對象的Clone方法，創建一個新的對象，該對象的屬性與原型對象的屬性相同。打印原型對象和克隆對象的屬性，驗證它們是否相同。結構型模式： 6. 適配器模式（Adapter）1. 橋接模式（Bridge）橋接模式是一種結構型設計模式，用于將抽象部分與其實現部分分離，使它們都可以獨立地變化。
以下是在C#中實現橋接模式的一個簡單示例：
// 實現類接口public interface IImplementor{ void OperationImp();}// 具體實現類Apublic class ConcreteImplementorA : IImplementor{ public void OperationImp() { Console.WriteLine("Concrete Implementor A"); }}// 具體實現類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接口的實例，通過這個實例調用實現類的方法。RefinedAbstraction是擴充的抽象類，它繼承自Abstraction。ConcreteImplementorA和ConcreteImplementorB是實現類，它們實現了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(); }}在這個例子中，我們創建了兩個實現類的實例，然后創建了兩個抽象類的實例，每個抽象類的實例都有一個實現類的實例。當我們調用抽象類的Operation方法時，它會調用實現類的OperationImp方法。
執行流程如下：
創建實現類的實例。創建抽象類的實例，抽象類的實例有一個實現類的實例。調用抽象類的Operation方法，該方法會調用實現類的OperationImp方法。2. 組合模式（Composite）組合模式（Composite pattern）是一種結構型設計模式，它可以使你將對象組合成樹形結構，并且能像使用獨立對象一樣使用它們。這種模式的主要目的是使單個對象和組合對象具有一致性。
以下是在C#中實現組合模式的一個簡單示例：
// 抽象組件類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);}// 葉節點類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); }}// 構件容器類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); // 顯示每個節點的子節點 foreach (Component component in _children) { component.Display(depth + 2); } }} 在這個代碼中，Component是組件抽象類，它有一個名字，并定義了添加、刪除和顯示操作。Leaf是葉子節點，它實現了Component的操作。Composite是組件容器，它可以添加、刪除和顯示其子節點。
以下是一個使用這個模式的示例：
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); // 顯示樹形結構 root.Display(1); Console.ReadLine(); }}在這個例子中，我們創建了一個根節點，并在其中添加了兩個葉子節點。然后我們創建了一個復合節點，并在其中添加了兩個葉子節點，然后我們把復合節點添加到根節點中。我們還在復合節點中添加了另一個復合節點。最后，我們又在根節點中添加和刪除了一個葉子節點，然后顯示了樹的結構。
執行流程如下：
創建組合和葉子對象。通過調用組合對象的Add方法將葉子對象和其他組合對象添加到組合對象中。通過調用組合對象的Remove方法將葉子對象從組合對象中移除。調用組合對象的Display方法顯示組合對象的結構。3. 裝飾模式（Decorator）裝飾模式是一種結構型設計模式，它允許在運行時動態地將功能添加到對象中，這種模式提供了比繼承更有彈性的解決方案。
以下是在C#中實現裝飾模式的一個簡單示例：
// 抽象組件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是具體組件，它實現了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(); }}在這個例子中，我們首先創建了一個ConcreteComponent對象，并調用它的Operation方法。然后我們創建了一個ConcreteDecoratorA對象，它裝飾了ConcreteComponent，并調用它的Operation方法。最后，我們創建了一個ConcreteDecoratorB對象，它裝飾了ConcreteDecoratorA，并調用它的Operation方法。這樣，我們就可以在運行時動態地添加功能。
執行流程如下：
創建一個具體組件對象并調用其操作。創建一個裝飾器對象，該對象裝飾了具體組件，并調用其操作。在操作中，裝飾器首先調用具體組件的操作，然后執行額外的操作。創建另一個裝飾器對象，裝飾前一個裝飾器，并調用其操作。在操作中，這個裝飾器首先調用前一個裝飾器的操作，然后執行額外的操作。4. 外觀模式（Facade）外觀模式是一種結構型設計模式，提供了一個統一的接口，用來訪問子系統中的一群接口。外觀模式定義了一個高層接口，讓子系統更容易使用。
以下是在C#中實現外觀模式的一個簡單示例：
// 子系統Apublic class SubSystemA{ public string OperationA() { return "SubSystemA, OperationA\n"; }}// 子系統Bpublic class SubSystemB{ public string OperationB() { return "SubSystemB, OperationB\n"; }}// 子系統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都是子系統，每個子系統都有一個操作。Facade是一個外觀類，它封裝了對子系統的操作，提供了一個統一的接口。
以下是一個使用這個模式的示例：
class Program{ static void Main(string[] args) { Facade facade = new Facade(); Console.WriteLine(facade.OperationWrapper()); Console.ReadLine(); }}在這個例子中，我們創建了一個Facade對象，并調用了它的OperationWrapper方法。這個方法封裝了對子系統的操作，使得客戶端可以不直接操作子系統，而是通過外觀類操作子系統。
執行流程如下：
創建一個外觀對象。
通過調用外觀對象的方法，間接地操作子系統。
子系統的操作被封裝在外觀對象的方法中，客戶端不需要直接操作子系統。
5. 享元模式（Flyweight）享元模式（Flyweight Pattern）是一種結構型設計模式，該模式主要用于減少創建對象的數量，以減少內存占用和提高性能。這種類型的設計模式屬于結構型模式，它提供了一種減少對象數量從而改善應用所需的對象結構的方式。
以下是在C#中實現享元模式的一個簡單示例：
// 享元類public class Flyweight{ private string intrinsicState; // 構造函數 public Flyweight(string intrinsicState) { this.intrinsicState = intrinsicState; } // 業務方法 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是享元類，它有一個內在狀態intrinsicState，這個狀態是不變的。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(); }}在這個例子中，我們創建了一個FlyweightFactory對象，并通過它創建了兩個享元對象。注意，當我們試圖創建第三個享元對象時，工廠實際上返回了第一個享元對象的引用，因為這兩個對象的內在狀態是相同的。
執行流程如下：
創建一個享元工廠對象。通過享元工廠獲取享元對象。如果對象已經存在，則返回現有對象；否則，創建新對象。執行享元對象的操作。顯示當前享元對象的數量。6. 代理模式（Proxy）代理模式是一種結構型設計模式，它提供了一個對象代替另一個對象來控制對它的訪問。代理對象可以在客戶端和目標對象之間起到中介的作用，并添加其他的功能。
以下是在C#中實現代理模式的一個簡單示例：
// 抽象主題接口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() { // 檢查是否有權限訪問 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是實現了ISubject接口的類，Proxy是代理類，它也實現了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(); }}在這個例子中，我們首先直接調用了RealSubject的Request方法，然后我們通過代理調用了相同的方法。注意，在通過代理調用Request方法時，代理還執行了其他的操作，如檢查訪問權限和記錄日志。
執行流程如下：
創建一個真實主題對象，并直接調用其Request方法。創建一個代理對象，代理對象包含一個真實主題的引用。通過代理對象調用Request方法。在這個方法中，代理首先檢查訪問權限，然后調用真實主題的Request方法，最后記錄日志。行為型模式： 13. 責任鏈模式（Chain of Responsibility）1. 命令模式（Command）命令模式（Command Pattern）是一種數據驅動的設計模式，它屬于行為型模式。在命令模式中，請求在對象中封裝成為一個操作或行為，這些請求被送到調用對象，調用對象尋找可以處理該命令的合適的對象，并把命令直接送達到對應的對象，該對象會執行這些命令。
以下是在C#中實現命令模式的一個簡單示例：
// 命令接口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"); }}// 調用者或發送者類public class Invoker{ private ICommand command; public void SetCommand(ICommand command) { this.command = command; } public void ExecuteCommand() { command.Execute(); }}在這個代碼中，ICommand是命令接口，定義了Execute方法。ConcreteCommand是具體的命令類，它實現了ICommand接口，并持有一個Receiver對象的引用。Invoker是調用者或發送者類，它持有一個ICommand對象的引用，并可以通過SetCommand方法設置命令，通過ExecuteCommand方法執行命令。
以下是一個使用這個模式的示例：
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(); }}在這個例子中，我們創建了一個Receiver對象、一個ConcreteCommand對象和一個Invoker對象。然后我們通過Invoker的SetCommand方法設置了命令，并通過ExecuteCommand方法執行了命令。
執行流程如下：
創建一個接收者對象。創建一個具體命令對象，并將接收者對象傳遞給它。創建一個調用者或發送者對象。通過調用者對象的SetCommand方法設置命令。通過調用者對象的ExecuteCommand方法執行命令。2. 解釋器模式（Interpreter）解釋器模式（Interpreter Pattern）是一種行為型設計模式，用于解決一些固定語法格式的需求。它定義了如何在語言中表示和解析語法。
以下是在C#中實現解釋器模式的一個簡單示例：
// 抽象表達式public interface IExpression{ bool Interpret(string context);}// 終結符表達式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; }}// 非終結符表達式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是終結符表達式，它實現了IExpression接口。OrExpression是非終結符表達式，它也實現了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(); } // 規則：Robert 和 John 是男性 public static IExpression GetMaleExpression() { IExpression robert = new TerminalExpression("Robert"); IExpression john = new TerminalExpression("John"); return new OrExpression(robert, john); } // 規則：Julie 是一個已婚的女性 public static IExpression GetMarriedWomanExpression() { IExpression julie = new TerminalExpression("Julie"); IExpression married = new TerminalExpression("Married"); return new OrExpression(julie, married); }}在這個例子中，我們定義了兩個規則，"Robert和John是男性"和"Julie是一個已婚的女性"。我們然后創建了兩個表達式對象，分別表示這兩個規則，并使用這兩個對象來解析輸入。
執行流程如下：
創建終結符表達式對象和非終結符表達式對象，用于表示規則。調用表達式對象的Interpret方法，解析輸入的字符串。輸出解析結果。3. 迭代器模式（Iterator）迭代器模式（Iterator Pattern）是一種行為型設計模式，它提供了一種方法來訪問一個對象的元素，而不需要暴露該對象的內部表示。以下是在C#中實現迭代器模式的一個簡單示例：
// 抽象聚合類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是具體聚合類，實現了IAggregate接口。IIterator是抽象迭代器，定義了First、Next等方法，ConcreteIterator是具體迭代器，實現了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(); }}在這個例子中，我們創建了一個ConcreteAggregate對象，并添加了幾個元素。然后我們通過CreateIterator方法創建了一個迭代器，并使用這個迭代器遍歷了集合中的所有元素。
執行流程如下：
創建一個聚合對象，并添加一些元素。通過聚合對象的CreateIterator方法創建一個迭代器。通過迭代器的First方法獲取第一個元素，然后通過Next方法獲取后續的元素，直到獲取不到元素為止。4. 中介者模式（Mediator）中介者模式是一種行為設計模式，它讓你能減少一組對象之間復雜的通信。它提供了一個中介者對象，此對象負責在組中的對象之間進行通信，而不是這些對象直接進行通信。
首先，讓我們定義一個中介者接口和一個具體的中介者：
// Mediator 接口聲明了與組件交互的方法。public interface IMediator{ void Notify(object sender, string ev);}// 具體 Mediators 實現協作行為，它負責協調多個組件。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 實現各種功能。它們不依賴于其他組件。// 它們也不依賴于任何具體 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"); }}最后，我們來創建一個客戶端代碼：
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(); }}這個示例中的各個組件通過中介者來進行通信，而不是直接通信，這樣就可以減少組件之間的依賴性，使得它們可以更容易地被獨立修改。當一個組件發生某個事件（例如"Component 1 does A"）時，它會通過中介者來通知其他組件，這樣其他組件就可以根據這個事件來做出響應（例如"Component 2 does C"）。
5. 備忘錄模式（Memento）備忘錄模式是一種行為設計模式，它能保存對象的狀態，以便在后面可以恢復它。在大多數情況下，這種模式可以讓你在不破壞對象封裝的前提下，保存和恢復對象的歷史狀態。
以下是一個簡單的備忘錄模式的實現，其中有三個主要的類：Originator（保存了一個重要的狀態，這個狀態可能會隨著時間改變），Memento（保存了Originator的一個快照，這個快照包含了Originator的狀態），以及Caretaker（負責保存Memento）。
// Originator 類可以生成一個備忘錄，并且可以通過備忘錄恢復其狀態。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}"); }}// 備忘錄接口提供了獲取備忘錄和原發器狀態的方法。但在該接口中并未聲明所有的方法，一些方法只在原發器中聲明。public interface IMemento{ string GetName(); string GetState(); DateTime GetDate();}// Concrete Memento 存儲原發器狀態，并通過原發器實現備份。備忘錄是不可變的，因此，沒有 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 不依賴于具體備忘錄類。結果，它不會有任何訪問原發器狀態的權利，它只能獲取備忘錄的元數據。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 持有一些重要的狀態，并且提供了方法去保存它的狀態到一個備忘錄對象以及從備忘錄對象中恢復它的狀態。Caretaker 負責保存備忘錄，但是它不能操作備忘錄對象中的狀態。當用戶執行操作時，我們先保存當前的狀態，然后執行操作。如果用戶后來不滿意新的狀態，他們可以方便地從舊的備忘錄中恢復狀態。
6. 觀察者模式（Observer）觀察者模式（Observer Pattern）是一種行為型設計模式，當一個對象的狀態發生變化時，依賴它的所有對象都會得到通知并被自動更新。以下是在C#中實現觀察者模式的一個簡單示例：
// 抽象觀察者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() { // 觸發狀態變化，通知所有觀察者 NotifyObservers(); }} 在這個代碼中，IObserver是抽象觀察者，定義了Update方法，ConcreteObserver是具體觀察者，實現了IObserver接口。ISubject是抽象主題，定義了RegisterObserver、RemoveObserver和NotifyObservers方法，ConcreteSubject是具體主題，實現了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(); }}在這個例子中，我們創建了一個ConcreteSubject對象，并注冊了三個觀察者。然后我們通過ChangeState方法改變了主題的狀態，這會觸發主題通知所有觀察者。
執行流程如下：
創建一個具體主題對象。創建幾個具體觀察者對象，并通過主題的RegisterObserver方法將這些觀察者注冊到主題中。通過主題的ChangeState方法改變主題的狀態，這會觸發主題通知所有觀察者。7. 狀態模式（State）狀態模式在面向對象編程中，是一種允許對象在其內部狀態改變時改變其行為的設計模式。這種類型的設計模式屬于行為型模式。在狀態模式中，我們創建對象表示各種狀態，以及一個行為隨狀態改變而改變的上下文對象。
以下是一個狀態模式的示例。這個示例中，我們將創建一個銀行賬戶，它有兩個狀態：正常狀態（NormalState）和透支狀態（OverdrawnState）。當用戶執行操作（存款和取款）時，賬戶狀態將相應地進行更改。
首先，我們定義一個表示狀態的接口：
public interface IAccountState{ void Deposit(Action addToBalance); void Withdraw(Action subtractFromBalance); void ComputeInterest();}然后，我們創建兩個表示具體狀態的類：
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"); }}然后，我們創建一個Context類，它使用這些狀態來執行其任務：
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(); }}現在，你可以創建一個實例并運行一個Demo來測試這個狀態模式的代碼：
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(); }}這個程序首先在正常狀態下進行存款操作，然后嘗試進行取款操作。由于取款金額超過賬戶余額，所以賬戶進入透支狀態，并阻止進一步的取款操作。但存款仍然被允許，以使賬戶回歸到正常狀態。計算利息的行為也根據賬戶的狀態變化而變化。
8. 策略模式（Strategy）策略模式定義了一系列的算法，并將每一個算法封裝起來，使得它們可以相互替換。策略模式讓算法獨立于使用它的客戶而獨立變化。
以下是一個簡單的策略模式的C#實現。這個例子中，我們將創建一個排序策略，比如快速排序和冒泡排序，它們實現同一個接口，然后創建一個Context類，它使用這些策略來執行排序操作。
首先，我們定義一個表示排序策略的接口：
public interface ISortStrategy{ void Sort(List list);} 然后，我們創建兩個表示具體策略的類：
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 "); }} 然后，我們創建一個Context類，它使用這些策略來執行其任務：
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(); }} 現在，你可以創建一個實例并運行一個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(); }}這個程序首先創建了一個未排序的列表，然后它首先使用快速排序策略進行排序，接著又使用冒泡排序策略進行排序。
9. 模板方法模式（Template Method）模板方法模式定義了一個操作中算法的骨架，將這些步驟延遲到子類中。模板方法使得子類可以不改變算法的結構即可重定義該算法的某些特定步驟。
以下是一個模板方法模式的示例。這個示例中，我們將創建一個烹飪食物的過程，這個過程有一些固定的步驟（例如準備材料，清理），但是具體的烹飪步驟則取決于具體的食物。
首先，我們定義一個抽象的模板類：
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..."); }}然后，我們創建兩個具體的子類，它們分別實現了具體的烹飪步驟：
public class CookPasta : CookingProcedure{ public override void Cook() { Console.WriteLine("Cooking pasta..."); }}public class BakeCake : CookingProcedure{ public override void Cook() { Console.WriteLine("Baking cake..."); }}現在，你可以創建一個實例并運行一個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(); }}在這個程序中，我們首先創建了一個CookPasta對象，然后調用其PrepareDish方法。然后，我們創建了一個BakeCake對象，再次調用其PrepareDish方法。這兩個對象雖然具有不同的Cook方法，但是它們的PrepareDish方法的結構（即算法的骨架）是相同的。
訪問者模式（Visitor Pattern）是一種將算法與對象結構分離的軟件設計模式。這種模式的基本想法就是通過所謂的"訪問者"來改變元素的操作。這樣一來，元素的類可以用于表示元素結構，而具體的操作則可以在訪問者類中定義。
以下是一個使用C#實現的訪問者模式示例，包括了詳細的注釋和執行流程。
這個示例中有三個主要部分：訪問者（IVisitor）、可訪問元素（IElement）和元素結構（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); }}// 對象結構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); } }} 執行流程如下：
創建具體元素ConcreteElementA和ConcreteElementB的實例。創建對象結構ObjectStructure的實例，并將步驟1創建的具體元素添加到對象結構中。創建具體訪問者ConcreteVisitorA和ConcreteVisitorB的實例。調用對象結構的Accept方法，傳入步驟3創建的具體訪問者，使具體訪問者訪問對象結構中的所有元素。以下是一個使用上述代碼的示例：
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的分享
標簽：
推薦
財富更多》
-
全國“三夏”大規模小麥機收全面展開|每日焦點
全國“三夏”大規模小麥機收全面展開---...
-
專家：我國胃癌診療水平穩步提升
專家：我國胃癌診療水平穩步提升---近日...
-
當前視點！兩部門：開展“春雨潤苗”專項行動 助力小微經營主體發展
兩部門：開展“春雨潤苗”專項行動助力...
-
全球報道:收評：指數走勢分化創指跌1.39% 景點及旅游漲幅居前
收評：指數走勢分化創指跌1 39%景點及...
-
環球播報:中經資料：巴基斯坦證券市場一周回顧(2023.5.29-6.2)
中經資料：巴基斯坦證券市場一周回顧(20...
動態更多》
熱點
- realme10系列正式宣布 采用雙曲面屏正面頂部居中挖孔
- 五菱全新微型電動車內飾官圖發布 座椅采用星際形打孔工藝
- 努比亞Z40星空典藏版正式開售 采用微米級油畫筆觸紋理技術
- iQOO11系列正式官宣 首批搭載驍龍8Gen2機型之一
- 海信34英寸帶魚屏顯示器發布 支持165Hz刷新率
- OPPO明年將商用240W超級閃充 新一代電芯支持更高倍率充電
- 第一款Android手機渲染圖曝光 橫向滑蓋設計和全尺寸鍵盤
- 吉利首款純電皮卡11月9日上市 車輛續航里程超過610公里
- 努比亞Z40SPro星空典藏版正式公布 堪稱窄邊框天花板
- vivo無線運動耳機2今日正式上市 首銷只要119元
- 最高檢：截至2022年底全國共辦理生態環境和資源保護公益訴訟案件40余萬件
- 電腦屏保時間怎么設置？電腦屏保后無法喚醒怎么辦？
- 筆記本屏幕亮度怎么調？筆記本屏幕的灰塵怎么清理？
- 志愿星光點亮社區“微治理”-焦點速遞
- 電腦防火墻在哪里設置？電腦防火墻怎么全部關閉？
- 電腦護眼模式怎么設置？電腦護眼模式真的護眼嗎？
- 瑞幸開出第一萬家店，咖啡殺到9.9元時代
- 電腦開機密碼怎么取消？電腦開機密碼鎖住了怎么解鎖？
- windows7一鍵還原在哪？windows7的設置在哪里找？
- 錦華新材掛牌新三板
- 無線路由器怎么連接？無線路由器怎么連接無線網絡？
- 藍牙耳機怎么連接電腦？藍牙耳機充不進去電怎么辦？
- 谷歌推設計神器“StyleDrop”，給一張圖就能復刻作品風格-天天訊息
- 電腦設備管理器在哪？電腦設備管理器顯卡在哪兒？
- 多地對網約車按下“暫停鍵”|世界最資訊
- 香腸太陽曬干好還是烘干好_香腸是太陽曬干好還是陰干好_全球最新
- 手機第一次充電要充多久？手機充電突然變慢是怎么回事？
- 北美票房：《蜘蛛俠：縱橫宇宙》登頂周末票房，《小美人魚》《柜魔》分居二三-當前觀點
- 電腦垃圾怎么清理?電腦垃圾多了怎么清理電腦？
- 比亞迪海洋網車型5月銷量達102572輛 世界熱訊
- 2023年“全國科技工作者日”法律服務系列活動啟動
- 蘋果怎么換自定義圖標?蘋果手機突然黑屏打不開怎么辦?
- 寧德時代回應供貨變動傳聞：與客戶戰略合作關系沒有發生變化 要聞
- 蘋果電腦沒聲音按哪個鍵恢復?蘋果電腦怎么切換系統?
- 香腸派對怎么添加好友？香腸派對的糖果怎么免費獲得?
- 抖音為什么要出極速版？抖音極速版和抖音有什么區別？
- 小雅智能音箱怎么使用？小雅智能音箱怎么連接手機？
- 蘋果手機下載軟件密碼忘了怎么辦？蘋果手機軟件更新不了怎么辦？
- 當前資訊!在家也能復刻的廣式腸粉，秘訣全在這個洲星腸粉粉
- 耳機插電腦上沒聲音怎么設置？耳機沒有聲音是怎么回事？
- 黎明覺醒河豚怎么釣？黎明覺醒的安全繩怎么放？
- 蘋果11快充傷電池嗎？蘋果11快充需要多長時間？
- 陳喬恩游日本，在大阪機場和老公Alan會合撒嬌，又親又抱甜如初戀-每日頭條
- 手提電腦開不了機怎么辦？筆記本電腦開機進不了系統怎么辦?
- 電腦管家有必要裝嗎？電腦管家是電腦自帶的嗎？
- qq音樂一起聽歌怎么用？qq音樂會員怎么取消自動續費？
- 平板怎么清理內存垃圾？平板電腦的操作系統有哪些？
- qq聊天記錄怎么發給別人？qq聊天記錄的視頻在哪個文件夾？
- 順利交付！神十五航天員帶回了20多公斤實驗樣品_焦點速看
- 鍵盤沒有反應是怎么回事？電腦鍵盤失靈怎么解決？
- 朋友圈內容太多怎么刪除？微信朋友圈可以看訪客記錄嗎？
- 阿里元境總經理王矛：AI加持，元宇宙將為內容創作降本提效 | 最前線-當前關注
- 電話加入黑名單后還能收到信息嗎？電話黑名單發信息能收到嗎？
- 【熱聞】西門子醫療在德國福希海姆建設新工廠，預計創造100個工作崗位
- 每日焦點！午評：創業板指跌1.48% 景點及旅游、傳媒板塊活躍
- 筆記本鍵帽可以扣下來嗎？筆記本鍵帽能直接掰下來嗎？
- 未來十天西南地區東部等地多降雨 華南地區高溫天氣將緩解
- 北海康成邁芮倍獲準上市，治療ALGS膽汁淤積性瘙癢
- 陜西扶風：“云端”綻放就業夢-每日時訊
- 打游戲用什么軸的機械鍵盤？機械鍵盤按鍵失靈怎么修？
- 快手家居數據行業迎618爆發 前三天GMV同比去年增長超139% 天天熱文
- 騰訊視頻可以掃碼登錄嗎？騰訊視頻可以登錄幾個設備？
- 杭州部分小區房價跌回2017年 跌了但還是賣不出去？！
- 雞蛋便宜了！未來價格怎么走？ 每日視訊
- 怎么找回清空微信聊天記錄？微信聊天記錄怎么備份？
- 六五環境日·手繪海報|挑剔的TA們，為何偏愛山東？ 世界熱點評
- 屏幕上的圓圈怎樣取消？手機屏幕失靈點不動怎么辦？
- win10網絡連接不見了？win10網絡類型在哪里設置？
- 教育部：加強實驗教學，將實驗操作納入中考
- 手機上怎么登錄官網？手機官網的手機是正品嗎？
- ipad屏幕變暗了怎么恢復？ipad屏幕旋轉怎么設置？
- 仙佑膏藥：互聯網+膏藥產業：電商與移動互聯網跨界融合
- 今年云夢2863人參加高考 快播報
- 我區發布總部經濟高質量發展實施意見_最新
- 越“聰明”的代碼，越是“一次性” 全球播資訊
- 加盟店負增長凈利潤連年大降，海瀾之家請張頌文能否破解“老化”難題_環球要聞 今日聚焦
- 每日視訊：重啟天涯第一步失敗！7 × 24 小時直播，僅募集 14.99 萬元！投資人潘海東：天涯已被時代拋棄，只剩下品牌和腦殘粉
- 全球今日報丨起亞聘請前寶馬設計師John Buckingham，以加強設計能力
- 環球速看：moto razr 40 Ultra斬獲京東手機榜TOP1
- 角力動力電池TWh時代，智能化或成制勝關鍵_全球觀天下
- 【環球快播報】眾泰董事長黃繼宏辭職
- 5月新勢力蔚來、理想、小鵬、哪吒、零跑銷量盤點，你看好哪家？_天天時訊
- 愛爾眼科手術器械破損生銹被罰 愛爾眼科手術器械消毒不合規被罰 每日看點
- 山東省煙臺市萊山區：開展“虎門硝煙日” 禁毒宣傳活動
- 今日熱門!7月3日開工！張店這些主干路路口要變樣……
- 農業周觀點：養豬連虧5個月，寵物618拉序幕 世界新視野
- 當前速看：向AI提問 這個新職業火了
- 全球今熱點：民族團結一家親 反詐宣傳同步行
- 王自如被強制執行198萬
- 全球熱門:清廉七里河 · 每日廉語（324）
- win10如何設置屏保圖片（win10如何設置屏保）
- 熱資訊！亞馬遜可能會增加 Prime 移動服務
- 起底疑吃出老鼠頭高校食堂運營方 #江西一高校食堂飯菜中疑吃出老鼠頭
- 環球熱議:郭明錤：蘋果 MR 頭戴設備成功關鍵因素在于能否與 AI、AIGC 高度整合 投資人更關注何時推出類 ChatGPT 服務
- 重慶市經濟信息委開展“滿天星”行動計劃“拉網式”調研
- VELOTRIC完成千萬級A+輪融資|每日報道
- 目標300萬僅完成約20萬，直播也救不了天涯？
- 視焦點訊！海天味業增資至55.61億 增幅20%
- 嚴管施工噪音 “護航模式”助力高考
- 隱藏居民樓里的偽中醫：號稱“老中醫” 穴位卻分不清_全球關注
- 淄博太暖了吧！這樣的助考方式......助夢高考，請將這條藍絲帶占屏朋友圈！
- 五菱繽果5月銷量18015輛 環比增長10%-環球即時
- 今日報丨2023年“慈心一日捐”活動公示（一）
- 水立方足浴店技師山寨“閱兵”步操，網民：老板以前當兵？
- 環球熱資訊！機構：電子特氣市場未來數年持續面臨供應短缺風險
- 新潮創投于雷：半導體并購不是目的，核心是服務企業長期發展
- 科諾美完成近億元A輪融資_最新資訊
- 【走進區域看發展】生態“雙城” 新顏新貌-今日報
- 特賽發科技獲得天使輪投資
- 吉野家雙拼飯含異物被罰 吉野家餐食含異物被罰5萬 全球看熱訊
- 全球滾動:華為手機用4G打敗5G，向世界證明什么才叫創新
- 【天天聚看點】邁入2.0時代！無人零售行業重新進入快車道
- “采取一切必要措施”！沙特減產100萬桶，意味著什么？ 天天時快訊
- 省“六一”少兒文藝調演精彩呈現
- 人民幣兌美元中間價報7.0904 調升35個基點 熱頭條
- 起底葉音背后公司 起底葉音工作室
- 星鯨科技獲數千萬元天使輪融資 今日熱議
- 北交所、全國股轉公司出臺“十八條”優化市場服務—— 強化資本市場對中小企業創新發展|環球快資訊
- 暖心！來自銀行的“小蜜蜂驛站”......
- AI識別技術讓雪豹有了專屬“身份證”
- 印度列車脫軌相撞事故現場|環球新消息
- 焦點速訊：蘋果iOS 17發布時間正式官宣，這些功能提前知曉
- 超七千輛出租車公交車參與福建高考保障 天天快訊
- 杭州路口一車輛喇叭一直響 民警打開車門發現......_獨家
- 工業富聯：已著手開發下一代AI服務器
- 外國人都在搶購中國車！出口量反超日本 這些車有多強？
- 阿里云部分云服務器價格將下調
- 環球熱議:中物聯：5月份我國大宗商品供應持續增加
- 全球觀點：科創50ETF期權今日上市，標的ETF規模超650億元
- 暑期高考生學車注意事項|世界熱文
- 世界觀點：注意！學生購票有變化
- 承壓、韌性、破局 阿里影業(1060.HK)2023財年業績深度解讀
- 索尼CEO：云游戲存在延遲、服務器浪費等障礙 環球微資訊
- 科技創新推動模式變革 行業加速探索未來新水務 當前速訊
- 騰勢汽車成為首個MPV單月冠軍的中國豪華品牌