在实现的抽象类中强制转换泛型类型

Question

I wanted to create an abstract class with an abstract method that takes a generic type. My implementing class method will do something with that type but because its generic I dont have access to the properties of the real object thats passed in the method. If I try casting then it won't compile as you cant cast back to a T type. An example of my meaning.

public abstract class TestAbstractClass
{
    public abstract void Method<T>(ref IQueryable<T> query);
}

public class TestA:TestAbstractClass
{
   // T in this class is an object with a property called Forename
   public override void Method<T>(ref IQueryable<T> query)
   {
       query = query.OrderBy(o=>o.Forename); // unaware of property forename
       query = ((IQueryable<Person>)query).OrderBy(o=>o.Forename); // breaks because of casting
   }
}

public class TestB:TestAbstractClass
{
   // T in this class is an object with a property called HandSize
   public override void Method<T>(ref IQueryable<T> query)
   {
       query = query.OrderBy(o=>o.HandSize); // unaware of property
       query = ((IQueryable<Glove>)query).OrderBy(o=>o.HandSize); // breaks because of casting
   }
}

I hope this makes sense and I'm not being stupid.

Cheers

Answer 1

A solution could be:

public abstract class TestAbstractClass<T>
{
    protected virtual void Method(ref IQueryable<T> query)
    {
    }
}

class TestA : TestAbstractClass<Person>
{
    protected override void Method(ref IQueryable<Person> query)
    {
        var q = query.OrderBy(p => p.Forename);
    }
}

Answer 2

That code is fragile as it's easy to break it. No one can tell by looking at that method that the sub class only allows one type of entity.

There is a principle called Liskovs Substitution Principle which says that any method that takes a base class should be able to work with any kind of subclass. In this case the <T> specifier could be compared to object .

I think that you meant to do this:

public abstract class TestAbstractClass<T>
{
    public abstract void Method(ref IQueryable<T> query);
}

public class TestA : TestAbstractClass<Person>
{
   // T in this class is an object with a property called Forename
   public override void Method(ref IQueryable<T> query)
   {
       query = query.OrderBy(o=>o.Forename); // unaware of property forename
   }
}

public class TestB:TestAbstractClass<Glove>
{
   // T in this class is an object with a property called HandSize
   public override void Method(ref IQueryable<T> query)
   {
       query = query.OrderBy(o=>o.HandSize); // unaware of property
   }
}

The difference is that you specify that the entire class can only work with one type of entity which allows you to get intellisense etc.