c＃中Factory类中的泛型类型实例化

Question

I have this structure

public class Base<T>
{

}

public class A : Base<string>
{

}

public class B : Base<int>
{

}

public class Factory
{
    public Base<T> GetInstance<T>(int type)
    {
        if (type == 0)
            return new A();
        else
            return new B();
    }
}

but I get compile error about Cannot convert expression type B to return type Base<T> , why I get this error? and how can I fix it?

Answer 1

why I get this error?

You are getting this error because the compiler cannot verify at compile time that T is string when type is 0 or that T is int otherwise. As far as the compiler is concerned, T could be any type.

and how can I fix it?

You need to cast the result to Base<T> like this:

public class Factory
{
    public Base<T> GetInstance<T>(int type)
    {
        if (type == 0)
            return new A() as Base<T>;
        else
            return new B() as Base<T>;
    }
}

Which will cause this method to return null if T is not the correct type.

The following alternative will throw a InvalidCastException exception if T is not the correct type:

public class Factory
{
    public Base<T> GetInstance<T>(int type)
    {
        if (type == 0)
            return (Base<T>)(object)new A();
        else
            return (Base<T>)(object)new B();
    }
}

Another approach that might work for you (depending on your requirements) is to remove the type parameter and to depend completely on T to determine the type of object that you need to return. Here is an example:

public Base<T> GetInstance<T>()
{
    if (typeof(T) == typeof(string))
        return (Base<T>)(object)new A();
    else if(typeof(T) == typeof(int))
        return (Base<T>)(object)new B();

    throw new ArgumentException("Unsupported type T");
}

Answer 2

Your method is not generic because you're returning a non-generic type based on the type that's passed in (whether you use a code for the type or the actual type). At best you could define a relationship between the type passed in and the return type:

public Base<T> GetInstance<T>()
{
    if (typeof(T) == typeof(int))
        return new A() as Base<T>;
    else if (typeof(T) == typeof(string))
        return new B() as Base<T>;
    throw new ArgumentException("Unsupported type: " + typeof(T).ToString());
}

But type checking and branching in a generic method is generally a code smell. A safer option would be to have different methods:

public Base<int> GetIntInstance()
{
    return new A();
}
public Base<string> GetStringInstance()
{
    return new B();
}

Note that

• The number of lines of code is the same (less if you don't count brackets)
• The calling syntax is almost identical ( GetIntInstance vs GetInstance<int> )
• There is no risk of using an unsupported generic type argument