Emuler IDispatchEx en C #

Question

Les méthodes d'extension C # 3.0 ajoutent des extensions à la base. Rendre l'appel de cette méthode sur toutes les instances de ce type est légal.

Maintenant, JavaScript que je connais implémente IDispatchEx par lequel il est possible d’ajouter des méthodes à une instance spécifique.

Alors, comment puis-je ajouter un ensemble de méthodes à une "instance" d'une classe C #? Je sais que c’est un territoire de guerre sacré entre dynamiques et statiques. :) Permettez-moi de clarifier mon intention n'est pas cela.

Je souhaite simplement pouvoir ajouter un ensemble d'événements à une interface en fonction de la classe implémentant cette interface.

J'ai pu le faire en utilisant des génériques

inteface ISample<T> { T SupportedEvents; }  

class Sample : ISample<UIWidgetEvent>   {   }  
class Sample2 : ISample<NonVisualUIWidget> { }

class UIWidgetEvent { public EventHandler Clicked; }  
class NonVisualUIWidget {public EventHandler Expired;}

class TestSample
{  
    public void Test()
    {  
        new Sample().SupportedEvents.Clicked += ...
        new Sample2().SupportedEvents.Expired += ...
    }  
}  

Ensuite, je n'ai pas aimé Evénements pris en charge : je veux pouvoir dire

new Sample().Clicked +=...

Alors j'ai pensé que JavaScript (je sais que C # n'est pas JS :)) ... ET IDispatchEx , IL Weaving , Reflection.Emit , etc., etc., et je pense qu'il y a peut-être un moyen de le faire ... [Une prise en charge de la conception serait bien mais je peux vivre sans]

Oui, je pourrais probablement faire cette "augmentation d'instance". avec un motif de visiteur. [Pas sûr si je pourrais obtenir le sucre syntatique cependant]

Commentaires?

Answer 1

Eh bien, vous pouvez créer une instance DynamicMethod pour votre " new " méthodes, mais les relier statiquement à une instance existante au moment de l’exécution ne fonctionnerait pas car elle ne compilerait pas.

Vous pourriez (je n'ai pas essayé cela) être capable d'émettre les opcodes dans un assemblage en mémoire, mais c'est à peu près aussi loin d'être "Syntactically sweet". comme vous pouvez l'obtenir (je pense que cela impliquerait beaucoup de réflexion et d'appels InvokeMember)

Cela pourrait également valoir la peine d’être examiné dans les méthodes d’extension - bien que je n’ai jamais essayé d’attacher des événements ou des méthodes analogues à des événements via des méthodes d’extension ... et qu’ils ne sont que de la version 3.5, ils risquent donc de vous limiter.

Le plus beau look, "pur C #" l’implémentation est probablement quelque chose de très similaire à ce que vous avez déjà avec la configuration générique / interface ...

Honnêtement, si vous recherchez quelque chose avec un véritable "soutien dynamique". comme ça, je ferais ce genre de choses dans un langage compatible DLR (comme IronPython) et y appellerais à partir de vos fichiers C #.