Massimiliano Spinetti PMP

In questo breve post voglio parlare degli Extension Method, una novità introdotta con la versione 3 del Framework.

Difficoltà:
Piattaforma: C#.

Il loro principale utilizzo è quello di estendere i metodi di una classe quando non è possibile utilizzare l’ereditarietà, quando non si ha il codice sorgente o quando semplicemente, si vogliono aggiungere metodi senza dover modificare la classe originale.
Gli Extension method vengono dichiarati come metodi statici di classi esterne statiche, e vengono riconosciuti dall’Intellisense come metodi interni alla classe.

In C# la dichiarazione di un Extended Method è quindi simile a quella di un metodo statico, fatta eccezione per il primo parametro del metodo che è composto dalla parola chiave this e dal nome del tipo da estendere.

Sebbene a prima vista la differenza che c’è tra un Extension method ed un normale metodo di classe sembra molto poca, in realtà gli utilizzi che se ne possono fare sono diversi, basti pensare ad esempio che gli Extension method vengono usati dalla classe Enumerable di  Linq per estendere l’interfaccia generica IEnumerable 

Pur essendo dei metodi statici di classe, questi appaiono come metodi dell’istanza ma non possono però accedere alle variabili private interne all’istanza.
Inoltre, al contrario dell’ereditarietà in cui è possibile fare l’ovverride di un metodo della classe parent, nel caso degli extension method, se la classe base e la classe che estende hanno un metodo con stessa firma, allora verrà eseguito automaticamente il metodo della classe base. E’ invece consentito l’overload.  

Vediamo ora un esempio e creiamo la classe da estendere UserClass:

    public class UserClass
    {
        private string m_Name;
        private string m_Surname;
        private Int16 m_Age;

        public UserClass()
        {
            this.m_Name = “”;
            this.m_Surname = “”;
            this.m_Age = 10;
        }
        public string Name
        {
            get
            {
                return m_Name;
            }
            set
            {
                m_Name = value;
            }
        }

        public string Surname
        {
            get
            {
                return m_Surname;
            }
            set
            {
                m_Surname = value;
            }
        }

        public Int16 Age
        {
            get
            {
                return m_Age;
            }
            set
            {
                m_Age = value;
            }
        }

Ora creiamo la classe UserClassExtension che estenderà la prima:

    public static class UserClassExtension
    {
        public static Boolean IsAdult(this UserClass user)
        {
            if (user.Age >= 18)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

Qui è visibile l’unico metodo IsAdult che vuole come unico parametro un istanza del tipo da estendere.

A questo punto possiamo andare ad istanziare un oggetto del tipo UserClass e possiamo vedere: sia come l’intellisense riconosce il metodo come se fosse effettiva parte integrante della classe, sia come il metodo statico venga effettivamente eseguito sull’istanza corrente.

            UserClass User = new UserClass();
            User.Name = “Jon”;
            User.Surname = “Doe”;
            User.Age = 18;
             
            if (User.IsAdult())
            {MessageBox.Show(“Adult”);}
            else
            { MessageBox.Show(“Child”); }

Possiamo notare inoltre che il metodo non richiede nessun parametro in ingresso, infatti il primo parametro che è quello che identifica l’istanza, viene omesso.

Per testare come si comporta un Extension Method nel caso in cui il metodo esista già, facciamo un altro esempio.

Creiamo una classe Sealed UserFinalClass che ha già un metodo IsAdult

   public sealed class UserFinalClass
    {
        private string m_Name;
        private string m_Surname;
        private Int16 m_Age;

        public UserFinalClass()
        {
            this.m_Name = “”;
            this.m_Surname = “”;
            this.m_Age = 9;
        }
     
     …
     …
     
        public bool IsAdult()
        {
            if (this.m_Age >= 18)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

 Creaiamo ora la classe che la estenderà:

  public static class UserFinalClassExtension
    {
        public static Boolean IsAdult(this UserFinalClass user)
        {
            if (user.Age >= 16)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public static Boolean IsTeenAger(this UserFinalClass user)
        {
            if ((user.Age >= 13) && (user.Age <= 19))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    }

In questo caso,  eseguendo il codice seguente, possiamo notare che per metodo IsAdult verrà chiamato quello definito nella classe base mentre per il metodo IsTeenAger verrà chiamato l’Extension method.

            UserFinalClass UserFinal = new UserFinalClass();
            UserFinal.Name = “Jon”;
            UserFinal.Surname = “Doe”;
            UserFinal.Age = 16;

            if (UserFinal.IsAdult())
            { MessageBox.Show(“Adult”); }
            else
            { MessageBox.Show(“Child”); }

            if (UserFinal.IsTeenAger())
            { MessageBox.Show(“Teenager”); }
            else
            { MessageBox.Show(“I’m not a teenager”); }

In conclusione, abbiamo visto come usando gli Extension method è possibile  crearsi librerie esterne che estendono classi esistenti, ad esembio le classi basi del framework. Potete trovare qualche metodo utile su questo link.

Alla prossima