Aaron's Technology Musings

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Thursday, June 26, 2008 12:11 PM

I wouldn't say it is duck typing, I would say it's exactly what's called late binding.

To be proper duck typing it has to be typesafe.

Something like this:

interface IHasAddNumbers

{

   int AddNumbers(int x, int y);

}

int sum = myRandomObject.Duck<IHasAddNumbers>().AddNumbers(10,20);

The extension method Duck<T> should create a 'proxy' instance that implements interface T, but every method call is forwarded to the real instance similarly named methods.

Obviously, it has to use Reflection.Emit. It is not too complex, I have done that myself for the other purpose.

mihailik

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Thursday, June 26, 2008 12:12 PM

BTW, the latest VB has similar feature already.

mihailik

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Thursday, June 26, 2008 12:24 PM

I was under the impression that duck typing was specifically waiting to test the types at runtime, and throw missingMethod (or handle somehow) when nothing matches.

I am certainly doing that by checking the parameters in the extension method.  That said, I am not doing anything that checks up the chain yet for interfaces - it is really a naive implementation at this point.

Anonymous

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Thursday, June 26, 2008 1:56 PM

The thing I am proposing should do the magic at runtime too.

I guess I have to clarify what is that I am talking about.

Let say you want to invoke a certain method on an unkown object. Let it be AddNumbers method. First thing you do, you create a 'fake' interface IHasAddNumbers which has method(s) you want to call. Of course the unknown object does not implement that interface. Here comes the 'magic' library, that can create a facade that implements the interface and forward the call to the proper method.

In this way the code is typesafe (still may fail at runtime if the method is not found). And, it is really performant, because the reflection hit is paid only once, because the 'facade' code is generated and then just used.

Here is the facade pseudo-code that the magic library would generate:

class RandomClassFacade : IHasAddNumbers

{

 private readonly RandomClass instance;

 public RandomClassFacade(RandomClass instance)

 { this.instance = instance; }

 public int AddNumbers(int x, int y)

 { return instance.AddNumbers(x,y); }

}

mihailik

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Thursday, June 26, 2008 2:02 PM

I think I see what you are doing here.  I would prefer not to get into reflecting code dynamically though - it seems as though I could possibly memoize the reflection somehow and create a vtable of sorts so I don't have to re-do the reflection for repeated calls.  I think you suggest doing that by dynamically creating an interface - which seems like a good way to do it.

Short of that, somehow even just storing references to the appropriate map between a given set of names and parameters to the right methodinfo might do the trick too.

Anonymous

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Thursday, June 26, 2008 4:04 PM

Yes, dynamically creating *implementation* of interface. The interface itself is statically defined. The whole idea is to eliminate using of strings.

mihailik

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Friday, June 27, 2008 3:04 AM

Hi Mihailik, You would have to statically create a lot of interfaces to emulate true Dynamic Duck Typing in the case were a method conditionally uses attributes (like this for example: http://en.wikipedia.org/wiki/Talk:Duck_typing#DuckDecoy_Example). The alternative would be to require objects to have all the attributes that _could_ be used. - Paddy.

Paddy3118

# re: Introducing DuckCallLib - An Extension Method to (almost) enable Duck Typing in C# @ Friday, June 27, 2008 11:14 AM

Hi Paddy,

Depends on why you need that duck typing in the first place.

If you want to call ocasionally one or two methods in 'duck way', you probably would want to create an interface, even if duck-fake interface. In this way you kind of manifest, what does that mean 'to behave like a duck'.

If you want to call a lot of loose-typed methods, and be totally tolerant to every kind of missing stuff or type conversions, or not completely compatible signatures, you don't want to use C# in the first place.

mihailik