使用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单月冠军的中国豪华品牌