如何让独立类无分支操作同基类的不同子类对象？

嘿，这个问题太典型了——你既想守住单一职责原则（不让Person这类领域类掺和持久化的事儿），又想干掉那种破坏多态的if/else类型判断，其实你需要的是访问者模式，或者更轻量的DAO工厂模式，下面给你一步步拆解清楚：

问题根源分析 #

你之前的困境很清晰：

• 让Person自带Save方法？违反单一职责，领域类就该管自身属性，不该碰数据库操作；
• 直接在循环里判断类型？完全抛弃了多态，新增子类就得改循环逻辑，违反开闭原则。

核心矛盾是：要针对不同Person子类执行特定操作，但又不想让操作逻辑和领域类耦合，也不想写丑陋的分支判断。

方案一：访问者模式（推荐用于需扩展多种操作的场景） #

访问者模式完美解决了「给不同类型对象执行不同操作，同时解耦操作和对象本身」的问题，具体实现步骤如下：

1. 定义访问者接口 #

这个接口里要为每个Person子类定义对应的处理方法：

public interface IPersonVisitor
{
    void VisitPerson(Person person);
    void VisitEmployee(Employee employee);
    void VisitCustomer(Customer customer);
}

2. 给Person类添加Accept方法 #

让每个子类通过重写Accept方法，把自己“交给”访问者处理：

public class Person 
{ 
    public string Name; 
    // 基类默认实现，交给访问者的VisitPerson方法
    public virtual void Accept(IPersonVisitor visitor)
    {
        visitor.VisitPerson(this);
    }
}

public class Employee : Person 
{ 
    public int EmployeeID; 
    // 子类重写，把自己强类型传给访问者的VisitEmployee
    public override void Accept(IPersonVisitor visitor)
    {
        visitor.VisitEmployee(this);
    }
}

public class Customer : Person 
{ 
    public int CustomerID; 
    public override void Accept(IPersonVisitor visitor)
    {
        visitor.VisitCustomer(this);
    }
}

3. 实现保存操作的访问者 #

把原来分散在循环里的DAO调用逻辑，封装到访问者类中：

public class PersonSaveVisitor : IPersonVisitor
{
    // 依赖注入各个DAO，避免硬编码实例化
    private readonly PersonDao _personDao;
    private readonly EmployeeDao _employeeDao;
    private readonly CustomerDao _customerDao;

    public PersonSaveVisitor(PersonDao personDao, EmployeeDao employeeDao, CustomerDao customerDao)
    {
        _personDao = personDao;
        _employeeDao = employeeDao;
        _customerDao = customerDao;
    }

    public void VisitPerson(Person person)
    {
        _personDao.Save(person);
    }

    public void VisitEmployee(Employee employee)
    {
        // 这里直接用强类型的Employee，无需强制转换，更安全
        _employeeDao.Save(employee);
    }

    public void VisitCustomer(Customer customer)
    {
        _customerDao.Save(customer);
    }
}

4. 改造原来的循环逻辑 #

现在循环里完全没有分支，直接调用Accept方法即可：

// 初始化访问者，传入已有的DAO实例
var saveVisitor = new PersonSaveVisitor(personDao, employeeDao, customerDao);

foreach (Person person in people)
{
    person.Accept(saveVisitor);
}

为什么这个方案靠谱？

• 领域类（Person/Employee/Customer）依然只负责自身属性，完全不涉及持久化，严格遵守单一职责；
• 彻底消除了类型判断分支，利用多态的Accept方法自动分发到对应的处理逻辑；
• 未来新增Person子类时，只需要在IPersonVisitor加对应的Visit方法、子类重写Accept、扩展Visitor即可，完全符合开闭原则；
• 如果以后需要给Person子类加其他操作（比如导出、打印），只需要新增一个IPersonVisitor的实现类，无需修改领域类。

方案二：DAO工厂模式（轻量简洁，适合操作单一的场景） #

如果你的场景里只需要给Person子类做保存这一种操作，不想引入访问者模式的复杂度，那么DAO工厂模式会更简单：

1. 创建DAO工厂类 #

集中管理Person类型到对应DAO的映射：

public static class PersonDaoFactory
{
    public static PersonDao GetDaoForPerson(Person person)
    {
        // 用C# 8+的switch表达式，比if/else更简洁
        return person switch
        {
            Employee => new EmployeeDao(),
            Customer => new CustomerDao(),
            _ => new PersonDao()
        };
    }
}

2. 改造循环逻辑 #

直接通过工厂获取对应DAO，然后调用Save：

foreach (Person person in people)
{
    var dao = PersonDaoFactory.GetDaoForPerson(person);
    dao.Save(person);
}

注意点：

这个方案的缺点是新增Person子类时需要修改工厂类的switch逻辑，违反开闭原则。但如果你的子类不会频繁新增，这个方案足够轻量高效。

额外优化建议 #

你原来的DAO类的Save方法参数是Person，其实可以改成对应的子类，比如让EmployeeDao的Save接受Employee类型，这样可以避免强制转换，更类型安全：

public class EmployeeDao : PersonDao 
{ 
    // 新增强类型的Save方法
    public void Save(Employee employee)
    { 
        // 直接使用employee.EmployeeID，无需转换
        Console.WriteLine($"保存员工：{employee.Name}，ID：{employee.EmployeeID}");
    } 

    // 保留基类的Save方法做兼容（或者标记为Obsolete）
    public override void Save(Person person)
    {
        Save((Employee)person);
    }
}

内容的提问来源于stack exchange，提问作者user2075962