C#常见的设计模式-行为型模式

前言

行为型模式是面向对象设计中的一类设计模式,它关注对象之间的通信和相互作用,以实现特定的行为或功能。在C#中,有许多常见的行为型模式,下面将对其中10种行为型模式进行介绍,并给出相应的代码示例。
在这里插入图片描述


目录

    • 前言
    • 1. 命令模式(Command)
      • 示例代码
      • 解释
    • 2. 解释器模式(Interpreter)
      • 示例代码
      • 解释
    • 3. 迭代器模式(Iterator)
      • 示例代码
      • 解释
    • 4. 中介者模式(Mediator)
      • 示例代码
      • 解释
    • 5. 备忘录模式(Memento)
      • 示例代码
      • 解释
    • 6. 观察者模式(Observer)
      • 示例代码
      • 解释
    • 7. 状态模式(State)
      • 示例代码
      • 解释
    • 8. 策略模式(Strategy)
      • 示例代码
      • 解释
    • 9. 模板方法模式(Template Method)
      • 示例代码
      • 解释
    • 10. 访问者模式(Visitor)
      • 示例代码
      • 解释


1. 命令模式(Command)

命令模式将请求封装成一个对象,从而使得请求发送者和接收者解耦。

示例代码

// 命令接口
public interface ICommand
{void Execute();
}// 具体命令类
public class ConcreteCommand : ICommand
{private Receiver _receiver;public ConcreteCommand(Receiver receiver){_receiver = receiver;}public void Execute(){_receiver.Action();}
}// 接收者类
public class Receiver
{public void Action(){Console.WriteLine("执行命令");}
}// 客户端类
public class Client
{public void Main(){Receiver receiver = new Receiver();ICommand command = new ConcreteCommand(receiver);// 客户端只需调用命令的执行方法即可command.Execute();}
}

解释

在上面的示例中,ICommand接口定义了命令的统一执行方法Execute()ConcreteCommand是具体的命令类,通过调用ReceiverAction()方法来实现对请求的处理。客户端通过实例化具体的命令对象,并调用其执行方法来发出请求。

2. 解释器模式(Interpreter)

解释器模式定义了一种语言文法的表示,并定义了一个解释器来解释语言中的句子。

示例代码

// 抽象表达式类
public abstract class AbstractExpression
{public abstract void Interpret(Context context);
}// 终结符表达式类
public class TerminalExpression : AbstractExpression
{public override void Interpret(Context context){Console.WriteLine("解释终结符表达式");}
}// 非终结符表达式类
public class NonterminalExpression : AbstractExpression
{public override void Interpret(Context context){Console.WriteLine("解释非终结符表达式");}
}// 上下文类
public class Context
{public string Input { get; set; }public string Output { get; set; }
}// 客户端类
public class Client
{public void Main(){Context context = new Context();List<AbstractExpression> expressions = new List<AbstractExpression>();expressions.Add(new TerminalExpression());expressions.Add(new NonterminalExpression());foreach (AbstractExpression expression in expressions){expression.Interpret(context);}}
}

解释

在上面的示例中,AbstractExpression是抽象表达式类,由TerminalExpressionNonterminalExpression继承,并分别实现了解释终结符和非终结符表达式的方法。Context类存储解释器的上下文信息。客户端通过实例化具体的解释器对象,并调用其解释方法来实现对句子的解释。

3. 迭代器模式(Iterator)

迭代器模式提供一种顺序访问集合对象元素的方法,而不需要暴露集合对象的内部结构。

示例代码

// 迭代器接口
public interface IIterator<T>
{bool HasNext();T Next();
}// 集合接口
public interface ICollection<T>
{IIterator<T> CreateIterator();
}// 具体集合类
public class ConcreteCollection<T> : ICollection<T>
{private List<T> _items = new List<T>();public void Add(T item){_items.Add(item);}public IIterator<T> CreateIterator(){return new ConcreteIterator<T>(this);}public T GetItem(int index){return _items[index];}public int Count{get { return _items.Count; }}
}// 具体迭代器类
public class ConcreteIterator<T> : IIterator<T>
{private ICollection<T> _collection;private int _position = 0;public ConcreteIterator(ICollection<T> collection){_collection = collection;}public bool HasNext(){return _position < _collection.Count;}public T Next(){T item = _collection.GetItem(_position);_position++;return item;}
}// 客户端类
public class Client
{public void Main(){ICollection<string> collection = new ConcreteCollection<string>();collection.Add("Item 1");collection.Add("Item 2");collection.Add("Item 3");IIterator<string> iterator = collection.CreateIterator();while (iterator.HasNext()){string item = iterator.Next();Console.WriteLine(item);}}
}

解释

在上面的示例中,IIterator<T>定义了迭代器接口,ICollection<T>定义了集合接口,并包含一个创建迭代器的方法CreateIterator()ConcreteCollection<T>是具体的集合类,实现了集合接口,并在CreateIterator()方法中返回具体的迭代器对象ConcreteIterator<T>。客户端通过调用集合的CreateIterator()方法来获取迭代器,并可以通过迭代器的HasNext()Next()方法依次访问集合中的元素。

4. 中介者模式(Mediator)

中介者模式定义了一个中介对象来封装一组对象之间的交互,使得这些对象之间不需要直接相互通信。

示例代码

// 中介者接口
public interface IMediator
{void SendMessage(string message, Colleague colleague);
}// 同事类
public abstract class Colleague
{protected IMediator _mediator;public Colleague(IMediator mediator){_mediator = mediator;}public abstract void ReceiveMessage(string message);public abstract void SendMessage(string message);
}// 具体同事类
public class ConcreteColleagueA : Colleague
{public ConcreteColleagueA(IMediator mediator) : base(mediator) { }public override void ReceiveMessage(string message){Console.WriteLine("Colleague A received: " + message);}public override void SendMessage(string message){_mediator.SendMessage(message, this);}
}public class ConcreteColleagueB : Colleague
{public ConcreteColleagueB(IMediator mediator) : base(mediator) { }public override void ReceiveMessage(string message){Console.WriteLine("Colleague B received: " + message);}public override void SendMessage(string message){_mediator.SendMessage(message, this);}
}// 具体中介者类
public class ConcreteMediator : IMediator
{private ConcreteColleagueA _colleagueA;private ConcreteColleagueB _colleagueB;public void SetColleagueA(ConcreteColleagueA colleagueA){_colleagueA = colleagueA;}public void SetColleagueB(ConcreteColleagueB colleagueB){_colleagueB = colleagueB;}public void SendMessage(string message, Colleague colleague){if (colleague == _colleagueA){_colleagueB.ReceiveMessage(message);}else if (colleague == _colleagueB){_colleagueA.ReceiveMessage(message);}}
}// 客户端类
public class Client
{public void Main(){ConcreteMediator mediator = new ConcreteMediator();ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);mediator.SetColleagueA(colleagueA);mediator.SetColleagueB(colleagueB);colleagueA.SendMessage("Hello from Colleague A!");colleagueB.SendMessage("Hi from Colleague B!");}
}

解释

在上述示例中,IMediator是中介者接口,定义了发送消息的方法SendMessage()Colleague是同事类,每个同事类都持有一个对中介者的引用。ConcreteColleagueAConcreteColleagueB是具体的同事类,实现了同事接口,并在自己的消息发送方法中调用中介者的SendMessage()方法。ConcreteMediator是具体的中介者类,负责将消息转发给其他同事。客户端首先创建中介者对象和同事对象,然后通过设置同事的引用到中介者上,实现同事之间的消息交互。

5. 备忘录模式(Memento)

备忘录模式用于保存和恢复对象的状态,并在不破坏封装性的前提下将对象状态的保存和恢复功能委托给其他对象。

示例代码

// 备忘录类
public class Memento
{public string State { get; private set; }public Memento(string state){State = state;}
}// 发起人类
public class Originator
{public string State { get; set; }public Memento CreateMemento(){return new Memento(State);}public void SetMemento(Memento memento){State = memento.State;}
}// 管理者类
public class Caretaker
{private Memento _memento;public void SaveMemento(Memento memento){_memento = memento;}public Memento RetrieveMemento(){return _memento;}
}// 客户端类
public class Client
{public void Main(){Originator originator = new Originator();Caretaker caretaker = new Caretaker();originator.State = "State 1";caretaker.SaveMemento(originator.CreateMemento());originator.State = "State 2";caretaker.SaveMemento(originator.CreateMemento());originator.State = "State 3";caretaker.SaveMemento(originator.CreateMemento());Memento memento = caretaker.RetrieveMemento();originator.SetMemento(memento);Console.WriteLine(originator.State);  // 输出:State 3}
}

解释

在上述示例中,Memento类是备忘录类,用于存储对象的状态;Originator类是发起人类,负责创建备忘录并根据备忘录恢复对象的状态;Caretaker类是管理者类,负责保存和获取备忘录。客户端通过创建发起人、管理者和备忘录对象,并依次设定发起人的状态并将备忘录保存到管理者中,最后可以通过管理者获取备忘录对象并将状态恢复到该备忘录所代表的状态。

6. 观察者模式(Observer)

观察者模式定义了一种一对多的依赖关系,使得当一个对象的状态发生改变时,其依赖对象都会收到通知并自动更新。

示例代码

// 主题接口
public interface ISubject
{void Attach(IObserver observer);void Detach(IObserver observer);void Notify();
}// 具体主题类
public class ConcreteSubject : ISubject
{private List<IObserver> _observers = new List<IObserver>();private string _state;public string State{get { return _state; }set{_state = value;Notify();}}public void Attach(IObserver observer){_observers.Add(observer);}public void Detach(IObserver observer){_observers.Remove(observer);}public void Notify(){foreach (IObserver observer in _observers){observer.Update();}}
}// 观察者接口
public interface IObserver
{void Update();
}// 具体观察者类
public class ConcreteObserver : IObserver
{private string _name;private ConcreteSubject _subject;public ConcreteObserver(string name, ConcreteSubject subject){_name = name;_subject = subject;}public void Update(){Console.WriteLine($"Observer {_name} received state: {_subject.State}");}
}// 客户端类
public class Client
{public void Main(){ConcreteSubject subject = new ConcreteSubject();ConcreteObserver observerA = new ConcreteObserver("A", subject);ConcreteObserver observerB = new ConcreteObserver("B", subject);subject.Attach(observerA);subject.Attach(observerB);subject.State = "State 1";// 输出:// Observer A received state: State 1// Observer B received state: State 1subject.State = "State 2";// 输出:// Observer A received state: State 2// Observer B received state: State 2subject.Detach(observerB);subject.State = "State 3";// 输出:// Observer A received state: State 3}
}

解释

在上述示例中,ISubject是主题接口,定义了对观察者的操作方法;ConcreteSubject是具体主题类,实现了主题接口,并在状态改变时通知所有观察者。IObserver是观察者接口,定义了观察者的更新方法;ConcreteObserver是具体观察者类,实现了观察者接口,并在收到通知时输出主题的状态。在客户端中,首先创建主题和观察者对象,然后将观察者注册到主题上,最后可以通过改变主题的状态来触发对应观察者的更新。

7. 状态模式(State)

状态模式允许对象在其内部状态发生改变时改变其行为,使得对象看起来像是在修改了其回归类。

示例代码

// 状态接口
public interface IState
{void Handle(Context context);
}// 具体状态类
public class ConcreteStateA : IState
{public void Handle(Context context){Console.WriteLine("State A handling");context.State = new ConcreteStateB();}
}public class ConcreteStateB : IState
{public void Handle(Context context){Console.WriteLine("State B handling");context.State = new ConcreteStateA();}
}// 上下文类
public class Context
{public IState State { get; set; }public Context(IState initState){State = initState;}public void Request(){State.Handle(this);}
}// 客户端类
public class Client
{public void Main(){Context context = new Context(new ConcreteStateA());context.Request();// 输出: State A handlingcontext.Request();// 输出: State B handlingcontext.Request();// 输出: State A handling}
}

解释

在上述示例中,IState是状态接口,定义了状态的处理方法Handle()ConcreteStateAConcreteStateB是具体状态类,实现了状态接口,并根据自身的逻辑处理状态的改变。Context类是上下文类,内部存储当前的状态,并在请求方法Request()中调用当前状态的处理方法。在客户端中,首先创建上下文对象和初始状态对象,然后可以通过调用上下文的请求方法来触发状态的改变,从而导致不同的行为。

8. 策略模式(Strategy)

策略模式定义了一系列的算法,将每个算法都封装起来,并使它们可以相互替换。

示例代码

// 策略接口
public interface IStrategy
{void Execute();
}// 具体策略类
public class ConcreteStrategyA : IStrategy
{public void Execute(){Console.WriteLine("Executing Strategy A");}
}public class ConcreteStrategyB : IStrategy
{public void Execute(){Console.WriteLine("Executing Strategy B");}
}// 上下文类
public class Context
{private IStrategy _strategy;public Context(IStrategy strategy){_strategy = strategy;}public void ExecuteStrategy(){_strategy.Execute();}
}// 客户端类
public class Client
{public void Main(){IStrategy strategyA = new ConcreteStrategyA();IStrategy strategyB = new ConcreteStrategyB();Context context = new Context(strategyA);// 输出: Executing Strategy Acontext.ExecuteStrategy();context = new Context(strategyB);// 输出: Executing Strategy Bcontext.ExecuteStrategy();}
}

解释

在上述示例中,IStrategy是策略接口,定义了算法的执行方法Execute()ConcreteStrategyAConcreteStrategyB是具体策略类,分别实现了策略接口,并提供不同的算法实现。Context类是上下文类,持有一个策略对象,并执行策略对象的算法。客户端首先创建不同的策略对象,然后根据需要将不同的策略对象传递给上下文,并调用上下文的执行方法来执行具体的算法。

9. 模板方法模式(Template Method)

模板方法模式定义了一个操作中的算法框架,将一些步骤延迟到子类中实现。

示例代码

// 抽象类
public abstract class AbstractClass
{public void TemplateMethod(){Console.WriteLine("Template Method - Step 1");PrimitiveOperation1();Console.WriteLine("Template Method - Step 2");PrimitiveOperation2();}protected abstract void PrimitiveOperation1();protected abstract void PrimitiveOperation2();
}// 具体类
public class ConcreteClassA : AbstractClass
{protected override void PrimitiveOperation1(){Console.WriteLine("Concrete Class A - Primitive Operation 1");}protected override void PrimitiveOperation2(){Console.WriteLine("Concrete Class A - Primitive Operation 2");}
}public class ConcreteClassB : AbstractClass
{protected override void PrimitiveOperation1(){Console.WriteLine("Concrete Class B - Primitive Operation 1");}protected override void PrimitiveOperation2(){Console.WriteLine("Concrete Class B - Primitive Operation 2");}
}// 客户端类
public class Client
{public void Main(){AbstractClass abstractClass = new ConcreteClassA();// 输出:// Template Method - Step 1// Concrete Class A - Primitive Operation 1// Template Method - Step 2// Concrete Class A - Primitive Operation 2abstractClass.TemplateMethod();abstractClass = new ConcreteClassB();// 输出:// Template Method - Step 1// Concrete Class B - Primitive Operation 1// Template Method - Step 2// Concrete Class B - Primitive Operation 2abstractClass.TemplateMethod();}
}

解释

在上述示例中,AbstractClass是抽象类,定义了模板方法TemplateMethod(),该方法包含了一系列的步骤,并调用了抽象方法PrimitiveOperation1()PrimitiveOperation2()ConcreteClassAConcreteClassB是具体类,继承自抽象类,并实现了抽象方法。客户端中,首先创建具体类的对象,并调用其模板方法,从而按照固定的步骤执行特定的算法。

10. 访问者模式(Visitor)

访问者模式定义了一种在不改变被访问对象结构的前提下,可以对该对象的元素进行操作的方法。

示例代码

// 元素接口
public interface IElement
{void Accept(IVisitor visitor);
}// 具体元素类
public class ConcreteElementA : IElement
{public void Accept(IVisitor visitor){visitor.VisitConcreteElementA(this);}
}public class ConcreteElementB : IElement
{public void Accept(IVisitor visitor){visitor.VisitConcreteElementB(this);}
}// 访问者接口
public interface IVisitor
{void VisitConcreteElementA(ConcreteElementA element);void VisitConcreteElementB(ConcreteElementB element);
}// 具体访问者类
public class ConcreteVisitor : IVisitor
{public void VisitConcreteElementA(ConcreteElementA element){Console.WriteLine("Visiting Concrete Element A");}public void VisitConcreteElementB(ConcreteElementB element){Console.WriteLine("Visiting Concrete Element B");}
}// 对象结构类
public class ObjectStructure
{private List<IElement> _elements = new List<IElement>();public void AddElement(IElement element){_elements.Add(element);}public void Accept(IVisitor visitor){foreach (IElement element in _elements){element.Accept(visitor);}}
}// 客户端类
public class Client
{public void Main(){ObjectStructure objectStructure = new ObjectStructure();objectStructure.AddElement(new ConcreteElementA());objectStructure.AddElement(new ConcreteElementB());IVisitor visitor = new ConcreteVisitor();objectStructure.Accept(visitor);// 输出:// Visiting Concrete Element A// Visiting Concrete Element B}
}

解释

在上述示例中,IElement是元素接口,定义了对元素的访问方法Accept()ConcreteElementAConcreteElementB是具体元素类,实现了元素接口,并在自己的访问方法中调用访问者的具体访问方法。IVisitor是访问者接口,定义了访问者的具体访问方法;ConcreteVisitor是具体访问者类,实现了访问者接口,并在每个具体访问方法中对元素进行访问。ObjectStructure是对象结构类,包含了需要被访问的元素,并提供对外的访问方法。在客户端中,首先创建对象结构对象和具体元素对象,并将元素对象加入到对象结构中,然后通过创建具体访问者对象来访问对象结构中的元素。


在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/206227.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

什么是网络爬虫技术?它的重要用途有哪些?

网络爬虫&#xff08;Web Crawler&#xff09;是一种自动化的网页浏览程序&#xff0c;能够根据一定的规则和算法&#xff0c;从互联网上抓取和收集数据。网络爬虫技术是随着互联网的发展而逐渐成熟的一种技术&#xff0c;它在搜索引擎、数据挖掘、信息处理等领域发挥着越来越重…

线性分组码的奇偶校验矩阵均匀性分析

回顾信道编解码知识&#xff0c;我们知道信道编码要求编码具有检纠错能力&#xff0c;作为FEC&#xff08;forward error correction&#xff09;前向纠错编码的一类&#xff0c;线性分组码表示校验位与信息位的关系能够线性表示。 在这篇文章中&#xff0c;并不是要讨论信道编…

【古月居《ros入门21讲》学习笔记】09_订阅者Subscriber的编程实现

目录 说明&#xff1a; 1. 话题模型 图示 说明 2. 实现过程&#xff08;C&#xff09; 创建订阅者代码&#xff08;C&#xff09; 配置发布者代码编译规则 编译并运行 编译 运行 3. 实现过程&#xff08;Python&#xff09; 创建订阅者代码&#xff08;Python&…

MYSQL索引使用注意事项

索引使用注意事项&#xff1a; 1.索引列运算 不要在索引列上进行运算操作&#xff0c;否则索引将失效&#xff1b; 2.字符串不加引号 字符串类型使用时&#xff0c;不加引号&#xff0c;否则索引将失效&#xff1b; 3.模糊查询 如果仅仅是尾部模糊匹配&#xff0c;索引将不会失…

WSL中安装的Pycharm如何在Windows的开始菜单中新建图标?或WSL中的Pycharm经常花屏

WSL中安装的Pycharm如何在Windows的开始菜单中新建图标&#xff1f;或WSL中的Pycharm经常花屏 ⚙️1.软件环境⚙️&#x1f50d;2.问题描述&#x1f50d;&#x1f421;3.解决方法&#x1f421;&#x1f914;4.结果预览&#x1f914; ⚙️1.软件环境⚙️ Windows10 教育版64位 W…

【云栖 2023】姜伟华:Hologres Serverless 之路——揭秘弹性计算组

云布道师 本文根据 2023 云栖大会演讲实录整理而成&#xff0c;演讲信息如下&#xff1a; 演讲人&#xff1a;姜伟华 | 阿里云计算平台事业部资深技术专家、阿里云实时数仓 Hologres 研发负责人 演讲主题&#xff1a;Hologres Serverless 之路——揭秘弹性计算组 实时化成为…

牛客算法心得——abb(dp)

大家好&#xff0c;我是晴天学长&#xff0c;传智杯的题&#xff0c;我准备写一个题解&#xff0c;需要的小伙伴可以关注支持一下哦&#xff01;后续会继续更新的。&#x1f4aa;&#x1f4aa;&#x1f4aa; 1) .abb leafee 最近爱上了 abb 型语句&#xff0c;比如“叠词词”、…

【物联网与大数据应用】Hadoop数据处理

Hadoop是目前最成熟的大数据处理技术。Hadoop利用分而治之的思想为大数据提供了一整套解决方案&#xff0c;如分布式文件系统HDFS、分布式计算框架MapReduce、NoSQL数据库HBase、数据仓库工具Hive等。 Hadoop的两个核心解决了数据存储问题&#xff08;HDFS分布式文件系统&#…

【Java学习笔记】75 - 算法优化入门 - 马踏棋盘问题

一、意义 1.算法是程序的灵魂&#xff0c;为什么有些程序可以在海量数据计算时&#xff0c;依然保持高速计算? 2.拿老韩实际工作经历来说&#xff0c;在Unix下开发服务器程序&#xff0c;功能是要支持上千万人同时在线&#xff0c;在上线前&#xff0c; 做内测&#xff0c;一…

常用服务注册中心与发现(Eurake、zookeeper、Nacos)笔记(一)基础概念

基础概念 注册中心 在服务治理框架中&#xff0c;通常都会构建一个注册中心&#xff0c;每个服务单元向注册中心登记自己提供的服务&#xff0c;将主机与端口号、版本号、通信协议等一些附加信息告知注册中心&#xff0c;注册中心按照服务名分类组织服务清单&#xff0c;服务…

OpenGL之Mesa3D编译for Ubuntu20.04(三十六)

简介: CSDN博客专家,专注Android/Linux系统,分享多mic语音方案、音视频、编解码等技术,与大家一起成长! 优质专栏:Audio工程师进阶系列【原创干货持续更新中……】🚀 人生格言: 人生从来没有捷径,只有行动才是治疗恐惧和懒惰的唯一良药. 更多原创,欢迎关注:Android…

vue3中的Fragment、Teleport、Suspense新组件

Fragment组件 在Vue2中: 组件必须有一个根标签 在Vue3中: 组件可以没有根标签, 内部会将多个标签包含在一个Fragment虚拟元素中 好处: 减少标签层级, 减小内存占用 <template><div style"font-size: 14px;"><p> 组件可以没有根标签</p&g…

大数据技术之数据安全与网络安全——CMS靶场(文章管理系统)实训

大数据技术之数据安全与网络安全——CMS靶场(文章管理系统)实训 在当今数字化时代&#xff0c;大数据技术的迅猛发展带来了前所未有的数据增长&#xff0c;同时也催生了对数据安全和网络安全的更为迫切的需求。本篇博客将聚焦于大数据技术背景下的数据安全与网络安全&#xff…

Cascader 级联选择器动态加载数据的回显

如果后端没有只返回第三级的id,而是同时把第三级的名字一起返回了&#xff0c;那么就可以通过下面的方法来实现 1.在级联选择器里面加上这句代码 placeholder"请选择" 2.注册一个字符串 pleasett:"" 3.赋值 如过后端返回的有第三级的选项名 直接进行赋…

解密Kafka主题的分区策略:提升实时数据处理的关键

目录 一、Kafka主题的分区策略概述1.1 什么是Kafka主题的分区策略&#xff1f;1.2 为什么分区策略重要&#xff1f; 二、Kafka默认分区策略2.1 Round-Robin分区策略 三、自定义分区策略3.1 编写自定义分区器3.2 最佳实践&#xff1a;如何选择分区策略 四、分区策略的性能考量4.…

【JS Promise, Promise.all 与 async/await用法详解】

目录 PromisePromise基本使用Promise可进行连续回调Promise回调可接受入参1.工作原理 async/await总结参考文档&#xff1a; 异步 let a 0setTimeout(() > {a 1}, 1000)console.log(a) // 0此时这个延迟就成为异步执行的了&#xff0c;a值还没有变1就被使用输出&#xff0…

element table滚动到底部加载数据(vue3)

效果图 使用插件el-table-infinite-scroll npm install --save el-table-infinite-scroll局部导入 <template><div class"projectTableClass"><el-table v-el-table-infinite-scroll"load"></el-table></div> </temp…

C#,《小白学程序》第二十七课:大数四则运算之“运算符重载”的算法及源程序

1 文本格式 using System; using System.Text; using System.Collections; using System.Collections.Generic; /// <summary> /// 大数的四则&#xff08;加减乘除&#xff09;运算 /// 及其运算符重载&#xff08;取余数&#xff09; /// </summary> public cl…

海外热门:香港服务器和美国服务器的成本较量

​  提到 2023 年海外热门服务器&#xff0c;在整个 IDC 站长圈中&#xff0c;要数香港服务器和美国服务器的关注度一直居高不下。其实也正常&#xff0c;毕竟这两种海外服务器相较成熟。不过&#xff0c;在实际使用中&#xff0c;两者也会被拿来对比&#xff0c;最显而易见的…

WordPress安装AWS插件实现文本转语音功能

适用于 WordPress 的 AWS 插件示例演示了内容创建者如何轻松地为所有书面内容添加文本转语音功能。随着语音搜索的不断增加&#xff0c;以音频格式提供更多网站内容变得至关重要。通过添加语音功能&#xff0c;网站访客可以通过在线音频播放器和播客应用程序等新渠道使用您的内…