ASP.Net  »  Articoli  »  Programmazione ASP.NET 

Risoluzione Dinamica (Dynamic Lookup)

Fino alla versione 3.0 di C# l'unico modo per invocare dinamicamente i membri di una classe era tramite la Reflection. Con la prossima versione grazie alle novità introdotte potremmo scrivere del codice che sfrutta la risoluzione dinamica. Cos'è la risoluzione dinamica?

La risoluzione dinamica consiste nella possibilità di scrivere codice che verrà valutato durante l'esecuzione piuttosto che in fase di compilazione. In sostanza quello che possiamo fare è "dire" al compilatore: "qualsiasi operazione effettuata su questo tipo, voglio che venga esclusa dalla fase di compilazione e valutata solo durante l'esecuzione".

Questo modo di lavorare ci risulterà comodo in determinati scenari che sono per loro natura dinamici, ovvero:

• Accesso dinamico, quindi tramite Reflection, ad oggetti .NET
• Interoperabilità con oggetti COM
• Strutture di oggetti soggette a cambiamento come il DOM di una pagina web
• Interazione con linguaggi puramente dinamici come Python e Ruby

Il tipo 'dynamic'

Per rendere un oggetto dinamico non dobbiamo far altro che dichiararlo utilizzando il nuovo tipo dynamic, dopodiché possiamo effettuare su di esso tutte le operazione che vogliamo, come invocare metodi piuttosto che impostare proprietà.

Il funzionamento visto ad alto livello è molto semplice. Normalmente il codice viene compilato come staticamente tipizzato, quando utilizziamo la keyword dynamic indichiamo al compilatore che non conosciamo la natura di quell'oggetto e che quindi vogliamo utilizzare la risoluzione dinamica, sia per l'operazione stessa, sia per i parametri richiesti da essa.

Per esempio ipotizziamo di aver definito una classe completamente vuota di nome Example.

 
//il successivo frammento di codice produrrà un errore in fase di compilazione
var e = new Example();
e.Process(5,"prova");

//mentre il seguente passerà la fase di compilazione ma produrrà un errore in fase di esecuzione
dynamic d = new Example();
d.Process(5,"prova");
d.SomeProperty = 12.34m;
d["chiave"] = "valore";

Possiamo implicitamente convertire qualsiasi tipo in dynamic e viceversa, in questo caso dobbiamo indicare il specifico tipo.

 
dynamic d = 10; // conversione implicita
int x = d;      // conversione implicita (valutata a run-time)
var y = d;      // conversione non valida

Anche la risoluzione del corretto overload di un metodo avviene in fase di esecuzione. Prendiamo come esempio il metodo statico Abs della classe Math, del quale esistono sei overload per sei differenti tipi di parametro.

 
// viene scelto in fase di compilazione l'overload per il tipo int
int x = 10;
int result = Math.Abs(x);

// viene scelto in fase di esecuzione l'overload per il tipo int prima e double dopo
dynamic y = 10;
dynamic result = Math.Abs(y);
dynamic k = 1.75;
dynamic result = Math.Abs(k);

Qualsiasi valore restituito dall'accesso ad un membro dinamico è sua volta di tipo dinamico.

 
//var è a sua volta di tipo dynamic
dynamic y = 10;
var result = Math.Abs(y);

Va sottolineato il fatto che, all'interno di Visual Studio, per il tipo dynamic non abbiamo il supporto dell'IntelliSense, questo perché l'oggetto reale non è conosciuto in fase di compilazione.

Quando l'applicazione sarà in esecuzione il run-time cercherà di effettuare la risoluzione delle operazioni effettuate, se non vi riuscirà, scatenerà un'eccezione. Questo comportamento rappresenta sia l'aspetto positivo, sia quello negativo dei linguaggi dinamici: di fatto se utilizzato in maniera incontrollata in tutti i contesti di sviluppo può portare notevoli svantaggi. Per questo è opportuno valutare con attenzione i casi in cui utilizzare oggetti dinamici.

Altri articoli

Altre guide

Altre newsletter