在 foreach 循环中使用基类时调用派生类方法

Question

我有以下代码，它简单地遍历一个 EdiElements 列表并验证每个元素以确保它符合定义为派生类属性的一组规则。

我遇到的问题是elem.Validate() 行调用基类方法而不是派生类方法。 _elements 列表包含所有从 EdiElement 派生的不同类，我需要能够遍历它们并在每个类中执行验证规则。

如下例所示，在 foreach 循环中使用基类作为迭代器变量时，调用派生类方法的标准方法是什么？

public override bool Validate()
{
  foreach ( EdiElement elem in _elements )
  {
    if ( !_checkElementIsValid( this, elem ) )
      base.ValidationErrors.Add( string.Format( "Element {0} does not belong to segment {1}", this.GetType().Name, this.GetType().Name ) );
    else
      elem.Validate(); // <-- I want this to call derived class method
  }

  return base.ValidationErrors.Count == 0;
}

已编辑以显示类定义。

public abstract class EdiElement : Edi
{
  public override bool Validate()
  {
    return true; // breakpoint here gets hit
  }
}

public abstract class EdiDataElement<T> : EdiElement
{
  public T Value { get; set; }
}

public class E3286 : EdiDataElement<String>
{
  public override bool Validate()
  {
    return base.Validate(); // breakpoint here does not get hit!
  }
}

我忘记添加基类了。

public abstract class Edi
{
    protected static List<string> _validationErrors = new List<string>();

    public List<string> ValidationErrors
    {
        get
        {
            return _validationErrors;
        }
    }

    public abstract bool Validate();
}

Answer 1

我在更改EdiElement 后设法解决了它，以便它在Validate() 方法中定义一个abstract override，然后在派生类中覆盖它。代码现在以我预期的方式正确执行。

public override bool Validate()
{
  foreach ( EdiElement elem in _elements )
  {
    if ( !_checkElementIsValid( this, elem ) )
      base.ValidationErrors.Add( string.Format( "Element {0} does not belong to segment {1}", this.GetType().Name, this.GetType().Name ) );
    else
      elem.Validate(); // <-- I want this to call derived class method
  }

  return base.ValidationErrors.Count == 0;
}

public abstract class EdiElement : Edi
{
  public abstract override bool Validate();
}

public abstract class EdiDataElement<T> : EdiElement
{
  public T Value { get; set; }
}

/// <summary>
///  To specify a component of an address.
/// </summary>
[DataElementMetadata(
    Name = "Address component",
    Description = "To specify a component of an address.",
    Type = Types.Type.an,
    Length = "0..70" )]
public class E3286 : EdiDataElement<String>
{
    public override bool Validate()
    {
        base.ValidationErrors.Add( "Validation error!" );
        return false;
    }
}

我要感谢社区为我指明了正确的方向，因为我确信自己做错了。

Answer 2

我认为发生了什么（尽管有调试构建和设置）编译器正在优化对 base.Validate() 的调用，这就是没有命中断点的原因。

以下（根据原始课程设计）对我来说是正确的：

A x = new D();
x.Test();

public abstract class A
{
    public abstract void Test();
}

public abstract class B : A
{
    public override void Test()
    {
        Console.WriteLine("Test() in B");
    }
}

public abstract class C<T> : B
{

}

public class D : C<String>
{
    public override void Test()
    {
        base.Test(); //breakpoint hits here
    }
}

Answer 3

这是... C# 的一个特点。

如果定义了一个基类并从它继承，则默认行为是，当一个实例向上转换为基类时，被覆盖的方法将恢复为被覆盖方法的基类实现，除非该覆盖被显式标记为关键字override。

如果你问我，这违反了 O-O 编程的基本原则（如果你称它为动物，狗并不会停止成为狗）。就我个人而言，我认为 C# 的设计者在决定这种行为时被坑了，但我离题了。

例如这个程序：

class Animal         { public virtual  void Speak() { Console.WriteLine("Most animals make some sort of noise.") ; } }
class Dog : Animal   { public virtual  void Speak() { Console.WriteLine("Dog: Woof!") ; } }
class Cat : Animal   { public new      void Speak() { Console.WriteLine("Meow!") ; } }
class Sheep : Animal { public override void Speak() { Console.WriteLine("Baaa!") ; } }

static void Main( string[] args )
{
  Animal[] menagerie = { new Animal() , new Dog() , new Cat() , new Sheep() , } ;

  foreach ( Animal creature in menagerie )
  {
    Console.Write( "{0}:\t" , creature.GetType().Name ) ;
    creature.Speak() ;
  }

  return;
}

产生这个输出：

Animal: Most animals make some sort of noise.
Dog:    Most animals make some sort of noise.
Cat:    Most animals make some sort of noise.
Sheep:  Baaa!

此功能意味着在 C# 程序中，要获得通常预期的行为，开发人员需要额外的工作。除非另有特殊要求，否则始终使用abstract/virtual 和override 是一种很好的做法。