Eventhandlers génériques

Soyez le premier à donner votre avis sur cette source.

Snippet vu 7 375 fois - Téléchargée 17 fois

Contenu du snippet

Par le passé, je créais mes propres délégates pour chaque évenement à lancer. Puis, je me suis mis a utiliser EventHandler<T>, mais ça c'est vite avéré pénible, car je devais créer mes propres Class qui dérivaient de EventArgs a chaque fois. J'ai alors trouvé une ressemblance frappante entre mes différentes sous-classes dérivant d'EventArgs. Souvent je n'ai besoin que d'un ou 2 paramètres. J'ai donc créer des classes génériques répondant a environ 90% de mes besoins niveau EventArgs.

Voici les 3 classes avec une classe de démonstration d'utilisation

Source / Exemple :


using System;
using System.IO;
using System.Windows.Forms;
using System.Linq;

namespace UtilityLib
{
    /// <summary>
    /// EventArgs avec un param d'un type quelconque (Key)
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    public class KeyEventArgs<TKey> : EventArgs
    {
        private TKey m_Key;
        public TKey Key { get { return m_Key; } }

        public KeyEventArgs(TKey key)
        {
            m_Key = key;
        }
    }

    /// <summary>
    /// EventArgs avec un param d'un type quelconque (Key) et un autre param d'un type quelconque (Value)
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    public class KeyValueEventArgs<TKey, TValue> : EventArgs
    {
        private TKey m_Key;
        private TValue m_Value;
        public TKey Key { get { return m_Key; } }
        public TValue Value { get { return m_Value; } }

        public KeyValueEventArgs(TKey key, TValue value)
        {
            m_Key = key;
            m_Value = value;
        }
    }

    /// <summary>
    /// EventArgs avec un param d'un type quelconque (Key) et d'autres params d'un type quelconque (Values)
    /// </summary>
    /// <typeparam name="TKey"></typeparam>
    /// <typeparam name="TValue"></typeparam>
    public class KeyValuesEventArgs<TKey, TValue> : EventArgs
    {
        private TKey m_Key;
        private TValue[] m_Values;
        public TKey Key { get { return m_Key; } }
        public TValue[] Values { get { return m_Values; } }

        public KeyValuesEventArgs(TKey key, params TValue[] values)
        {
            m_Key = key;
            m_Values = values;
        }
    }
    /*

  • SIMULATION D'UTILISATION
  • /
class ClassSimulation { public event EventHandler<KeyEventArgs<string>> MessagePopped; public event EventHandler<KeyValueEventArgs<Control, bool>> VisibilityChanged; public event EventHandler<KeyValuesEventArgs<StreamWriter, int>> SumRequested; private StreamWriter fi; private Control co; public ClassSimulation() { fi = new StreamWriter("test.txt"); Control co = new Button(); } public void SimuleChangeVisibility() { if (VisibilityChanged != null) VisibilityChanged(this, new KeyValueEventArgs<Control, bool>(co, co.Visible)); } public void SimuleMessageArrived(string s) { if (MessagePopped != null) MessagePopped(this, new KeyEventArgs<string>(s)); } public void SimuleAsk2Nbs(int a, int b) { if (SumRequested != null) SumRequested(this, new KeyValuesEventArgs<StreamWriter, int>(fi, a, b)); } public void SimuleAsk8Nbs(int a, int b, int c, int d, int e, int f, int g, int h) { if (SumRequested != null) SumRequested(this, new KeyValuesEventArgs<StreamWriter, int>(fi, a, b, c, d, e, f, g, h)); } /// <summary> /// The main entry point for the application. /// </summary> [STAThread] static void Main() { ClassSimulation c = new ClassSimulation(); c.MessagePopped += new EventHandler<KeyEventArgs<string>>(c_MessagePopped); c.SumRequested += new EventHandler<KeyValuesEventArgs<StreamWriter, int>>(c_SumRequested); c.VisibilityChanged += new EventHandler<KeyValueEventArgs<Control, bool>>(c_VisibilityChanged); //Simulation c.SimuleAsk2Nbs(2, 7); c.SimuleChangeVisibility(); c.SimuleMessageArrived("MessageArrived"); c.SimuleChangeVisibility(); c.SimuleAsk8Nbs(1, 2, 3, 4, 5, 6, 7, 8); } static void c_VisibilityChanged(object sender, KeyValueEventArgs<Control, bool> e) { Console.WriteLine("Visibility of {0} changed to {1}", e.Key, e.Value); } static void c_SumRequested(object sender, KeyValuesEventArgs<StreamWriter, int> e) { string res = String.Format("La somme de tous les nombres donne {0}", e.Values.Sum()); Console.WriteLine(res); e.Key.WriteLine(res); } static void c_MessagePopped(object sender, KeyEventArgs<string> e) { Console.WriteLine(e.Key); } } }

Conclusion :


KeyEventArgs<TKey> : Un paramètre

KeyValueEventArgs<TKey,TValue> : Deux parametres, de deux types pouvant différés

KeyValuesEventArgs<TKey,TValue> : Un nombre >=2 paramètres, étant tous du même types sauf le premier qui peut différer.

A voir également

Ajouter un commentaire

Commentaires

billou_13
Messages postés
860
Date d'inscription
jeudi 4 mars 2004
Statut
Membre
Dernière intervention
19 août 2014
16 -
Si je met pas de notes... (dsl)
billou_13
Messages postés
860
Date d'inscription
jeudi 4 mars 2004
Statut
Membre
Dernière intervention
19 août 2014
16 -
Source intéressante. (manque un p'tit peu de commentaire qd même)

Il est vrai que ça devient vite rébarbatif de créer N événement avec autant de fonctions "delegates" qui vont bien.
Cependant, je reste encore persuader que ce travail est nécessaire, qui plus est si les classes implémentées sont emmenées à devenir une bibliothèque partagée sur Internet ou fournie à d'autres projets.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.