Eventhandlers génériques

Commenter

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

S'inscrire maintenant

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.

Du même auteur (ricklekebekoi)