How To: Use Event and Delegate C#

Uno dei post più letti del mio blog, è anche uno dei post meno curati. Ho notato guardando le statistiche che molti arrivano sul mio blog cercando Eventi e Delegati.

Quindi propongo questo nuovo post dove spiego molto più accuratamente l'argomento.

In questo esempio creo un Handler per un Evento che poi utilizzerò delegandolo in due punti differenti e per due scopi differenti.

Per questo esempietto tuttavia mi serve sempre la mia cara classe Entity che ormai
trionfa e appare quasi come una diva sulla passerella.

public class entity
{
    public int id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
}

Come sempre le 3 solite proprietà (id, nome e descrizione) non c'e' molto altro da
spiegare.

Questo è Handler per il mio evento, chiaro è che servirà anche per il delegato

public class LimitElementArgs
{
    private DateTime _dt;
    public DateTime DateTimeOf
    {
        get { return _dt; }
        set { _dt = value; }
    }

    public LimitElementArgs(DateTime dt)
    {
        _dt = dt;
    }
}

L'unico argomento che mi serve per questo esempio è una data, e come più o meno
si può intuire non farà altro che contenere il momento in cui è avvenuto qualcosa.

Questa classe è diciamo la mia BU ossia l'unità in cui svolgerò compiti e mansioni,
anche se per questo caso specifico c'e' ben poco da notare.
La parte importante riguarda proprio la dichiarazione degli eventi (delegabili da chi usa la classe ) e dei Delegati stessi.

public class doLoop
{ 
    public delegate void LimitReachedHandlers (LimitElementArgs Args);

    public event LimitReachedHandlers Readed100Element;

    public event LimitReachedHandlers Readed1000Element;

    public void DoLoop(List<entity> Element)
    {

        for (int i = 0; i < Element.Count; i++)
        {
            if (i ==100)
            {
                Readed100Element(
                            new LimitElementArgs(DateTime.Now)
                            );
            }

            if (i ==1000)
            {
                Readed100Element(
                            new LimitElementArgs(DateTime.Now)
                            );
            }            
        }        
    }    
}

A tutti gli effetti esegue un semplice ciclo da 1 a n su un elenco di elementi
ma quanto trova il 100esimo o il 1000esimo scatena un evento.
Tuttavia proseguirà il Loop.


E questo è il nostro main.

class Program
{
    public static doLoop dl = new doLoop();

    static void Main(string[] args)
    {
        dl.Readed100Element += new doLoop.LimitReachedHandlers(dl_Readed100Element);
        dl.Readed1000Element +=new doLoop.LimitReachedHandlers(dl_Readed1000Element);


        List<entity> eL = new List<entity>();
        for (int i = 0; i < 1080; i++)
        {
            eL.Add(new entity { id = i, Name = "Test", Description = "test" });
        }

        dl.DoLoop(eL);

        Console.ReadLine();
    }

    static void dl_Readed100Element(LimitElementArgs Args)
    {
        DoTrace(100, Args);
    }

    static void dl_Readed1000Element(LimitElementArgs Args)
    {
        DoTrace(1000, Args);
    }


    static void DoTrace(int limit,LimitElementArgs Args)
    {
            
        Console.WriteLine("limit [" + limit.ToString() + "]reached at " + Args.DateTimeOf);
    }
}

Questa è la dichiarazione dei delegati alla gestione degli eventi associati

dl.Readed100Element += new doLoop.LimitReachedHandlers(dl_Readed100Element);
dl.Readed1000Element +=new doLoop.LimitReachedHandlers(dl_Readed1000Element);

Questi sono i delegati che percepiscono gli argomenti forniti dall'evento.

static void dl_Readed100Element(LimitElementArgs Args)
{
    DoTrace(100, Args);
}

static void dl_Readed1000Element(LimitElementArgs Args)
{
    DoTrace(1000, Args);
}

Spero così di aver dato una panoramica molto più sostanziosa della precedente versione.