I delegati sono dei tipi che incapsulano uno o più metodi, nel framework .NET sono usati in abbondanza e sono assolutamente essenziali nella gestione degli eventi. Nella gestione degli eventi di una web form ASP.NET il framework rende molto facile e intuitivo utilizzarli anche senza capire come funzionano effettivamente. Anche LINQ fa un utilizzo massivo dei

Per facilitare il lavoro degli sviluppatori nel framework sono presenti dei delegati generici che rappresentano dei tipi comuni:

Action e Func<T>. Entrambi hanno molti overload che permettono di avere tipi col più parametri in ingresso, rimandiamo a MSDN per i dettagli. È possibile tuttavia definire i propri tipi di delegati e utilizzarli come variabili o proprietà all'interno del codice.

Potremmo avere quindi un metodo A che prende in ingresso un altro metodo B e dopo aver eseguito del codice lo invoca senza sapere nulla dell'implementazione di B. La situazione può complicarsi facilmente e diventare un vero rompicapo.

Per capire meglio come funzionano i delegati si può pensare ad un tipo di delegato come ad una interfaccia contenente un solo metodo e alle istanze di questo delegato come a istanze di classi che implementano l'interfaccia.

Vediamo nel codice seguente come definire un delegato e due sue istanze utilizzando la keyword delegate e le lambda expressions:

public delegate int DelOperazione(int i, int j);

class Program
{
    static void Main(string[] args)
    {
        DelOperazione delSomma = (i, j) => i + j;
        DelOperazione delMoltiplicazione = (i, j) => i * j;

        int n = 2;
        int m = 3;


        var risu1 = delSomma(n, m);
        var risu2 = delMoltiplicazione(n, m);
    }
}

La sintassi è semplice, veloce e pulita e le variabile delSomma e delMoltiplicazione sono metodi che possiamo chiamare in qualunque momento come ogni altro metodo. Vediamo come ottenere lo stesso utilizzando interfacce e classi. La sintassi è decisamente più lunga:

public interface IOperazione
{
    int Calcola(int i, int j);
}

public class ClasseSomma : IOperazione
{
    public int Calcola(int i, int j)
    {
        return i + j;
    }
}

public class ClasseMoltiplicazione : IOperazione
{
    public int Calcola(int i, int j)
    {
        return i * j;
    }
}

class Program
{
    static void Main(string[] args)
    {
        IOperazione classeSomma = new ClasseSomma();
        IOperazione classeMoltiplicazione = new ClasseMoltiplicazione();

        int n = 2;
        int m = 3;

        var somma = classeSomma.Calcola(n, m);
        var prod = classeMoltiplicazione.Calcola(n, m);
    }
}

L'interfaccia IOperazione incapsula il metodo e possiamo quindi utilizzare le nostre classi ignorando effettivamente l'implementazione del metodo Calcola di cui conosciamo solamente la firma. Invocare i metodi è più indiretto del caso dei delegati.

La sintassi alternativa è decisamente più lunga e laboriosa, pensiamo però che possa aiutare a capire concettualmente i delegati.

comments powered by Disqus