从 C# 中的方法返回通用 class 的实例

Question

I have a template class:

public abstract class Base<T> where T : IConvertible {}

And derived classes:

public enum Vals1{}

public class Der1: Base<Vals1> {}


public enum Vals2{}

public class Der2: Base<Vals2> {}

I want to write a method that returns instance of Der1 or Der2 but I don't know which.

I tried something like this:

private Base<T> GetDer() where T : IConvertible
{
    if (condition)
        return new Der1();
    return new Der2();
}

But I get errors:

Cannot implicitly convert type 'Der1' to 'Base<T>'
Cannot implicitly convert type 'Der2' to 'Base<T>'

Casting doesn't help either. It returns the same error, just without word "implicitly".

Is there a way to do what I want simply or do I have to find some other more strenuous way?

Thanks in advance for any help.

Answer 1

If you create an additional Base class which is not generic, then you could inherit Base<T> from it.

public abstract class Base {}

public abstract class Base<T> : Base where T : IConvertible {}

Then your method becomes:

private Base GetDer()
{
    if (condition)
        return new Der1();
    return new Der2();
}

This is about finding or adding a common ancestor in the inheritance hierarchy (that is not object ...). Of course, you lose information this way because you lose type information when calling GetDer() .

• If the methods you wish to call later on your returned object do not require a value for T , then you should move those methods up from Base<T> to the Base class so that you can still use them.

• If the methods you wish to call require a defined T , then I don't see another way than using some reflection to deduce the type of T at run-time or using the dynamic keyword to by-pass compile-time checks:

public abstract class Base<T> : Base where T : IConvertible {
    abstract void MethodFromBaseT();
}

...

dynamic myObject = GetDer();
myObject.MethodFromBaseT(); //does compile

Note that you have to use dynamic because the returned type is basically unknown, because as said in the comments, two different Base<T> with different T are two distinct types that do not inherit each other.