C# 4.0: dynamic ?

re: C# 4.0: dynamic ?

MiddleTommy — Thu, 29 Jan 2009 05:01:24 GMT

I have thought this would be the first "dynamic" step c# would go in but I guess they are trying to target python type dynamic users rather that give c#ers what dynamics they want.

I thought you should declare it like this

public dynamic interface IMessageRouter

{

void Send(string message, string destination);

}

and then use it as a normal interface with "is" and "as" keywords but no type ever needs to derive from it. and if the dynamic interface doesnt match it is just null. Easy to handle and easy to learn.

Thats my two cents on Duck Typing in C#

re: C# 4.0: dynamic ?

Mehrdad Afshari — Mon, 08 Dec 2008 05:55:57 GMT

Yeah, I understand that you didn't suggest it as the only method for dynamic method dispatch. And I agree we're all just guessing, but this is how designs work, isn't it? Nobody knows what's going happen in the future.

To clarify what I meant from false sense of safety, it's really mostly the Intellisense thing. If something shows up in Intellisense, I'll pretty much believe that it do exist. The specially negative point is, in my opinion, the fact that you might have a couple methods in your interface, one of them exists in the type, the other doesn't exist. You'll start debugging, you see it's successfully cast to dynamic<MyInterface> since you can call it's First() method successfully, but it fails on the Second() method call. I think such a suggestion should only be implemented if member existence is checked at the time of assignment (which is a performance hit).

Another thing is, C# is not going to be a dynamic language. I think C# developers should stick to static typing as much as possible and use dynamic types when it really helps. I'll see two situations where dynamic typing is specifically useful, first is COM interop, which usually have much more clutter that you're able to define interfaces for easily (unless the code is generated by a tool) and they have a lot of pretty useless parameters (for which named parameters exist). The other case which dynamic typing is very useful is interfacing with dynamic languages and dynamic environments. Some dynamic languages support dynamically adding and removing methods at runtime, and I don't think your idea is suited for them either. After all, if you know enough about the object and use it more than a couple of times in your code (to make it worth declare the interface), static typing is probably the way to go. This feature might unnecessarily make people go for dynamic typing, which C# designers are probably going to avoid.

I personally think Intellisense is and should be the smartness of the IDE, not the language. I should not manually hint VS to show intellisense for me. If this is merely to help VS, I think it's better be a special type of comment rather than a syntactic thing that compiler understands. VS should be designed to support C# well, not the other way around.

That's just my personal opinion. I'm not a language designer and you probably have a lot more experience in this area.

re: C# 4.0: dynamic ?

skeet — Sun, 07 Dec 2008 20:04:52 GMT

@Mehrdad: With dynamic<IFoo> you'd get Intellisense, and avoid typos which would otherwise only be discovered at execution time. How does that harm productivity?

Note that I'm not suggesting this would be the *only* type of dynamic dispatch - I'd suggest keeping the "raw" dynamic type as well. If people didn't find it helped them to be productive, they could just use the raw form.

As for giving a false sense of safety - the word "dynamic" is still pretty prominent. If that's not enough of a hint, I don't know what is :(

Unfortunately it's unlikely that we'll ever be able to see how useful or otherwise it would be - which means both of us are guessing, basically :(

re: C# 4.0: dynamic ?

Mehrdad Afshari — Sun, 07 Dec 2008 19:54:28 GMT

I think the dynamic type is there primarily to improve productivity while working with extremely dynamic environment. If you're working in such an environment, it would take a long time to implement these kind of interfaces. I think your idea is very similar to Java's checked exceptions (which C# designers don't like). It will harm productivity without adding significant benefits.

In addition, it makes false sense of safety. Your code might compile OK and you'll think it's not going to fail (since, in C#, you're used to strong type checks at compile time) while at run time, it'll throw an exception due to an unresolved method. But when you declare it as "dynamic" alone, you are basically NOT expecting the compiler to do anything for you and you say you're aware of what you are doing.

Your idea is very cool in isolation, but considering C# language style, I think it doesn't fit very well.

re: C# 4.0: dynamic ?

Bart — Wed, 26 Nov 2008 02:30:10 GMT

FYI, a while ago I posted about the idea of a "ducktaper" which is essentially a runtime-generated wrapper object. As Curt comes to say such a wrapper suffers from an identity crisis (you could go off and think of ways to band-aid restore identity to the Equals method extent as you're controlling the wrapper anyway, but let's leave that discussion for another time) amongst other defects like piggybacking on interfaces for not-so-good reasons and limitations/caveats from LCG in general.

More info at community.bartdesmet.net/.../introducing-the-c-ducktaper-bridging-the-dynamic-world-with-the-static-world.aspx.

Thanks,

-Bart

re: C# 4.0: dynamic ?

skeet — Tue, 18 Nov 2008 06:24:25 GMT

I'm suggesting that for the purposes of Intellisense and *static* compilation, dynamic<T> would only expose the members of T. In other words, you could have:

dynamic<IDispose> foo = GetSomeObject();

foo.Dispose(); // Legal

foo.RandomMethod(); // Not legal

However, the actual binding would still be done at execution time - so GetSomeObject() could return something which had a Dispose method, but didn't know it was implementing IDisposable.

re: C# 4.0: dynamic ?

Curt Hagenlocher — Tue, 18 Nov 2008 01:51:36 GMT

Ah, so you're not suggesting that dynamic<T> actually implement T. If that's the case, then I don't think I understand what this would gain you.

re: C# 4.0: dynamic ?

skeet — Sun, 09 Nov 2008 18:17:10 GMT

Curt: Were you suggesting that my idea requires the creation of a wrapper object? It certainly wouldn't. It would be a dynamic object in the normal way, just with the compiler reducing the amount of operations available.

re: C# 4.0: dynamic ?

Curt Hagenlocher — Sun, 09 Nov 2008 12:20:37 GMT

One problem with this idea is that it requires creation of a wrapper object. There are lots of potential gotchas when object identity isn't maintained.

re: C# 4.0: dynamic ?

Tobi — Mon, 03 Nov 2008 20:04:05 GMT

Hey Jon,

inspired by your post I wrote about IDynamicObject - and I think I did make it possible to have the kind of conversion Jesper asked for in the first comment. Go check it out: saftsack.fs.uni-bayreuth.de/.../202.html

Cheers and keep up the great work!

Tobi

Tobi + C# = T# » A first look at Duck Typing in C# 4.0

Tobi + C# = T# » A first look at Duck Typing in C# 4.0 — Mon, 03 Nov 2008 19:21:16 GMT

Pingback from Tobi + C# = T# » A first look at Duck Typing in C# 4.0

re: C# 4.0: dynamic ?

Omer van Kloeten — Sun, 02 Nov 2008 20:52:54 GMT

It's funny how this came to my mind as well[1]. Unfortunately, I couldn't find many supporters for this either, including David who commented about your post as well.

[1] weblogs.asp.net/.../6708812.aspx

re: C# 4.0: dynamic ?

James Hart — Fri, 31 Oct 2008 21:48:29 GMT

I was trying to think of a way to do ducktyping to interfaces now we have dynamic; Agreed - this approach as a language feature would be nice. My best effort would be:

public class DynamicMessageRouter : IMessageRouter

{

private dynamic _d;

public DynamicMessageRouter(dynamic d)

{

_d = d;

}

public void Send(string message, string destination)

{

_d.Send(message, destination);

}

Simple enough as a pattern to be codegenned for a given interface, but it'd be nice to have this class available automatically for every interface, without having to code it. Maybe a virtual "inner type" of the interface - IMessageRouter.dynamic ?

re: C# 4.0: dynamic ?

Charles Feduke — Fri, 31 Oct 2008 20:53:11 GMT

We're *almost* to the point of Objective-C's objc_msgSend(), I think we just need a built in message forwarding mechanism -before- the exception throwing piece is allowed to throw an exception and we'll be set.

re: C# 4.0: dynamic ?

Keith J. Farmer — Fri, 31 Oct 2008 19:25:50 GMT

@David: Static typing hasn't been "tossed out the window". What has been "tossed out the window" has been a tremendous amount of reflection pain. The reason that pain exists is because there are things -- valuable things that underpin frameworks you almost certainly use -- that static typing cannot cope with. The dynamic support addresses part of the pain.

re: C# 4.0: dynamic ?

David Nelson — Fri, 31 Oct 2008 15:53:44 GMT

A number of people have been blogging about this. Personally I think it would have been a far better way to go than what has been announced. Unfortunately, in many dynamic languages, members can be added and removed from objects at runtime. So querying an object for its members at a specific point in time would be a significant limitation. However, in my opinion, accepting that limitation would still be far better for the C# language than tossing static typing out the window, which is what the C# team has apparently settled on.

re: C# 4.0: dynamic ?

Petar Repac — Fri, 31 Oct 2008 11:06:00 GMT

This could drive developers in creating interfaces that are really never implemented, so they get intellisense and compile time checking. Is this acceptable ?

What if we get refactoring tool that could create a wrapper around dynamic object based on some inteface. Then we could remove methods we know we will not use or our dynamic object doesn't have.

Other idea would be C# syntactic sugar that creates this wrapper for us. Something like delegate keyword that creates class that derives from MulticastDelegate.

re: C# 4.0: dynamic ?

skeet — Fri, 31 Oct 2008 09:51:51 GMT

Mike: This would basically be duck casting, but making it really obvious that you're *expecting* duck casting instead of normal static casting. I'd want to keep the two very separate - C# is still a statically typed language at heart :)

re: C# 4.0: dynamic ?

Mike Hadlow — Fri, 31 Oct 2008 09:42:54 GMT

Jon, why not just have 'duck casting'. If the dynamic object provides the methods/properties defined in the interface it can be cast to that interface.

Right now, this doesn't work:

dynamic realRouter = new MessageRouter(); // MessageRouter doesn't implement IMessageRouter

// but does have a send(string,string) method.

IMessageRouter router = realRouter; // compiles, but InvalidCastException is thrown when run

But it would be cool if it did.

Mike

C# 4.0: dynamic

DotNetKicks.com — Fri, 31 Oct 2008 09:29:07 GMT

You've been kicked (a good thing) - Trackback from DotNetKicks.com