使用泛型类型时，如何从继承的类而不是基类中调用方法？

Question

I have a base class which implemnts DependsOn()

public class Entity
{
    protected Entity() { }

    public virtual List<Type> DependsOn()
    {
        return new List<Type>();
    }
}

I've extended this base class.

public class Waveform : Entity
{
    public virtual new List<Type> DependsOn()
    {
        return new List<Type> {typeof(Scenario)};
    }
}

I would expect the following code to return "new List {typeof(Scenario)}", instead it returns a empty list (its calling the DependsOn method from the base class, instead of the inherited class. I verified this with a debugger as well.)

public virtual List<Entity> FindParents<T>(T possibleChild) where T : Entity
{
    List<Type> dependsOnTypes = possibleChild.DependsOn();
}

public void DeleteEntity<T>(T entity) where T : Entity
{
    List<Entity> parents = FindParents<T>(entity);
}

Waveform waveform = new Waveform();
DeleteEntity<Waveform>(waveform);

Answer 1

Use override instead of virtual new .

virtual new creates a new slot and defines a new function that is itself virtual but doesn't share the vtable slot with its base class.

Every time you use the new keyword on a function, you should think of it as being unrelated to the function with the same name in the base class. new allows you to completely change the signature of the function for instance.

Answer 2

You haven't really extended the base class, you created a new method with the same name. Use the override keyword as follows:

public class Waveform : Entity
{
    public override List<Type> DependsOn()
    {
        return new List<Type> {typeof(Scenario)};
    }
}

Answer 3

Why you need override in this case instead of new is, the method is called from the base class object which contains child class at runtime. Actual passed element is of type Entity type, which gets filled up with waveform at runtime, but at runtime, Entity object is not aware of any override, since the child class implementation is hiding base class implementation.

In original format only way to call the correct method that you want is by using the Waveform object, instead of entity, it will then call the correct version, as shown below:

 class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();
            Waveform waveform = new Waveform();
            p.DeleteEntity<Waveform>(waveform);
        }

        public void DeleteEntity<T>(T entity) where T : Waveform
        {
            List<Entity> parents = FindParents<T>(entity);
        }

        public virtual List<Entity> FindParents<T>(T possibleChild) where T : Waveform
        {
            List<Entity> dependsOnTypes = possibleChild.DependsOn();
            return dependsOnTypes;
        }        
    }

    public class Entity
    {
        protected Entity() { }

        public virtual List<Entity> DependsOn()
        {
            return new List<Entity>();
        }
    }

    public class Waveform : Entity
    {
        public virtual new List<Entity> DependsOn()
        {
            return new List<Entity> { new Scenario() };           
        }
    }

    public class Scenario: Entity
    {
        int x;
        float y;
    }