C# 访问者模式：灵活扩展对象行为，告别硬编码

在软件开发中，我们经常面临需要在不修改已有对象结构的前提下，为其添加新的行为。例如，一个公司的人员（员工、经理、兼职）都有接受涨薪、接受裁员等行为，但这些行为的具体实现可能根据人员类型而异。如果每次新增行为都修改现有类，会导致代码臃肿、难以维护，并且违反了开闭原则。这时，C# 的访问者模式就能派上用场。

想象一下，公司组织结构调整，HR需要对不同类型的员工进行不同的操作，比如统计工作时长、绩效评估、发放奖金等。如果直接在Employee父类或者各个子类中添加这些方法，会导致类变得越来越臃肿，而且每增加一种操作，都需要修改所有Employee及其子类，违反了开闭原则，也增加了维护成本。这就像使用Nginx做反向代理时，配置都写在一个文件里，导致配置文件过于庞大，不易管理。

访问者模式：原理剖析与角色定义

访问者模式的核心思想是将算法与对象结构分离，使得可以在不修改对象结构的前提下，动态地定义作用于这些对象的操作。访问者模式涉及以下几个角色：

• Element (元素)：定义一个 Accept 方法，接受一个访问者对象作为参数。
• ConcreteElement (具体元素)：实现 Accept 方法，通常是调用访问者的 Visit 方法，并将自身作为参数传递给访问者。
• Visitor (访问者)：定义一个 Visit 方法，针对每一个具体元素类型提供一个重载版本。
• ConcreteVisitor (具体访问者)：实现 Visit 方法，定义针对具体元素的操作。
• ObjectStructure (对象结构)：负责管理元素集合，并提供遍历元素的方法，通常是一个 List 或其他集合。

访问者模式通过双重分派实现，即先确定访问者，再确定被访问的元素，从而执行特定的操作。

模式优势

• 符合开闭原则：可以在不修改现有类的情况下，添加新的操作。
• 将算法与对象结构分离：降低了类之间的耦合度。
• 增加新的操作变得容易：只需要添加新的访问者即可。

模式缺点

• 增加新的元素类型困难：需要修改所有的访问者类。
• 可能破坏元素的封装性：访问者需要访问元素的内部状态。

C# 代码示例：实现薪资调整

以下是一个简单的 C# 代码示例，演示如何使用访问者模式来实现薪资调整：

// Element 接口
public interface IEmployee
{
    void Accept(IVisitor visitor);
    string Name { get; set; }
    double Salary { get; set; }
}

// ConcreteElement 类
public class Employee : IEmployee
{
    public string Name { get; set; }
    public double Salary { get; set; }

    public Employee(string name, double salary)
    {
        Name = name;
        Salary = salary;
    }

    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this); // 双重分派
    }
}

public class Manager : IEmployee
{
    public string Name { get; set; }
    public double Salary { get; set; }

    public Manager(string name, double salary)
    {
        Name = name;
        Salary = salary;
    }

    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this); // 双重分派
    }
}

// Visitor 接口
public interface IVisitor
{
    void Visit(Employee employee); // 针对 Employee 的操作
    void Visit(Manager manager);  // 针对 Manager 的操作
}

// ConcreteVisitor 类
public class SalaryRaiseVisitor : IVisitor
{
    private double _raisePercentage;

    public SalaryRaiseVisitor(double raisePercentage)
    {
        _raisePercentage = raisePercentage;
    }

    public void Visit(Employee employee)
    {
        employee.Salary *= (1 + _raisePercentage); // 员工涨薪逻辑
        Console.WriteLine($"Employee {employee.Name}'s salary raised to {employee.Salary}");
    }
    public void Visit(Manager manager)
    {
        manager.Salary *= (1 + _raisePercentage * 1.2); // 经理涨薪逻辑，更高
        Console.WriteLine($"Manager {manager.Name}'s salary raised to {manager.Salary}");
    }
}

// ObjectStructure 类
public class EmployeeList
{
    private List<IEmployee> _employees = new List<IEmployee>();

    public void AddEmployee(IEmployee employee)
    {
        _employees.Add(employee);
    }

    public void Accept(IVisitor visitor)
    {
        foreach (var employee in _employees)
        {
            employee.Accept(visitor);
        }
    }
}

// 客户端代码
public class Client
{
    public static void Main(string[] args)
    {
        EmployeeList employees = new EmployeeList();
        employees.AddEmployee(new Employee("Alice", 50000));
        employees.AddEmployee(new Manager("Bob", 80000));

        SalaryRaiseVisitor raiseVisitor = new SalaryRaiseVisitor(0.1);
        employees.Accept(raiseVisitor);
    }
}

实战避坑：访问者模式的注意事项

1. 元素类型稳定时适用：如果元素类型经常变化，频繁修改访问者类会增加维护成本。
2. 注意封装性：避免访问者过度依赖元素的内部状态，尽量通过接口或公共属性进行访问。
3. 避免过度设计：只有在确实需要动态添加操作，并且对象结构相对稳定时才考虑使用访问者模式。过度使用会导致代码复杂性增加，反而降低可维护性。
4. 考虑性能：双重分派会带来一定的性能开销，在性能敏感的场景下需要谨慎使用。可以考虑使用缓存等技术来优化性能，就像使用Redis缓存高频访问数据一样。

总结

C# 的访问者模式是一种强大的设计模式，可以有效地解决对象行为扩展的问题。通过将算法与对象结构分离，可以提高代码的灵活性和可维护性。但是，也需要注意其缺点和适用场景，避免过度设计。希望本文能够帮助你更好地理解和应用访问者模式。