The below code won't work, I wanted to know how I can dynamically cast an instance to a type determined at runtime?
Convert.ChangeType() returns an Object that still needs to be cast. So does all attempts to Invoke() a GetConstructor() or Activator.CreateInstance(), see below. At some point I need to explicitly cast in code, I'm hoping to avoid it or push it out as far as possible.
Type type = Type.GetType ("RandomChildClass");
Object obj = Activator.CreateInstance (type, new Object[]{ "argument" });
var instance = (type)obj;
I know I can create a method to accept < T >, but I'd still have the same problem of not knowing how to call it with a dynamic random type Casting a variable using a Type variable
Define your variable as
dynamic
and it should work, I mean still you can't cast it but you can access your methods:For example:
It is not possible to use a
Type
value to determine the type of an expression. (Generics type parameters are different than values as they are codified into the type-system.)The value of the variable is from the run-time code execution, while the expression type is a compile-time construct. Needless to say, the compilation occurs before the code ever runs so using a variable for a cast is impossible.
Reflection (albiet unwieldy) or
dynamic
(which is basically easier-to-use-reflection) allow invoking arbitrary methods or accessing properties/fields against a generic object-typed expression - this is occasionally refered to as "late binding". However, the type of the expression upon which operations is invoked is still object.Interfaces can be used to unify disparate class implementations for proper static typing. The newly created object can then cast to the applicable interface(s) are required. Just like with other expressions, the type is a compile-time construct (and as such the interface must be directly specified), but the code is now free from a particular class.
If creating a system such that these "dynamic classes" are to be used directly in statically typed (C#) code, and the interfaces can be guaranteed or are constrained to a small set, then using interfaces is likely the cleanest approach: e.g.
var myAction = (IMyAction)obj
. Otherwise, fall back to dynamic access - direct or behind a facade.Based on your comment you are trying to add it to a
List<SomeDynamicClass>
. My first thought is that if you can't statically accessSomeDynamicClass
then I'm curious how, or why, you have aList<SomeDynamicClass>
. It sounds like the code would be much better off withList<object>
orList<dynamic>
instead.If you are constrained to
List<SomeDynamicClass>
then it sounds like you should just jump directly to using reflection to call theAdd
methodIf you statically know the type of the base class, cast to that type. For example:
Then
If you need to do something type-specific later, you can test the type and cast:
Or use the OfType method:
You can also use reflection, but that's fairly cumbersome so I won't give an example. Reflection would be useful if you have a property with the same name that's defined on different subtypes of the base type, but not on the base type. If there are many subtypes, the type checking would get cumbersome, so reflection might be a better approach.