cyphersec A blog about Web Application Security and .NET development best practices

Implicitly Typed Local Variables in C# 2008.

Con il rilascio di C# 2008 e la piattaforma .NET 3.5 in generale, nuove features per la manipolazione dei dati sono state  introdotte.

In particolare C# 2008 continua ad essere il linguaggio ad aver ricevuto alcune delle piu' interessanti.

Come sempre e' bene ricordare che .NET 3.5 e' .NET 2.0 piu' <qualcosa>; Quindi i sistemi legacy sono ancora validi ma, sconsigliati in termini di performance (95%) e rapporto developer/tempo.

Per esempio in C# 2008 e' possibile dichiarare variabili in modo implicito anziche' esplicito.  Sembra una cosa da poco, ma e' molto interessante capirne il concetto per utilizzarle al meglio e trarne il maggior guadagno.

Allora, prendete qualunque programmatore C# e chiedetegli di dichiararvi tre variabili (int,string,boolean). Il 99% rispondera' cosi'

    class Program
    {
        static void Main(string[] args)
        {
            // int32
            int TypeInteger = 0;
            // string
            string TypeString = string.Empty;
            // bool
            bool TypeBool = false;
        }
    }
Questo modo di dichiarare le variabili si chiama "Esplicito". Ora con C# e' possibile fare esattamente lo stesso solo in modalita' Implicita.

    class Program
    {
        static void Main(string[] args)
        {
            var TypeInteger = 0;            // Integer
            var TypeString = "alessio";        // String
            var TypeBool = false;            // Boolean
        }
    }
Quando questo si verifica il compilatore dedurra' il tipo di dell'oggetto che sta "valorizzando" la variabile e quindi dichiarera' quest'ultima con il corrispondente tipo.

In questo caso qui sopra, TypeInteger sara' un System.Int32, TypeString sara' System.String e TypeBool sara' System.Boolean.  Per verificare questo e' possibile scrivere il seguente codice.

    class Program
    {
        static void Main(string[] args)
        {
            var TypeInteger = 0;            // Integer
            var TypeString = "alessio";        // String
            var TypeBool = false;            // Boolean

            Console.WriteLine("TypeInteger is a: {0}", TypeInteger.GetType().Name);
            Console.WriteLine("TypeString is a: {0}", TypeString.GetType().Name);
            Console.WriteLine("TypeBool is a: {0}", TypeBool.GetType().Name);

            Console.ReadLine();
        }
    }
Naturalmente si puo' effettuare questo anche con tutti gli oggetti .NET come Custom Types, List, Arrays etc.  E' possibile fare uso della keyword var anche in cicli foreach. Per esempio

    class Program
    {
        static void Main(string[] args)
        {
            var numeriPari = new int[] { 2, 4, 6, 8 };

            foreach (var singoloNumeroEstratto in numeriPari)
            {
                Console.WriteLine("Valore: {0}", singoloNumeroEstratto);
            }
        }
    }
Da ricordare che fare uso di keyword var in cicli foreach e' altamente sconsigliato in termini di performance. In qualunque operazione di iterazione l'utilizzo di iteratori base 32 int e' consigliata per via del fatto  che questi sono ottimizzati hardware.

La conversione implicita di dati in C# 2008 ha comunque delle restrizioni. <Questo e' importante>.

Per prima cosa si deve tenere a mente che e' possibile eseguirlo solo ed unicamente su variabili locali, metodi o proprieta'.

1. var non puo' essere nullable.
2. var non puo' essere un: return value, parameter, field data type.

Vantaggi:

Var porta lo Strong Data Typing dove prima non esisteva.

La filosofia .NET 3.5 tende a ridurre a zero il boxing per via del semplice fatto che Object era l'unica risposta in molti casi. Oggi con .NET e' possibile sistemi che si astraggono dai stati primitivi di programmazione. Man mano che si procede nelle certificazioni Visual Studio 2008 si nota come Microsoft abbia cercato di dare la possibilita' di far guadagnare piu' tempo ai sviluppatori lasciandoli lavorare piu' sul Object Oriented invece che fargli scornare con problematiche inutili.

La piattaforma Microsoft nasce e resta una tecnologia per il BUSINESS. Per questo ora in .NET e' possibile lavorare con entita' di cui non si conosce il tipo. Tutto si sta trasformando in entita' (e' su questa filosifia che e' nato Entity Framework (prima dai Generics poi dai var etc).

var si rende utile quando si lavora con collezioni di cui non si ha controllo. Vedi Linq.

Faccio un esempio veloce cosi' si arriva velocemente a capire il concetto.
Il seguente snippet e' di Andrew Troelsen e dimostra perfettamente l'importanza di var.

        static void Main(string[] args)
        {
            int[] numbers = { 10,20,30,40,1,2,3,8};
            var subset = from i in numbers where i > 8 select i;

            Console.WriteLine("Values in subset: ");

            foreach (var i in subset)
            {
                Console.WriteLine("{0} :", i);
            }

            Console.WriteLine();

            // Hmm... what type is subset?
            Console.WriteLine("subset is a: {0}", subset.GetType().Name); 
            Console.ReadLine();
        }

Ritorna :

Values in subset:
10 :
20 :
30 :
40 :

subset is a: <WhereIterator>d__0`1
subset is defined in: <WhereIterator>d__0`1

chi avrebbe detto un array di integers e' bocciato