C# 4.0 language features

[Pavel Minaev]

An "official" document covering the new language features has finally
been posted:

http://code.msdn.microsoft.com/cshar...ReleaseId=1686

(warning: it's available in .docx format only)

Not that much, to be honest. Named arguments is the only feature that
is likely to be used, and, while certainly nice to have in and of
itself, it really is long overdue (as Anders himself said on PDC). The
rest seem to be too specialized, though I can think of some ways to
creatively abuse IDynamicObject and dynamic dispatch to e.g. walk XML
trees, XPath-style (similar to first-class LINQ to XML support in
VB9).

Your thoughts?

[Ivan]

I can see "dynamic" type being abused a lot by VB developers. It's like
"Object" in VB6
"Pavel Minaev" <in****@gmail.comwrote in message
news:7e**********************************@m3g2000h sc.googlegroups.com...

An "official" document covering the new language features has finally
been posted:

http://code.msdn.microsoft.com/cshar...ReleaseId=1686

(warning: it's available in .docx format only)

Not that much, to be honest. Named arguments is the only feature that
is likely to be used, and, while certainly nice to have in and of
itself, it really is long overdue (as Anders himself said on PDC). The
rest seem to be too specialized, though I can think of some ways to
creatively abuse IDynamicObject and dynamic dispatch to e.g. walk XML
trees, XPath-style (similar to first-class LINQ to XML support in
VB9).

Your thoughts?

[Peter Morris]

I also expect to see much great take up of COM interop with this version.

I am greatly looking forward to avoiding this as much as possible :-)

--
Pete
====
http://mrpmorris.blogspot.com
http://www.capableobjects.com

[Pavel Minaev]

After some discussion of new C# 4.0 features with Eric Lippert, it
seems that dynamic is not quite as obvious as it seems, and can be
abused in some rather creative ways. It's not just a dynamic receiver
that triggers dynamic dispatch - it's _any_ argument that's dynamic.
But, in this case, the arguments (including the receiver) that are
statically typed are used to constrain the candidate method group at
run-time. For example:

class Base
{
public void Foo(int i) {}
public virtual void Foo(float f) {}
}

class Derived : Base
{
public override void Foo(float f) {}
public new void Foo(string s) {}
}

Base b = new Derived();
object arg = 1; // hide actual type at compile-time
b.Foo((dynamic)arg); // calls Base.Foo(int) - overload resolution at
runtime
arg = 1.2f;
b.Foo((dynamic)arg); // calls Derived.Foo(float) - overload
resolution at runtime yields Base.Foo(float) + virtual/override
dispatch as usual
arg = "abc";
b.Foo((dybamic)arg); // does NOT call Derived.Foo(string), since
variable b is declared as Base; runtime exception!

This is interesting. We've all seen those clever LINQ hacks (monads
etc); now the challenge of the day is to find some way to abuse
dynamic in a similarly non-obvious fashion ;)