Action<T> vs délégué de l'événement

J'ai vu des développeurs utilisant le ci-dessous les codes tout à fait autrement. Quelle est la différence exacte entre ces derniers, et ceux qui vont à la norme? Sont-ils de même, comme Action et Func<T> est un délégué ainsi:

public event Action<EmployeeEventAgs> OnLeave;
public void Leave()
{
    OnLeave(new EmployeeEventAgs(this.ID));
}

public delegate void GoOnLeave(EmployeeEventAgs e);
public event GoOnLeave OnLeave;
public void Leave()
{
    OnLeave(new EmployeeEventAgs(this.ID));
}

InformationsquelleAutor Bhaskar | 2010-02-17

c#delegates

51

Fwiw, ni exemple utilise la norme .NET conventions. Le EventHandler<T> générique doit déclarer l'événement:
```
public event EventHandler<EmployeeEventArgs> Leave;
```
Le préfixe "on" devrait être réservé à une méthode protégée qui déclenche l'événement:
```
protected virtual void OnLeave(EmployeeEventArgs e) {
    var handler = Leave;
    if (handler != null) handler(this, e);
}
```
Vous n'avez pas ont de faire de cette façon, mais toute personne de reconnaître instantanément le modèle, de comprendre votre code et apprendre à utiliser et à personnaliser.

Et il a le grand avantage de ne pas être obligés de choisir entre un délégué personnalisé de déclaration et de Action<>, EventHandler<> est le meilleur moyen. Qui répond à votre question.
- C'est bien, des conseils, mais je ne pense pas que cela répond à la question
- Avez-vous déclarer le Leave gestionnaire en tant que délégué, au lieu de: public event Gestionnaire d'événements<> ... sur le but? Le event mot-clé est tout à fait un changeur de jeu lorsque vous travaillez avec la classe d'exposer l'événement, que sans elle, on pourrait simplement effacer la totalité de l'événement de la collection en utilisant obj.Leave = someHandler au lieu de obj.Leave += someHandler
- Non, c'était une erreur. Personne ne l'a remarqué dans les trois ans 🙂 Merci!
InformationsquelleAutor Hans Passant
27

Les deux lignes de code suivantes sont presque équivalents:
```
public event Action<EmployeeEventAgs> Leave;
```
par rapport à:
```
public event EventHandler<EmployeeEventAgs> Leave;
```
La différence est dans la signature de la méthode de gestionnaire d'événements. Si vous utilisez la première approche avec l'action, vous pourriez avoir:
```
public void LeaveHandler(EmployeeEventAgs e) { ... }
```
et puis ceci:
```
obj.Leave += LeaveHandler;
```
Avec la deuxième approche, la signature de la LeaveHandler doit être différent:
```
public void LeaveHandler(object sender, EmployeeEventAgs e) { ... }
```
Il est très important de remarquer que, dans les deux cas, la event mot-clé est utilisé pour déclarer l'événement membre. Un événement membre a déclaré que cette voie n'est pas simplement un champ de la classe, malgré qu'il semble comme si elle l'était. Au lieu de cela, le compilateur crée comme un propriété d'événement¹. L'événement propriétés sont semblables à celles des propriétés, sauf qu'ils n'ont pas get ou set accesseurs. Le compilateur permet de les utiliser uniquement sur le côté gauche d'un += et -= affectations (ajout ou retrait d'un gestionnaire d'événement). Il n'y a aucun moyen de remplacer le déjà attribué des gestionnaires d'événements, ou à invoquer l'événement à l'extérieur de la classe qui déclare il.

Si l'événement de mot-clé qui manquait dans les deux exemples, vous pouvez effectuer les opérations suivantes avec pas d'erreur ou d'avertissement:
```
obj.Leave = LeaveHandler;
```
qui effacer toute les gestionnaires inscrits et de les remplacer avec les LeaveHandler.

En outre, vous pouvez également effectuer cet appel:
```
obj.Leave(new EmployeeEventAgs());
```
Les deux situations ci-dessus sont considérées comme une anti-modèle, si vous avez l'intention de créer un événement. Un événement doit être invoquée que par le propriétaire de l'objet et ne devrait pas permettre introuvable suppression des abonnés. Le event mot-clé est le .NET-programme de construction qui vous permet de coller avec l'utilisation correcte des événements.

Avoir le dessus dans l'esprit, je crois que beaucoup de gens en tenir à la EventHandler approche, car il est plus rare d'utiliser un EventHandler sans event mot-clé. Les Actions ont une portée plus large d'utilisation, ils ne sont pas aussi naturellement lorsqu'il est utilisé comme événements. Ce dernier est, bien sûr, un avis personnel, que le gestionnaire d'événement approche a sans doute devenu trop câblé dans mes propres pratiques de codage. Encore, si les actions sont utilisés correctement, il n'est pas un crime de l'utiliser pour des événements.

¹ d'Une propriété d'événement est ce que le compilateur génère automatiquement lorsqu'voir le code comme ceci:
```
event EventHandler SomeEvent 
```
Il devient à peu près le même code comme le suivant:
```
private EventHandler _someEvent; //notice the lack of the event keyword!
public event EventHandler SomeEvent
{
    add { _someEvent += value; }
    remove { _someEvent -= value; }
}
```
Événement invocations qui nous écrire comme ceci:
```
this.SomeEvent(sender, args);
```
sont convertis en ceci:
```
this._someEvent(sender, args);
```
- +1 pour l'explication détaillée.
InformationsquelleAutor Ivaylo Slavov
21

Action<T> est exactement le même que delegate void ... (T t)

Func<T> est exactement le même que delegate T ... ()
- Pas exactement la même chose... ils ont la même signature, mais ils ne sont pas d'affectation compatible (ce qui à mon humble avis est très regrettable...)
- Est-ce à eux de ne pas exactement la même chose? Soient X et Y différentes ici: public delegate void X<T>(T t); public delegate void Y<T>(T t); Vous ne pouvez pas affecter l'un à l'autre.
InformationsquelleAutor pdr
6

Action est juste un raccourci pour le plein délégué de la déclaration.
```
public delegate void Action<T>(T obj)
```
http://msdn.microsoft.com/en-us/library/018hxwa8.aspx

À utiliser dépendra de vos organisations des normes de codage/de style.

InformationsquelleAutor Darryl Braaten
4

Oui, d'Action et de Func sont tout simplement la commodité des délégués qui ont été définis dans la 3.5 clr.

Action, Func et les lambdas sont tout simplement syntaxique de sucre et de commodité pour l'utilisation de délégués.

Il n'y a rien de magique. Plusieurs personnes ont écrit simple 2.0 addon bibliothèques pour ajouter cette fonctionnalité à 2,0 code.

InformationsquelleAutor Sky Sanders
4

Vous pouvez regarder ici, voir ce que le compilateur génère de l'Action est la meilleure description. Il n'y a pas de différence fonctionnelle dans ce que vous avez écrit, juste plus court, plus pratique syntaxe.

InformationsquelleAutor Nick Craver

En général, ils sont équivalents. Mais dans le contexte de l'utilisation d'un délégué pour le type d'événement, la convention est d'utiliser ce Gestionnaire (où T hérite EventArgs):

public event EventHandler<EmployeeEventArgs> Left;

public void Leave()
{
    OnLeft(this.ID);
}

protected virtual void OnLeft(int id)
{
    if (Left != null) {
        Left(new EmployeeEventArgs(id));
    }
}

InformationsquelleAutor Rafa Castaneda

0

Vous pourriez avoir écrit ces Action et Func générique délégués de vous-même, mais étant donné qu'ils sont généralement utiles qu'ils ont écrit pour vous et vous coincé dans .Bibliothèques Net.

InformationsquelleAutor Jason Kleban

Vous devez vous connecter pour publier un commentaire.