cast with a Type variable

Question

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

Answer 1

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.

Answer 2

Define your variable as dynamic and it should work, I mean still you can't cast it but you can access your methods:

dynamic obj = Activator.CreateInstance (type, new Object[]{ "argument" });

For example:

Answer 3

Based on your comment you are trying to add it to a List<SomeDynamicClass>. My first thought is that if you can't statically access SomeDynamicClass then I'm curious how, or why, you have a List<SomeDynamicClass>. It sounds like the code would be much better off with List<object> or List<dynamic> instead.

If you are constrained to List<SomeDynamicClass> then it sounds like you should just jump directly to using reflection to call the Add method

var listType = theList.GetType();
var method = listType.GetMethod("Add");
method.Invoke(theList, obj);

Answer 4

If you statically know the type of the base class, cast to that type. For example:

void AddToList(List<Control> list, string typeName) {
    var control = (Control)Activator.CreateInstance(typeName);
    list.Add(control);
}

Then

var list = new List<Control>();
AddToList(list, "Button"):
AddToList(list, "Label"):
AddToList(list, "ListBox"):

If you need to do something type-specific later, you can test the type and cast:

foreach (Control child in list)
    DoSomethingWithThe(control);

void DoSomethingWithThe(Control control)
{
    Button button = control as Button;
    if (button != null)
    {
        button.Click += Button_Click;
        return;
    }

    Label label = control as Label;
    if (label != null)
    {
        label.MouseOver += Label_MouseOver;
        return;
    }
    //... etc.
}

Or use the OfType method:

foreach (Button button in list.OfType<Button>())
    button.Click += Button_Click;

foreach (Label label in list.OfType<Label>())
    label.MouseOver += Label_MouseOver;

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.