Create Generic Collection at Runtime

[Paul Welter]

Is there anyway to do the following?

Type myType = typeof(User);
Collection<myTy pe> list = new Collection<myTy pe>();

I know I could just use User instead of myType but have a function that
takes a type and populates a collection then calls SetValue using
reflection. How would I create the generic collection to fill it and call
SetValue?

thanks
Paul

[realfun]

template is called "compile-time" polymorphism, so the <myType> should
been set at "COMPILE-TIME", you can't use runtime type instead.

my suggestion is use Collection<Obje ct>, and convert it, or just create
an Interface for your <myType>s to implement. and use
Conllection<myT ypeInterface> instead.

[Daniel O'Connell [C# MVP]]

"Paul Welter" <pw*****@loreso ft.com> wrote in message
news:Oa******** *****@TK2MSFTNG P15.phx.gbl...

Is there anyway to do the following?

Type myType = typeof(User);
Collection<myTy pe> list = new Collection<myTy pe>();

I know I could just use User instead of myType but have a function that
takes a type and populates a collection then calls SetValue using
reflection. How would I create the generic collection to fill it and call
SetValue?

Why not have the function take a type parameter instead of passing it a
type?

Collection<T> CreateCollectio n<T>(T[] dataItems)
{
}

or what have you.

[Oliver Sturm]

Paul Welter wrote:

Is there anyway to do the following?

Type myType = typeof(User);
Collection<myTy pe> list = new Collection<myTy pe>();

I know I could just use User instead of myType but have a function that
takes a type and populates a collection then calls SetValue using
reflection. How would I create the generic collection to fill it and call
SetValue?

You can do this:

Type genericType = typeof(Collecti on<>);
Type constructedType = genericType.Mak eGenericType(my Type);

Now you can create an instance of the constructed type and call methods
on it via Reflection:

object myObject = Activator.Creat eInstance(const ructedType, ...);
myObject.GetTyp e().InvokeMembe r("SetValue", BindingFlags.In stance |
BindingFlags.In vokeMethod | BindingFlags.Pu blic,
null, myObject, new object[] { ... });

Now finally, let me say this: I'm quite sure there should be a better
way to do whatever it is exactly that you want to do. Especially since
the advent of Generics... Think about it, or tell us about it.
Oliver Sturm
--
omnibus ex nihilo ducendis sufficit unum
Spaces inserted to prevent google email destruction:
MSN oliver @ sturmnet.org Jabber sturm @ amessage.de
ICQ 27142619 http://www.sturmnet.org/blog

[Paul Welter]

Type.MakeGeneri cType works great, thanks. Couple question about
MakeGenericType though. Is there a big performance hit for using
Type.MakeGeneri cType? Is the performance hit in calling
Type.MakeGeneri cType or when calling
Activator.Creat eInstance(const ructedType, ...)? Would something be gained
if I cached the Type output from the call to Type.MakeGeneri cType? I was
thinking something like this ...

private static Hashtable genericClassTyp eCache = Hashtable.Synch ronized(new
Hashtable());

private Type GetGenericClass Type(Type classType, Type genericType)
{
string key = classType.ToStr ing() + genericType.ToS tring();
if (genericClassTy peCache.Contain s(key))
{
return (Type)genericCl assTypeCache[key];
}

Type constructedType = classType.MakeG enericType(gene ricType);
genericClassTyp eCache.Add(key, constructedType );

return constructedType ;
}

thanks
Paul

"Oliver Sturm" <ol****@sturmne t.org> wrote in message
news:u9******** ********@TK2MSF TNGP10.phx.gbl. ..

Paul Welter wrote:

Is there anyway to do the following?

Type myType = typeof(User);
Collection<myTy pe> list = new Collection<myTy pe>();

I know I could just use User instead of myType but have a function that
takes a type and populates a collection then calls SetValue using
reflection. How would I create the generic collection to fill it and
call SetValue?

You can do this:

Type genericType = typeof(Collecti on<>);
Type constructedType = genericType.Mak eGenericType(my Type);

Now you can create an instance of the constructed type and call methods on
it via Reflection:

object myObject = Activator.Creat eInstance(const ructedType, ...);
myObject.GetTyp e().InvokeMembe r("SetValue", BindingFlags.In stance |
BindingFlags.In vokeMethod | BindingFlags.Pu blic,
null, myObject, new object[] { ... });

Now finally, let me say this: I'm quite sure there should be a better way
to do whatever it is exactly that you want to do. Especially since the
advent of Generics... Think about it, or tell us about it.
Oliver Sturm
--
omnibus ex nihilo ducendis sufficit unum
Spaces inserted to prevent google email destruction:
MSN oliver @ sturmnet.org Jabber sturm @ amessage.de
ICQ 27142619 http://www.sturmnet.org/blog

[realfun]

learned a lot, thanks

[Paul Welter]

Well, I'll answer this one myself. I did some simple performance testing
and found that there was no difference between caching the type and just
calling MakeGenericType every time. In the test I used 3 different generic
collection types, 8 classes to use as the generic and ran it for about 200
reps. The average time for calling MakeGenericType every time was 0.0156125
milliseconds. The average time when using the caching function below was
0.018180451 milliseconds. I guess the runtime is doing its own caching, no
need for it in this case. I would have thought there was going to be a
bigger hit then that as generics are optimized at compile time.

thanks
~ Paul

"Paul Welter" <pw*****@loreso ft.com> wrote in message
news:eF******** ******@TK2MSFTN GP10.phx.gbl...

Type.MakeGeneri cType works great, thanks. Couple question about
MakeGenericType though. Is there a big performance hit for using
Type.MakeGeneri cType? Is the performance hit in calling
Type.MakeGeneri cType or when calling
Activator.Creat eInstance(const ructedType, ...)? Would something be gained
if I cached the Type output from the call to Type.MakeGeneri cType? I was
thinking something like this ...

private static Hashtable genericClassTyp eCache =
Hashtable.Synch ronized(new Hashtable());

private Type GetGenericClass Type(Type classType, Type genericType)
{
string key = classType.ToStr ing() + genericType.ToS tring();
if (genericClassTy peCache.Contain s(key))
{
return (Type)genericCl assTypeCache[key];
}

Type constructedType = classType.MakeG enericType(gene ricType);
genericClassTyp eCache.Add(key, constructedType );

return constructedType ;
}

[Oliver Sturm]

Paul Welter wrote:

Well, I'll answer this one myself. I did some simple performance testing
and found that there was no difference between caching the type and just
calling MakeGenericType every time. In the test I used 3 different generic
collection types, 8 classes to use as the generic and ran it for about 200
reps. The average time for calling MakeGenericType every time was 0.0156125
milliseconds. The average time when using the caching function below was
0.018180451 milliseconds. I guess the runtime is doing its own caching, no
need for it in this case. I would have thought there was going to be a
bigger hit then that as generics are optimized at compile time.

I guess you will see a performance hit comparing this approach with the
construction of the object without Reflection. In .NET 2.0, enormous
improvements have been made to Reflection performance-wise, but it's
still slower by a huge factor.
Oliver Sturm
--
omnibus ex nihilo ducendis sufficit unum
Spaces inserted to prevent google email destruction:
MSN oliver @ sturmnet.org Jabber sturm @ amessage.de
ICQ 27142619 http://www.sturmnet.org/blog