How can I use a Type object as a Type argument?
For example:
byte[] Data;
Type objectType;
public T MyFunction<T>()
{
return OtherClass.Deserialize <objectType> (Data);
}
In other words, how do you use a Type object in a Type parameter <typehere>?
Your generic method expects type identifier which is known at compile time. Meanwhile, you're trying to pass an instance of such a type to your method, but such an instance is not known until runtime.
Use reflection instead:
var method = typeof (OtherClass).GetMethods()
.Single(x => "Deserialize".Equals(x.Name)
&& x.IsGenericMethodDefinition);
method = method.MakeGenericMethod(new[] { objectType });
method.Invoke(null, new object[] { Data });
Generics is really designed to work with types which are known at compile-time on the calling side. (The type argument can itself be a type parameter as far as the caller is concerned, of course.)
Otherwise, you're stuck with generics - you'd get the MethodInfo associated with OtherClass.Deserialize, call MakeGenericMethod using objectType as an argument, and then call the resulting method.
var method = typeof(OtherClass).GetMethod("Deserialize");
var genericMethod = method.MakeGenericMethod(objectType);
object result = genericMethod.Invoke(null, Data);
Note that this won't return a T though. It's not clear why your MyFunction method is generic if you're not actually going to use the type parameter.
Like this (recursively, for brevity):
Type myType;
public void MyFunction<T>(T instance) {
MyFunction<Type>(myType);
}
object object, sorry, struggling to be clear here.here myType is a Type object. So you should call MyFunction<Type>( myType);
You should write MyFunction method like:
public T MyFunction<T>(byte[] data)
{
return OtherClass.Deserialize<T>(data);
}
and the client code will look like:
byte[] Data = new byte[];
Type objectType;
objectType = MyFunction<Type>(Data);
