CODEWITHSUNDEEP
c#dynamictypescasting
Andy Hunt
Andy Hunt

Reputation: 1083

C#: return stong types from reflection

In the latest version of C#, is it possible to convert a dynamic type to a strong type, if you know the type in advance?

I'm using reflection to call a method on an object, which returns to a var:

var returnVal = context.GetType().InvokeMember(MethodName, BindingFlags.InvokeMethod, null, context, lParams.ToArray());

I can easily get the type being returned to returnVal. Is it possible to cast\convert thins to a more strongly typed version?

EDIT FOR CLARITY:

In this situation, I know the type being returned but only by string. To get the type, I have to do:

diAssemblies[k].GetType(diAssemblies[k].GetName().Name + "." + returnType)

Where returnType is the name of type being returned.

Ideally, I'd like to be able to get the result of the method invocation in to a strongly typed field.

CONTEXT

I'm loading assemblies containing .edmx files from a directory, then invoking methos on those contexts. At run time, the loader won't know what assemblies it's going to be loading. However, the person using the loader will be aware of the assemblies, methods and types.

This is to create a generic wrapper around database calls through entity framework (with stored procedures), that will be reused elsewhere.

Upvotes: 0

Views: 925

Answers (2)

ForbesLindesay
ForbesLindesay

Reputation: 10712

No, you can't get the advantages of a concrete type such as compile time checking and intellisense. This is because you are only actually working out what the type is at run time. It is late bound, which means that it's a job for dynamic and the DLR. You can cast it to an object that you know the actual object will inherit from (e.g. object), but you can't cast to the actual type. You might want to look into generics as an alternative if you had for example:

public T GetReturnVal<T>()
{
   return (T)context.GetType().InvokeMember(MethodName, BindingFlags.InvokeMethod, null, context, lParams.ToArray());
}

You would at least be returning a concrete type to callers of type T. But this type has to be set at compile time, i.e. known in advance.

I recomend you read An Introduction to C# Generics as it does exactly what, from the context you've added, you need to do.

Upvotes: 1

Dan Bryant
Dan Bryant

Reputation: 27515

If you don't know the Type statically, how could you use a statically typed reference? What you can do is have the returned type implement an interface you do know about statically, then cast to that interface.

So, if MyStrongType implements IMyStrongBehavior, you can cast the return value to IMyStrongBehavior and use that statically. The underlying value is already strongly typed, regardless of whether you cast it.

Alternately, you can store the return value in a dynamic variable (which will allow you to invoke known methods without an actual statically-typed interface.) The disadvantage here is that you don't get any Intellisense and any mistakes you make won't show up until runtime.

Upvotes: 2

Related Questions