CODEWITHSUNDEEP
c#generics
D.R.
D.R.

Reputation: 21194

C#, instantiating a generic type - with variable type argument?

Code example:

void Foo(params object[] objects)
{
    var entries = new List<IEntry>();
    foreach(var o in objects)
    {
        var entry = new Entry<o.GetType()>(); // this doesn't work
        entries.Add(entry);
    }

    ...
}

Foo("hello", 5); // should fill entries with Entry<string> and Entry<int>

Why is that not possible? I guess I need to work with reflection instead? How to do that properly AND performant?

Upvotes: 4

Views: 5793

Answers (3)

rsenna
rsenna

Reputation: 11964

You just can't use C# generics the way you're trying to do in your snippet.

In order to use [C#] generics, the actual object type must be known at compile time.

You're trying to dynamically pass the object type as a type parameter. This is simply not possible.

Edit

Yes, it is possible to dynamically create generic objects using reflection. After all, generics is implemented both as a compile-time C# construct and as a .NET framework feature (as opposed to, say, Java, where it is only a compile-time feature based on Type Erasure). So, in .NET, through reflection, it is possible to implement the latter "bypassing" the former (which, again, would be impossible in Java).

But the OP clearly does not need that.

After all, entries is a List<IEntry>. IOW, the entries container does not "know" the concrete type of its elements (since it is bound to an interface). So, if each element to be add already implements IEntry, then this would be enough:

void Foo(params IEntry[] objects)
{
    var entries = new List<IEntry>();
    foreach(var o in objects)
    {
        entries.Add(o);
    }

    ...
}

OTOH, if those objects do not implement IEntry, then the OP just need a pure, ordinary, old-school list of untyped objects:

void Foo(params object[] objects)
{
    var entries = new List<object>();
    foreach(var o in objects)
    {
        entries.Add(o);
    }

    ...
}

So using reflection in order to dynamically create a generic container, even if possible, seems to be overkill for this particular use case.

Upvotes: 4

Jason
Jason

Reputation: 1383

You need a function of the form:

Func<Type, IEntry>

I would suggest adding a static function to the parent of Foo like this:

public static IEntry Make(Type type)

Inside that function, feel free to add whatever code makes sense to you:

if (type == typeof(string))
{
    return new StringEntry(); //Obviously some special logic based on the type.
}
else
{
    //Default logic
    return (IEntry) Activator.CreateInstance(typeof(Entry<>).MakeGenericType(type));
}

Upvotes: 1

Hack
Hack

Reputation: 1408

You can do it with reflection 

var entryType = typeof(Entry<>);
Type[] typeArgs = { o.GetType() };
var genericType = entryType.MakeGenericType(typeArgs);
IEntry entry = (IEntry)Activator.CreateInstance(genericType);

Upvotes: 4

Related Questions