Il Tipo dynamic

Nella versione 4.0 di C#, Microsoft ha introdotto un nuovo tipo di dati: il tipo dynamic. In realtà si tratta di un tipo static, ma a differenza degli altri tipi static, i membri (potenziali) di un oggetto dynamic non vengono verificati dal compilatore. Questo vi dà alcuni dei vantaggi dei linguaggi debolmente/dinamicamente tipizzati, pur mantenendo tutti i vantaggi di un linguaggio fortemente tipizzato in tutti gli altri casi.

Dichiarare un tipo dynamic è come dichiarare qualsiasi altro tipo; semplicemente, usa la keyword dynamic al posto del tipo di dati:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;

Ora hai tre oggetti differenti: il primo a questo punto non contiene niente (null), mentre il secondo è di tipo testo (string) e il terzo è un intero (integer). Sarà l'interprete ad assegnare automaticamente questi tipi a runtime, in base ai valori che hai assegnato alle variabili. Ciò significa anche che il compilatore non farà alcuna verifica su quello che farai con queste variabili, come viene illustrato dall'esempio seguente:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;
Console.WriteLine(d2.Length);
Console.WriteLine(d3.Length);

I tipi string hanno una proprietà lenght, che ne contiene la lunghezza, ma ciò non vale per il tipo integer. In questo caso, cerco di usare questa proprietà in entrambe le variabili, e il compilatore non avrà nulla da ridire. Se queste variabili fossero state dichiarate come string e integer, il compilatore avrebbe intercettato l'errore. Ma poiché i tipi sono dynamic, si limita a compilare e lanciare l'eseguibile. Tuttavia, non appena l'interprete raggiunge l'ultima riga, viene sollevata un'eccezione, perché naturalmente non è possibile accedere ad una proprietà che non esiste.

Questo dimostra il pericolo insito nei tipi dinamici - devi essere consapevole di quel che stai facendo ed assicurarti di scrivere correttamente ogni proprietà e ogni chiamata di metodo, perché il compilatore non farà alcun controllo, permettendoti praticamente di pubblicare codice che fallisce ogni volta che viene eseguito.

Un oggetto dynamic

La parola chiave dynamic può, naturalmente, essere usata per tipi più complessi di interi e stringhe. Un grande esempio di questo è quando viene usata per contenere un oggetto anonimo, come questo:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.Name + " is " + user.Age + " years old");

Questo ti permette di creare un oggetto senza prima definire una classe per esso. La keyword dynamic può essere usata per contenerlo, ma allo stesso modo può essere usata la keyword var, che può risultare più adatta allo scopo in molte situazioni.

Potresti pensare che poiché il tipo è dynamic, allora puoi aggiungere ad esso nuove proprietà in un secondo tempo, come qui di seguito:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
user.HomeTown = "New York";

Poiché su un tipo dynamic non viene fatta alcuna verifica in fase di compilazione, questo codice viene di fatto eseguito, perché il compilatore non valida l'esistenza della proprietà HomeTown; ma non appena viene raggiunta l'ultima riga, verrà sollevata un'eccezione. Anche se un tipo dynamic È davvero dinamico, esso non ti consente di aggiungergli dinamicamente nuove proprietà. Per fare questo, puoi usare un ExpandoObject, del quale discuteremo nel prossimo articolo.

Cambiare il tipo

Una variabile dichiarata dynamic non è affatto priva di tipo. Invece, C# la tratterà internamente come qualsiasi tipo di oggetto tu le abbia assegnato. Nel nostro prossimo esempio, vedremo come possiamo dichiarare una variabile dynamic, assegnarle un valore string oppure integer, e poi iniziare ad usare le proprietà appartenenti a questi tipi. È possibile, tuttavia, cambiare facilmente il tipo di una variabile dynamic, semplicemente assegnando ad essa un nuovo valore. Ecco un esempio:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.GetType() + ": " + user.Name + " is " + user.Age + " years old");
user = "Jane Doe";
Console.WriteLine(user.GetType() + ": String.Length = " + user.Length);

Da notare come usiamo la variabile dynamic user: prima contiene un oggetto anonimo e poi invece le assegniamo una semplice stringa. La validiamo usando il metodo GetType() presente in tutti gli oggetti C# e, in entrambi i casi, accediamo alle proprietà trovate nel tipo che abbiamo in quel momento (prima le proprietà Name e Age dell'oggetto anonimo, poi la proprietà Length degli oggetti stringa).

Riepilogo

La parola chiave dynamic permette di usare variabili che non hanno un tipo specifico. Invece, si comportano come il tipo di dato che contengono. Si può facilmente assegnare un nuovo valore ad una variabile dynamic e, se questo non è dello stesso tipo di quello assegnato in quel momento, la variabile dynamic aggiornerà automaticamente il proprio tipo.

Le variabili dynamic non sono controllate dal compilatore, permettendo di accedere a proprietà che potrebbero non essere presenti. Questo le rende molto flessibili, ma rende anche le nostre applicazioni molto più vulnerabili agli errori. Proprio per questa ragione, è consigliabile riservare l'uso della parola chiave dynamic a quelle situazioni in cui non si riesce ad ottenere ciò che si vuole senza usarla. Esempi di situazioni in cui ha senso usare la parola chiave dynamic sono con operazioni con oggetti COM e nell'interazione con formati come JSON e XML.