text: [Update March 31, 2010: MUCH OF THIS HAS CHANGED SINCE PRE-RELEASE VERSION OF DYNAMIC. SEE THIS POST]
  We left off last time with this piece of code
  public class C
  {
  public static void M(int i) { }
  public static void M(string s) { }
  }
  ...
  dynamic d = GetSomeD();
  C.M.
  And since we can't decide which M to call in the example above, it just got more complicated. How do we know when to defer until runtime?:
  public class C
  {
  public static void M(int i) { }
  public static void M(dynamic d) { }
  }
  ...
  dynamic d = GetSomeD();
  C.M(d);
  In this case, the compiler will resolve to the second M, since the conversions work out. The trick is that there is an implicit conversion from dynamic to itself.
  If none of the overloads that we look at actually work, then we need to try something else. It goes like this: while you are looking for methods to test, if ever you see one that fails only because there was a dynamic argument in one position and no conversion, then just "pretend" that there exists a method that takes dynamic everywhere and returns dynamic. So in this case, the pretend method would look like:
  public static dynamic M(dynamic d) { } // not real.
  Incidentally, while we were designing this feature, we called the pretend method "the phantom method." I am not sure if that name will stick in the spec.
  So the deferred overload resolution as well as the assignment conversions are two different strategies that arose in an effort to get "dynamic" to work just as you expect it. But there are some other changes that make the dynamic type a little weird.?
  List<dynamic> ld = GetAList();
  List<object> lo = ld;.
  I call these conversions "structural conversions," since they exist only because they preserve the runtime structure of the objects being converted. This is probably not the language that you will see in the final C# 4 specification since this area is not 100% baked yet.
  There's more weirdness for next time, too! Can you implement IEnumerable<dynamic> or derive from Base<dynamic>? Should you be able to? What does each of those things mean?
  Previous posts in this series: Part V, Part IV, Part III, Part II, Part I