C #: appelle explicitement un gestionnaire d'événements "une bonne chose à faire"?

Cette question est liée à C#, mais peut être applicable à d'autres langues. J'ai une réserve à l'encontre de l'utilisation de code comme le suivant:

using System.Windows.Forms;

class MyForm : Form
{
    private Timer myTimer;
    private Button myButton;

    public MyForm()
    {
        //Initialize the components, etc.

        myTimer.Tick += new EventHandler( myTimer_Tick );
        myButton.Click += new EventHandler( myButton_Click );

        myTimer.Start();
    }

    private void myTimer_Tick( object sender, EventArgs eventArgs )
    {
        myTimer.Stop();
        //also, I see a lot of usage of 
        //Timer.Enabled = true/false instead of -^
        myButton_Click( this, ea /* or event EventArgs.Empty, or null */ );
        return;
    }

    private void myButton_Click( object sender, EventArgs eventArgs )
    {
        //do a lot of stuff, with lots of logic that doesn't even use the
        //state of the eventArgs
        return;
    }
}

Suis-je le seul, que le style est une bête noire de la mine? Il y a d'autres qui aiment la clarté de la séparation de la gestion des événements de la charge de travail, ou même de séparer le complexe routines des fonctions distinctes?

Est-il même accepté de style? J'ai envie de tout l'expressivité et la flexibilité de la gestion des événements en C# a peut être perdu avec les styles de ce genre. Je me sens comme si vous avez une méthode qui signifie "un bouton a été cliqué", alors il ne doit être appelée lorsque le bouton est cliqué.

À ceux qui écrivent comme ça, je dirais: si vous insistez pour avoir un Gestionnaire d'événements méthode pour gérer votre cycle d'horloge, et de votre bouton de la souris, puis l'appeler autre chose que button_Click -- peut-être "handleUserEvent( object sender, EventArgs eventArgs )".

Vraiment, cependant, la question est la suivante, existe-il des lignes directrices de style qui sont largement utilisés qui favorisent ou découragent l'utilisation comme ci-dessus?

source d'informationauteur maxwellb

.net c#coding-style formatting

7

Je suis d'accord avec Rex M de la réponsemais je préfère prendre un peu plus loin. Si vous êtes en utilisant le modèle MVC (ou quelque chose de similaire), la vue de déléguer le bouton cliquez sur le contrôleur. Les contrôleurs de méthodes de cours peut être appelé à partir d'un autre endroit dans votre classe - dire, à partir de votre minuterie de rappel.

Donc, retour à votre code d'origine:
```
using System.Windows.Forms;

class MyForm : Form
{
    private Timer myTimer;
    private Button myButton;

    private MyController myController;

    public MyForm()
    {
        //...
        //Initialize the components, etc.
        //...

        myTimer.Tick += new EventHandler( myTimer_Tick );
        myButton.Click += new EventHandler( myButton_Click );

        myTimer.Start();
    }

    private void myTimer_Tick( object sender, EventArgs eventArgs )
    {
        myTimer.Stop();
        myController.SomeMethod()
    }

    private void myButton_Click( object sender, EventArgs eventArgs )
    {
        //All the stuff done here will likely be moved 
        //into MyController.SomeMethod()
        myController.SomeMethod();
    }
}
```
Un avantage de l'utilisation de MVC est le découplage entre le contrôleur de la vue. Le contrôleur peut maintenant être utilisé sur plusieurs types de vues facilement et de quitter les Interfaces graphiques sont plus faciles à entretenir, car ils contiennent très peu de la logique de l'application.

EDIT: Ajouté en réponse aux commentaires de l'OP

La conception fondamentale de principes de génie logiciel parler de couplage et la cohésion. Il est important de nous efforçons de minimiser le couplage entre les composants tout en maximisant la cohésion, qui conduit à une plus modulaire et facile à gérer le système. Des modèles comme MVC et les directeurs d'école, comme l'ouverture/fermeture Principale construire sur ces principes de base, fournissant plus tangible des modèles de mise en oeuvre pour le réalisateur à suivre.

Ainsi, toute personne qui écrit le code comme on le voit dans le post original n'a pas compris les principes fondamentaux de la conception de logiciels et les besoins de développer considérablement leurs compétences. L'OP doit être félicité pour l'identification de cette "odeur de code" et à essayer de comprendre pourquoi il n'est pas tout à fait droit.

Quelques références pertinentes:
23

Ce n'est certainement pas un "préférences personnelles". Il est clair que, bien entendu approche de la façon d'écrire du code qui est bien structuré, facile à maintenir, réutilisables et faciles à comprendre. Chaque méthode dans votre code doit encapsuler une seule pièce de des fonctionnalités réutilisables. La structure de votre code devrait être:
```
void ButtonClickEventHandler(...)
{
    UserData userData = //determine user data from event data
    DoUserThing(userData);
}

void DoUserThing(UserData userData)
{
    //do stuff
}

void SomeOtherMethod()
{
    UserData userData = //get userdata from some other source
    DoUserThing(userData);
}
```
(Ce qui est un très lâche exemple. Dans une application adéquate, tout doit être séparés en plusieurs classes par le souci.)
5

myButton.PerformClick() est probablement un peu plus sympa, si vous n'avez pas besoin de passer eventargs. Parfois vous voulez juste pour simuler un clic.

Mais oui, je suis d'accord que c'est plus agréable de se déplacer le code réel dans une autre fonction. Je préfère mes gestionnaires d'événements pour être très simple - il suffit de connecter l'INTERFACE utilisateur de la logique, qui est ailleurs.

Alors vous pouvez réorganiser et restructurer votre INTERFACE, sans s'inquiéter autant de la logique.
1

Ce code augmenter le risque de problèmes si un autre codeur fonctionne sur le myButton_Click méthode.

Ce que si je suis venu pour ajuster la mise en œuvre de la myButton.Cliquez sur gestionnaire? Je pourrais supposer que l'objet expéditeur est un Bouton, et essayez de lancer:
```
Button b = (Button)sender;
```
Je n'ai pas de connaissance sans lire le reste de l'implémentation de la classe que je ne suis pas toujours de la réception d'un Bouton que l'expéditeur.

Donc, mon point est: -1 pour la maintenabilité, en raison de la rupture des hypothèses de quels objets seront passés en tant que myButton_Click paramètres.
1

La réponse courte est que pourquoi voudriez-vous simuler un clic sur un bouton en appelant le gestionnaire directement? Si vous souhaitez connecter les deux méthodes en place pour le même événement, vous serait tout simplement de fil. Les gestionnaires d'événements sont multicast délégués, ce qui signifie que vous pouvez ajouter plus d'un d'entre eux. Câblage d'un événement plus d'une fois est tout à fait acceptable.
```
    myTimer.Tick += myTimer_Tick;
    myTimer.Tick += myButton_Click;

    myButton.Click += myButton_Click;
```
Si oui ou non c'est un WTF est un génie appel que nous ne pouvons pas le faire à partir d'un court extrait de code. Cependant, d'après vos commentaires, il sent comme un WTF. Les formulaires ainsi que toute l'INTERFACE utilisateur ne devraient jamais manipuler une logique d'entreprise. Ils ont besoin d'être logique de gestion conscient à un certain degré (en cours de validation), mais ils n'ont pas encapsuler /appliquer la logique d'eux-mêmes.

D'aller plus loin, en suivant quelques simples pratiques de base refactorings et à l'aide d'une couche (n-tier) logiciel va vous prendre un long chemin, et vous comprendrez le long de la manière que le code que vous avez présenté sent mauvais.

Éventuellement, vous allez venir à travers certains de haut niveau de modèles comme MVC (modèle-vue-contrôleur) et MVP (model-view-presenter) qui vont un peu au-delà de la simple superposition. Si vous les suivez, vous obtenez une bonne séparation des préoccupations.

Je suis d'accord avec la accepté de répondre, mais de sauter à droite dans 'Utiliser MVC', voici un code qui n'a pas d'illustrer MVC, sans expliquer pourquoi est-un peu-cargo culte pour moi.
0

Les choses spéciales à propos des événements en C# (et de la .Net framework, en général, est le délégué, qui est le C/C++ équivalent d'un pointeur de fonction. la méthode attachée à l'événement lui-même n'est pas quelque chose de particulier et doit être appelée à partir de n'importe où.

Mise à jour:
peut-être que j'aurais été plus prolixe, mais j'ai pensé que mon utilisation de "doit" au lieu de "peut" ou "peut" serait suffisant. Il est mon affirmation selon laquelle les gestionnaires d'événements doit être appelée lorsque la fonctionnalité ils mettent en œuvre est nécessaire, au lieu de les faire devenir des wrappers pour les méthodes que "faire le travail" le moins d'appels de la méthode que vous avez dans la pile, mieux vous pouvez, spécialement avec les implications sur les performances de .Net de la gestion des exceptions.

Vous devez vous connecter pour publier un commentaire.