Delegate

I delegate sono dei tipi che consentono delle chiamate di metodo indirette. Una istanza di delegate contiene un puntatore ad un certo numero di metodi, e l'invocazione del delegate, consente la chiamata del metodo. Per chi conoscesse C++, i Delegate corrispondono alle funzioni di callback.

Per utilizzare i Delegate occorre fare tre cose:

• Dichiararli
• Instanziarli
• Richiamarli

Dichiarare ed istanziare un Delegate

Vediamo un esempio:

using System;
public class Sample
{
  //Dichiaro il delegate
  public delegate string metodoDelegate(int numero);
  //La mia classe
  public class classeDelegate
  {

    public string controllaSegno(int numero)
    {
      if (numero = 0)
        return("uguale di zero");
      else if (numero < 0)
        return("Minore di zero");
      else
        return ("uguale a zero");
      }
    }

    public static void Main()
    {
        // Creo i delegati.
        classeDelegate c = new classeDelegate();
        metodoDelegate d = new metodoDelegate(c.controllaSegno);

        // Invoco i delegati.
        int[] numeri = {-1,2,19,-2,0,4};
        foreach (int num in numeri)
          Console.WriteLine("Il numero {0} è {1}; ", num, d(num));
      }
}

La riga public delegate String metodoDelegate(int numero); dichiara il delegate, la classe classeDelegate contiene i metodi richiamabili

Nel Main istanziamo la classe ed il metodo Delegate, e poi lo richiamiamo passandogli dei valori diversi.

L'output sara:

Il numero -1 è minore di zero;
Il numero 2 è maggiore di zero;
Il numero 19 è maggiore di zero;
Il numero -2 è minore di zero;
Il numero 0 è uguale a zero;
Il numero 4 è maggiore di zero;

Eventi

Gli eventi sono simili alle chiamate di metodo, ma a differenza di questi ultimi, la loro invocazione deve essere generata esternamente.
Un esempio classico è la pressione di un pulsante in una interfaccia grafica o una pagina web.
Gli eventi sono realizzati tramite un tipo particolare di Delegate, detti "multicast".

Si deve creare un delegate e poi "sottoscrivere" l'evento tramite la sintassi:

classe.Evento += new GestoreEvento.EventDelegate(funzione);

Vediamo un esempio pratico:

using System;
//Dichiaro il delegate
delegate void testEventHandler(object source, string messaggio);
class test
{
    //L'evento
    public event testEventHandler testEvento;
    //La funzione che scatena l'evento
    public void Evento(string messaggio)
    {
        Console.WriteLine("Evento!");
        if (testEvento != null)
        {
            testEvento(this, messaggio);
        }
    }
}
public class EventSample
{
    public EventSample() {}
    static void Main()
    {
        //istanzio la classe
        test b = new test();
        //Agiungo il gestore di eventi
        b.testEvento += new testEventHandler(onTestAction);
        //Scateno l'evento
        b.Evento("ciao, sono un evento!");
    }
    //La funzione che gestisce l'evento
    public static void onTestAction(object source, string messaggio)
    {
        Console.WriteLine("Siamo all'interno del gestore di eventi.");
        Console.WriteLine("Messaggio: " + messaggio);
    }
}

Il Main istanzia una classe "test" che contiene un gestore di eventi,
viene poi sottoscritto il metodo che risponde agli eventi ed infine scatenato l'evento

Ecco l'output:

Evento!
Siamo all'interno del gestore di eventi.
Messaggio: ciao, sono un evento!