• c#设计模式-行为型模式 之 访问者模式

    🚀简介

    封装一些作用于某种数据结构中的各元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。
    访问者模式包含以下主要角色 :
    1. 抽象访问者（Visitor）角色：定义了对每一个元素 （Element） 访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素类个数（Element的实现类个数）是一样的，从这点不难看出，访问者模式要求元素类的个数不能改变。
    2. 具体访问者（ConcreteVisitor）角色：给出对每一个元素类访问时所产生的具体行为。
    3. 抽象元素（Element）角色：定义了一个接受访问者的方法（ accept ），其意义是指，每一个元素都要可以被访问者访问。
    4. 具体元素（ConcreteElement）角色： 提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法。
    5. 对象结构（Object Structure）角色：定义当中所提到的对象结构，对象结构是一个抽象表述，具体点可以理解为一个具有容器性质或者复合对象特性的类，它会含有一组元素（ Element ），并且可以迭代这些元素，供访问者访问。

    🚀案例

    我们就以养宠物为例，宠物分别有狗和猫，要给宠物喂食的话，主人可以喂，其他人也可以喂食。
    • 访问者角色：给宠物喂食的人
    • 具体访问者角色：主人、其他人
    • 抽象元素角色：动物抽象类
    • 具体元素角色：宠物狗、宠物猫
    • 结构对象角色：主人家

    🐤创建抽象访问者接口 

    1. public interface Person {
    2.     void Feed(Cat cat);
    3.     void Feed(Dog dog);
    4. }
    🐤创建不同的具体访问者角色（主人和其他人），都需要实现 Person 接口 
    1. //主人
    2. public class Owner : Person
    3. {
    4.     public void Feed(Cat cat)
    5.     {
    6.         Console.WriteLine("主人喂食猫");
    7.     }
    8.  
    9.     public void Feed(Dog dog)
    10.     {
    11.         Console.WriteLine("主人喂食狗");
    12.     }
    13. }
    14.  
    15. //其他人
    16. public class Someone : Person
    17. {
    18.     public void Feed(Cat cat)
    19.     {
    20.         Console.WriteLine("其他人喂食猫");
    21.     }
    22.  
    23.  
    24.     public void Feed(Dog dog)
    25.     {
    26.         Console.WriteLine("其他人喂食狗");
    27.     }
    28. }
    🐤定义抽象节点 -- 宠物 
    1. public interface IAnimal {
    2.     void Accept(Person person);
    3. }

    🐤定义实现 Animal 接口的 具体节点（元素）

    1. public class Dog:IAnimal
    2. {
    3.     public void Accept(Person person)
    4.     {
    5.         person.Feed(this);
    6.         Console.WriteLine("好吃！汪汪汪");
    7.     }
    8. }
    9.  
    10. public class Cat:IAnimal
    11. {
    12.     public void Accept(Person person)
    13.     {
    14.         person.Feed(this);
    15.         Console.WriteLine("好吃！喵喵喵");
    16.     }
    17. }
    🐤定义对象结构，此案例中就是主人的家 
    1. public class Home
    2. {
    3.     private readonly List _nodeList = new List();
    4.  
    5.     public void Action(Person person)
    6.     {
    7.         foreach (var node in _nodeList)
    8.         {
    9.             node.Accept(person);
    10.         }
    11.     }
    12.  
    13.     //添加操作
    14.     public void Add(IAnimal animal)
    15.     {
    16.         _nodeList.Add(animal);
    17.     }
    18. }

    🐳测试类

    1. class MyClass
    2. {
    3.     public static void Main(string[] args)
    4.     {
    5.         Home home = new Home();
    6.         home.Add(new Dog());
    7.         home.Add(new Cat());
    8.         
    9.         Owner owner = new Owner();
    10.         home.Action(owner);
    11.         
    12.         Someone someone = new Someone();
    13.         home.Action(someone);
    14.     }
    15. }

    👻运行结果!

    🚀优缺点

    优点：
    • 扩展性好
      • 在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。
    • 复用性好
      • 通过访问者来定义整个对象结构通用的功能，从而提高复用程度。
    • 分离无关行为
      • 通过访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每一个访问者的功能都比较单一。
    缺点：
    • 对象结构变化很困难
      • 在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。
    • 违反了依赖倒置原则
      • 访问者模式依赖了具体类，而没有依赖抽象类。
    使用场景：
    1. 对象结构相对稳定，但其操作算法经常变化的程序。
    2. 对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。
  • 相关阅读:
    现代 ERP 系统，如何使中小企业智能制造商受益？
    1行Python代码实现：PDF转Word。
    SQL ZOO —— 7 JOIN Quiz
    【cmake】利用cmake的add_subdirectory管理内部和外部库
    数据库概论 - MySQL的简单介绍
    Mybatis-plus 使用
    频频刷屏朋友圈，白酒如何越来越年轻化？来聊聊白酒企业数字化
    BUUCTF Misc 隐藏的钥匙 & 另外一个世界 & FLAG & 神秘龙卷风
    upload-labs通关(Pass11-Pass15)
    【Python+selenium】自动化生成测试报告
  • 原文地址：https://blog.csdn.net/weixin_65243968/article/details/133847262