Convert to IEnumerable<dynamic>?

Question

I wrote this extension method :

public static class A
{
 public static IEnumerable<dynamic> AsDynamic<T>(this IEnumerable<T> f)
    {
        foreach (var element in f)
        {
                yield return (dynamic) element;
        }   
    }
}

And tested it :

List<int> l   = new List<int>(){1,2,3};
Console.WriteLine ( l.AsDynamic().GetType());

However the output is : typeof (IEnumerable<Object>)

• Why it is not typeof (IEnumerable<dynamic>) ?

• How can I make it to be like it ?

Answer 1

I think that you have a misunderstanding of what dynamic means. Essentially, when you tell the compiler that an object's type is dynamic , you "promise" that the object at runtime will support whatever methods or properties that you invoke, in exchange for the compiler not complaining at compile time . You also promise that you will face the consequences if you break your promise.

When you say that an object is dynamic , the compiler cannot make assumptions about the type, so it uses object , knowing that anything can be stored as object . When you make an IEnumerable<dynamic> , it becomes IEnumerable<object> , with one significant difference: you can call any method on its elements, and the compiler will not say a word:

IEnumerable<SomeType> original = ...
foreach (dynamic x in original.AsDynamic()) { // Using your method
    Console.WriteLine(x.SomeUnsupportedMethod()); // The compiler is silent!
}

Since original.AsDynamic() gives a sequence of dynamic objects, the compiler does not complain about your call to SomeUnsupportedMethod . If the method is indeed not supported at runtime, the program will crash; if the method is actually supported by elements of SomeType , there would be no crash, and the method will be invoked.

That's all the dynamic will do for you; statically, the "placeholder" will remain object , and typeof will tell you as much. But the exact capabilities of the object (its methods and properties) will not be examined until runtime.

Answer 2

By design, runtime bindings behave as similarly as possible to static binding.

So the runtime type would be typeof (IEnumerable<Object>)

The static type would be typeof (IEnumerable<dynamic>)

Also

The runtime treats this true conceptually

typeof(object)==typeof(dynamic)

So,

A dynamic type is like object except it lets you use in ways that aren't known at compile time.

Answer 3

Try the Linq Extension method Cast() . But I'm not sure it will work with dynamic.

Answer 4

Because dynamic is not a type

Console.WriteLine(typeof(dynamic)); // error

dynamic just resolves the actual type at runtime