C # 4: esempio del mondo reale di tipi dinamici

Penso di avere il mio cervello a metà strada attorno al concetto di Dynamic Types in C # 4, ma non riesco a immaginare una scena in cui vorrei davvero usarla.

Sono sicuro che ce ne sono molti, ma sto solo avendo problemi a stabilire la connessione su come posso progettare una soluzione che sia meglio risolta con dinamiche rispetto alle interfacce, all’iniezione di dipendenza, ecc.

Quindi, qual è uno scenario di applicazione del mondo reale in cui l’utilizzo del tipo dinamico è appropriato?

Ci sono molti casi in cui si sta già utilizzando la digitazione dynamic e l’associazione dynamic oggi . Semplicemente non te ne rendi conto, perché è tutto nascosto dietro stringhe o System.Object , dal momento che fino al C # 4, il supporto necessario non c’era.

Un esempio è l’interoperabilità COM: COM è in realtà un sistema a oggetti semi-dinamico. Quando si esegue l’interoperabilità COM, molti metodi restituiscono effettivamente un object dinamico, ma poiché C # non li supporta, sono stati restituiti come System.Object e si è dovuto eseguire il cast da soli, con la possibilità di individuare eccezioni lungo il percorso.

Un altro esempio è l’interazione con dati digitati dynamicmente (o anche non tipizzati), come JSON, CSV, HTML, schemi XML, servizi web senza schemi, database di schemi (che sono, dopo tutto, la nuova hotness). Oggi usi le stringhe per quelli. Apparirà un’API XML

 var doc = new XmlDocument("/path/to/file.xml"); var baz = doc.GetElement("foo").GetElement("qux"); 

e così via. Ma che dire:

 dynamic doc = new XmlDocument("/path/to/file.xml"); var baz = doc.foo.qux; 

Non è bello?

Un terzo esempio è la riflessione. Oggi, l’invocazione di un metodo tramite riflessione viene effettuata passando una stringa a InvokeMember (o qualunque cosa venga chiamata la cosa). Non sarebbe più bello, sai, invocare solo quella dannata cosa?

Quindi, c’è una generazione di dati dinamici (sostanzialmente l’opposto del secondo esempio). Ecco un esempio di come generare un XML dinamico:

 dynamic doc = new XmlBuilder(); doc.articles(id=42, type="List", () => { article(() => { number(42); title("blahblubb");});}); 

Questo non è tanto bello quanto il Ruby equivalente, ma è il meglio che ho potuto ottenere con così poco preavviso 🙂

E, ultimo ma certamente non meno importante, l’integrazione con un linguaggio tipizzato dynamicmente. Che si tratti di JavaScript in un’applicazione Silverlight, un motore di regole personalizzate incorporato nell’app aziendale o un’istanza DLR ospitata nel programma CAD / IDE / editor di testo.

C’è un esempio su MSDN :

Molti metodi COM consentono la variazione nei tipi di argomento e il tipo restituito designando i tipi come object. Ciò ha richiesto il cast esplicito dei valori per coordinarsi con variabili fortemente tipizzate in C #. Se si compila usando l’opzione / link (Opzioni del compilatore C #), l’introduzione del tipo dinamico consente di trattare le occorrenze dell’object nelle firme COM come se fossero di tipo dinamico, e quindi di evitare gran parte del cast.

Un altro esempio è se devi eseguire l’interoperabilità con le lingue dinamiche.

Ci sono anche alcune occasioni in cui si desidera creare codice un po ‘generico, ma non è ansible perché anche se gli oggetti implementano lo stesso metodo, non condividono una class di base o un’interfaccia idonea che dichiari i metodi necessari. Un esempio di questo sta cercando di fare qualcosa di generico con ints e short. È un po ‘un trucco, ma la dynamic ti consente di chiamare gli stessi metodi su questi diversi tipi, consentendo un maggiore riutilizzo del codice.

Aggiornamento: un po ‘di ricerca qui ha trovato questo post correlato .

Dal blog di Walter Almeida: uno scenario di utilizzo della parola chiave dynamic in C # per migliorare l’orientamento dell’object:

http://blog.walteralmeida.com/2010/05/using-the-dynamic-keyword-in-c-to-improve-objectorientation.html

Scott Watermasysk ha scritto un articolo sull’utilizzo delle dinamiche per la mapping delle proprietà chiave del dizionario sul driver C # di MongoDB.

http://simpable.com/code/mongodb-dynamics/

Penso che altri abbiano dato grandi risposte finora, quindi voglio solo aggiungere questo esempio di David Hanson. Il post di Hist mostra l’applicazione più pratica che ho trovato finora per i tipi dinamici in C # in cui li usa per creare oggetti proxy. In questo esempio crea un proxy che consente di generare eccezioni sugli errori di binding di WPF. Non sono sicuro se questo potrebbe essere ottenuto anche nel caso di associazioni WPF usando CustomTypeDescriptors e concetti descrittivi di proprietà in generale, ma a prescindere penso che l’uso del nuovo tipo dinamico C # 4.0 sia una grande dimostrazione delle sue capacità.

Sollevare eccezioni vincolanti in WPF e Silverlight con .net 4.0 Dynamics

Un altro uso che posso pensare per i tipi dinamici è quello di creare proxy che possono essere collegati come DataContext in WPF o in altri luoghi in cui è previsto un tipo di object generico e vengono normalmente utilizzati metodi di riflessione per interrogare il tipo. In questi casi, in particolare durante la creazione di test, è ansible utilizzare un tipo dinamico che consente quindi di richiamare e registrare gli accessor delle proprietà in modo dinamico dall’object proxy in modo dinamico senza dover ricorrere alle proprietà dell’hardcode all’interno di una class di soli test.

Ho letto un interessante articolo su questo (allegato) di Scott Hanselman. Egli sottolinea che, invece di usare l’object, è ansible utilizzare i metodi di riferimento dinamici da vecchi oggetti COM in cui il compilatore non sa che esiste un metodo. Ho trovato il collegamento utile.

Scott Hanselman – C # 4 e la parola chiave dynamic