current community

your communities

more stack exchange communities

company blog
Stack Exchange Inbox Reputation and Badges
tour help
Software Engineering Stack Exchange is a question and answer site for professionals, academics, and students working within the systems development life cycle who care about creating, delivering, and maintaining software responsibly. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top
up vote 6 down vote favorite

If it possible:

IList <dynamic> = new List <dynamic>;

or:

class A <T>
{
 A(T){}
}

class B: A <dynamic> {}

. Why it is not possible to do this:

class U: IEnumerable <dynamic> {}

?

share|improve this question
up vote 7 down vote accepted

This is not allowed, as Chris Burrows (who helped create and implement dynamic) explains:

Well, for one thing, it doesn’t actually give you anything that you didn’t already have. The first thing and the second thing are already there if you implemented IEnumerable<object>. In that case, you still would have been able to define GetEnumerator the way we did, and you still can convert C to IEnumerable<dynamic> (again, because of the structural conversions). Think of it this way: if anyone ever looks directly at your type C, they are never going to “see” what interfaces you implement. They only “see” them when they cast, and at that point, your IEnumerable<dynamic> didn’t do them any good.

That’s a fine reason, but you might respond, why not let me do this anyway? Why impose this limitation that seems artificial? Good question. I encountered this for the first time when I was trying to get the compiler to emit these things, and I realized very quickly that there was no where for me to emit the [Dynamic] attribute that we use to mark dynamic types. The metadata team reported that a reading of the CLI spec seemed to indicate that the tables for interface implementations and custom attributes might have permitted it, but anyway no one we know of has ever done this, and it would have been effort expended. We have priorities and a limited budget of time, and this didn’t make the cut.

share|improve this answer
up vote 3 down vote

The easiest way of thinking about it - dynamic is not a type.

dynamic is a compiler directive which turns off all compile-time checks, and implements them at runtime instead.

When you declare a variable dynamic: 

dynamic t = 123;

t = t.Length;    // crashes at runtime

actually you are declaring the variable as System.Object, then turning off all compile-time checks for expressions which involve that variable:

object t = 123;

unchecked_for_errors
{
    t = t.Length;    
}

You cannot use <dynamic> as if it were a type, because it really isn't one.
Use <object> instead.

share|improve this answer

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.