返回泛型方法中的特定类型

Question

I have written the following method:

public T CreatePackage<T>() where T : new()
{
        var package = new T();

        if (typeof(ComponentInformationPackage) == typeof(T))
        {
            var compInfoPackage = package as ComponentInformationPackage;

            // ...

            return compInfoPackage;
        }

        throw new System.NotImplementedException();
}

I check what type T is and according to this I treat my variable Package . When I want to return it I get an compiler error.

"The type ComponentInformationPackage cannot be implicitly converted to T"

How can I solve this problem?

Answer 1

First: Where a cast doesn't work, a safe cast does work:

return CompInfoPackage as T;

...provided there's a class constraint on T :

public static T CreatePackage<T>() where T : class, new() { ... }

Second: Given this code:

var package = new T();
if (typeof(ComponentInformationPackage) == typeof(T))
{
    var compInfoPackage = package as ComponentInformationPackage;

    // ...

    return (T)compInfoPackage; 
}

...you already have the reference package to the new object. Since it's of type T , the compiler already likes it as a return type. Why not return that?

var package = new T();
if (typeof(ComponentInformationPackage) == typeof(T))
{
    var compInfoPackage = package as ComponentInformationPackage;

    // ...

    return package; // Same object as compInfoPackage
}

Answer 2

You have to cast to T as your method returns an instance of T not ComponentInformationPackage .

return (T)CompInfoPackage;

The compiler has no chance to get to know that T actually IS a ComponentInformationPackage . However as you already checked it before this cast may never fail.

However I´m not sure why you have a generic type at all, as only instances of ComponentInformationPackage are handled by your method. Ommit the type-param and the constraint and simply return what you already do.

EDIT: I mentioned it already within the comments, you can also return package (without any cast) as the compiler already knows that package is an instance of T . Last opportunity you have is return (T)(object) CompInfoPackage which however seems quite odd to me.

Answer 3

Casting back to T will not work as suggested by HimBromBeere and thus is not your solution. In order for the compiler to accept the cast you will need an additional type constraint of ComponentInformationPackage . So this will be your fix:

public T CreatePackage<T>()
    where T : ComponentInformationPackage, new()
{
        var package = new T();

        if (typeof(ComponentInformationPackage) == typeof(T))
        {
            var compInfoPackage = package as ComponentInformationPackage;

            // ...

            return (T)compInfoPackage;
        }

        throw new System.NotImplementedException();
}

Also I suggest using the capitalization conventions as a guideline by MSDN. This is irrelevant to your question, but it's a tip.

Answer 4

If you want to handle the object creation based on the type you shouldn't use generics here (as it is NOT generic). Maybe use a factory pattern to achieve that.

Answer 5

I think what you are trying to achieve is not possible with generics unless you have all your types implement common interface or is of some common abstract type

public T CreatePackage<T>()
    where T : IPackage, new()
{
        var package = new T();

        if (typeof(ComponentInformationPackage) == typeof(T))
        {
            var compInfoPackage = package as ComponentInformationPackage;

            // ...

            return (T)compInfoPackage;
        }

        throw new System.NotImplementedException();
}

In Above example, all your classes should implement IPackage interface

It seems like you want to create instance based on the type passed...you need something like factory pattern. I think you should reconsider your design