TOC

This article is currently in the process of being translated into Italian (~71% done).

Tipi di dati:

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);

Notice how we use the dynamic user variable: First it holds an anonymous object and then we assign a simple string to it instead. We validate it by using the GetType() method found on all C# objects, and in both cases, we access properties found on the type we currently have (first Name/Age properties of the anonymous object, then the Length property found on string objects).

Riepilogo

The dynamic keyword allows you to use variables which are not type-specific - instead, they act as the kind of data which they hold. You can easily assign a new value to a dynamic variable, and if the type of value you are assigning is not the same as it currently holds, the dynamic variable will simply change type automatically.

Dynamic variables are not checked by the compiler, allowing you to access properties which may or may not be present. This makes them very flexible, but it also makes your applications a lot more vulnerable to errors. Especially for this reason, you may want to restrict the usage of the dynamic keywords to situations where you can't accomplish what you want without using it. Examples of when it makes good sense to use the dynamic keyword are for COM interop and when interacting with data formats like JSON and XML.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!