方法重载和继承——如何找到正确的方法？

Question

我有以下工厂：

public class ChildFactory : IChildFactory {
    public Child? GetChild(ChildType childType)
    {
        switch (childType)
        {
            case ChildType.Boy:
                return new BoyChild() { };
            case ChildType.Girl:
                return new GirlChild() { };
            case ChildType.Undecided:
                return new UndecidedChild() { };
            default:
                return null;
         }
    }
}

每当我通过ChildType 以生成Child 时，我都会返回正确的孩子实例：

Child? child = _childFactory.GetChild((ChildType)Enum.Parse(typeof(ChildType), childDto.Type));

似乎在这一点上，child 是正确的类型（比如说BoyChild）。 现在我想使用方法重载分别动态验证每个子类型。界面如下：

public interface IChildValidator
    {
        public ValidationResult Validate(BoyChild child);
        public ValidationResult Validate(GirlChild child);
        public ValidationResult Validate(UndecidedChild policy);
    }

但是每当我尝试在上面的方法中使用它时，我都会收到错误CS1503: Cannot convert from 'Child' to 'BoyChild'。

我想我应该以不同的方式声明 child，说“它可以是任何子类型”，但我不知道该怎么做。

提前致谢。

Answer 1

Overload Resolution 发生在编译时。 C# 编译器使用参数的静态类型来查找最佳重载。由于您使用Child 类型的参数调用该方法，因此编译器找不到匹配的重载。这三个重载都没有Child 类型的参数。没有从Child 到BoyChild、GirlChild 或UndecidedChild 的隐式转换。您可以将派生类分配给基类，但不能反过来。

要走的路，是使用多态，即在（抽象的）Child 类中添加一个抽象的Validate 方法（除非您可以在基类中提供标准实现）。然后派生类必须重写此方法并提供实现。在运行时，Dynamic dispatch 将调用正确的实现。

Answer 2

根据您寻求的分离级别，您可以尝试这样的方法来将验证逻辑保留在您的子模型之外（这只是一个示例，有几种方法可以调整它，例如设置验证器的方式) :

public class ChildFactory : IChildFactory
{
    public Child? GetChild(ChildType childType)
    {
        switch (childType)
        {
            case ChildType.Boy:
                return new BoyChild(new BoyValidator()) { };
            case ChildType.Girl:
                return new GirlChild(new GirlValidator()) { };
            case ChildType.Undecided:
                return new UndecidedChild(new UndecidedValidator()) { };
            default:
                return null;
        }
    }
}


public interface IChildValidator
{
    ValidationResult Validate(Child child);
}

public interface IChildValidatable
{
    ValidationResult Validate();
}


public class BoyValidator: IChildValidator
{
    ...
}


public class Child: IChildValidatable
{
    public Child(IChildValidator validator)
    {
        Validator = validator;
    }

    protected IChildValidator Validator { get; }


    public ValidationResult Validate() => Validator(this);
}

如果您喜欢使用特定类而不是基类的“准备覆盖”类/函数，您可以改进前面的示例。它有时对验证覆盖很有用，因为无论如何您都可能会强制转换 Child。同样，这只是一个简单的示例，Validate(Child child) 函数可能会在传递给 TypedValidate 之前执行一些通用检查和附加类检查。

public abstract class ChildValidator<T>: IChildValidator where T: Child
{
    public ValidationResult Validate(Child child) => TypedValidate(child as T)

    protected abstract ValidationResult TypedValidate(T child);
}

和

public class BoyValidator: ChildValidator<BoyValidator>
{
    protected override ValidationResult TypedValidate(BoyValidator child)
    {
        ...
    }
}

Answer 3

要解决您的问题，您可以为您的子验证器使用抽象类而不是接口：

public abstract class ChildValidator
{
    public ValidationResult Validate(Child child)
    {
       switch(child)
       {
         case BoyChild boyChild:
            return Validate(boyChild);
         case GirlChild girlChild:
            return Validate(girlChild);
         case UndecidedChild undecided:
            return Validate(undecided);
         default:
            throw new Exception(child.GetType() + " is not supported");
       }
    }

    protected abstract ValidationResult Validate(BoyChild child);
    protected abstract ValidationResult Validate(GirlChild child);
    protected abstract ValidationResult Validate(UndecidedChild policy);
}

但我不推荐这种解决方案。如果您检查变量的类型，这通常（并非总是）表明您做错了。相反，我建议将验证逻辑放在您的子类中：

public abstract class Child
{
    public abstract ValidationResult Validate();
}

这有几个优点：如果您添加一个新的子子类，您不必记住还要在您的ChildValidator 及其所有子类中添加这个类。这使得扩展代码的行为变得更容易，这也称为开闭原则。此外，我猜您的验证确实检查了您孩子的某些属性。如果您添加一个属性，您可能还必须更改您的验证方法。使用第二种方法，这些变化将集中在一个地方。