Manière préférée de déclarer des événements

Je suis assez satisfait de ma compréhension du modèle d'événement .NET. Je pense que je peux mal comprendre une petite nuance du système.

Quand j'ai commencé à mettre des événements dans mes classes, j'utilisais la méthode standard comme ceci:

public event EventHandler<MyEventArgs> MyEvent;

Cela signifiait que tout abonnement à l'événement aurait besoin d'une méthode comme:

void HandleThatEvent(object sender, MyEventArgs args){...}

Ce qui est bien, mais j'ai trouvé que je me soucierais rarement de l'expéditeur, donc cela faisait gonfler beaucoup de signatures de méthode.

Je suis donc passé à déclarer mes propres types de délégués

public delegate void MyEventHandler(SomeClass argument);

Ce qui a réduit l'encombrement, mais m'a laissé un petit problème en ce qui concerne l'écriture des gestionnaires:

eventImplmentor.MyEvent += HandleThatEvent;
.
.
.
void HandleThatEvent(/*oh, um, what arguments does it take? Intellisense isn't telling me*/)

Je devrais donc revenir à la déclaration du délégué et regarder, puis revenir en arrière et les écrire, ou le compiler et attendre d'être informé.

Alors maintenant , à la place, je suis juste en utilisant Action, Action<T>ou ce qui convient modèle.

public event Action<SomeClass> MyEvent;

Pour que je puisse survoler l'événement et être informé des paramètres qu'il attend.

Ma question, après tout cela: existe-t-il une meilleure pratique pour déclarer des événements en C #? Dois-je revenir en arrière EventHandler<T>ou est-ce Action<T>acceptable?

Pour une gestion simple et interne des événements, il y a ceux qui utilisent simplement Actionou Action<T>, comme vous le proposez. J'ai tendance à utiliser le modèle standard, y compris l'expéditeur, même pour les événements internes, car vous ne savez jamais quand vous voudrez plus tard exposer une classe ou un événement, et je ne voudrais pas la pénalité d'avoir à refactoriser la méthode d'événement juste pour faire il public.

Je suis d'accord avec vous que la signature de gestion des événements est un peu plus lourde qu'elle ne devrait l'être pour des scénarios simples, mais elle est bien conçue pour gérer la migration incrémentielle car des arguments d'événement supplémentaires pourraient devenir nécessaires au fil du temps. Dans l'ensemble, je m'en tiendrai au modèle standard, d'autant plus que, comme vous l'avez remarqué, vous n'obtiendrez un support IntelliSense approprié que si vous le faites.

Pour ce que ça vaut, j'ai consacré du temps à cela et j'ai proposé un modèle de gestion des événements différent: Signature d'événement dans .NET - Utilisation d'un «expéditeur» typé fort? . Le but ici n'était pas de supprimer l'expéditeur, mais de le rendre typiquement fort comme TSenderau lieu de faiblement typé comme System.Object. Il fonctionne très bien; cependant, on perd le support IntelliSense lorsque vous faites cela, il y a donc un compromis malheureux.

Dans l'ensemble, je m'en tiendrai au modèle standard, mais il est intéressant de penser à de meilleures façons de le faire.