C# 4.0 introduce un nuovo tipo: dinamico, che è un tipo statico, ma un'istanza di oggetto di questo tipo è in grado di bypassare il processo di controllo statico dei tipi (static type check). Nella maggior parte dei casi, il tipo funziona come una classe oggetto. Al momento della compilazione, un'istanza di una classe dinamica supporta qualsiasi operazione, quindi non c'è bisogno di preoccuparsi se l'oggetto venga preso da un'API COM, o da un linguaggio dinamico come IronPython, dal DOM HTML, dalla reflection o da qualche altra parte del programma. Tuttavia, se il codice fa qualcosa di non valido, l'errore viene rilevato in tempo reale.
Ad esempio, il metodo exampleMethod1 nel seguente frammento di codice ha un solo parametro, e il compilatore può identificare che è invalido quando chiama ec.exampleMethod1(10,4) in tempo di compilazione; Questo è un errore di compilazione. La seconda chiamata dynamic_ec.exampleMethod1(10,4) non viene controllata per i tipi statici. Pertanto, il compilatore non segnala errori di compilazione. Tuttavia, il bug non si nasconde per sempre; Verrà rilevato in tempo di esecuzione e attiverà un'eccezione in tempo reale.
static void Main(string[] args){
ExampleClass ec = nuova ExampleClass();
dinamico dynamic_ec = nuova ClasseEsempio();
dynamic_ec.exampleMethod1(10, 4);
dynamic_ec.someMethod("qualche argomento", 7, null);
dynamic_ec.nonexistentMethod();
}
classe EsempioClasse {
pubblica ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void exampleMethod2(stringa str) { }
}
Ecco un esempio di utilizzo dinamico per chiamare IronPython:
usando IronPython.Hosting;
usando Microsoft.scrip{filtering}ting. Ospitare;
Console.WriteLine("Caricamento random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
Dinamico casuale = Py. UseFile("random.py");
Console.WriteLine("random.py caricato!");
var items = Enumerabile. Range(1, 7). ToArray();
per (int s = 0; s < 10000; s++) {
casuale.mescola(oggetti);
Console.Write("Sequence {0}: ", s);
foreach (int i in items) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
Per oggetti o espressioni di tipo dinamico, il ruolo del compilatore è incapsulare le azioni che ogni espressione dovrebbe eseguire e, al momento dell'esecuzione, controllare le informazioni memorizzate, e qualsiasi istruzione invalida attiverà un'eccezione a runtime.
Il tipo di risultato della maggior parte delle operazioni dinamiche è anch'esso dinamico. Ad esempio, se passi il puntatore del mouse sopra il testSum nell'esempio seguente, lo smart prompt mostrerà un testSum dinamico (variabile locale).
dinamico d = 1;
var testSum = d + 3;
Passa il mouse con il puntatore del mouse sul testSum qui sotto.
System.Console.WriteLine(testSum);
Conversione di tipo
La transizione tra istanze di tipo Dynamic e altri tipi di istanze è semplice, e gli sviluppatori possono facilmente passare da comportamenti dinamici a non dinamici. Qualsiasi istanza può essere implicitamente convertita in un'istanza di tipo dinamico, vedi il seguente esempio:
dinamico d1 = 7;
dinamico d2 = "una stringa";
dinamico d3 = System.DateTime.Today;
dinamico d4 = System.Diagnostics.Process.GetProcesses();
Viceversa, una conversione implicita può essere applicata dinamicamente a qualsiasi espressione di dinamica di tipo.
E viceversa, qualsiasi espressione di dinamica di tipo può anche essere implicitamente convertita in altri tipi.
int i = d1;
stringa forza = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Problema di sovraccarico con i parametri dinamici del tipo nel metodo
Se un metodo viene chiamato "
DLR a runtime dinamico del linguaggio
Il runtime dinamico del linguaggio è . NET Framework 4 Beta 1 è un nuovo insieme di API che supportano tipi dinamici in C# e implementano anche linguaggi di programmazione dinamica come IronPython e IronRuby.
Interoperabilità COM
C# 4.0 include diverse funzionalità che migliorano l'interoperabilità con le tradizionali interfacce API COM come l'automazione di Office. Tipi dinamici, parametri nominati e parametri opzionali fanno anch'essi parte del miglioramento.
Molti metodi COM permettono che i loro parametri e valori di ritorno siano di tipo oggetto, quindi per linguaggi fortemente tipati come C#, è richiesta molta conversione forzata di tipo. Tuttavia, in C# 4.0, se aggiungi l'opzione /link a tempo di compilazione, il tipo dinamico ha un nuovo effetto: rende il tipo oggetto (tipo di parametro o tipo di ritorno) nella firma del metodo dell'interfaccia COM considerato dinamico, evitando così molte conversioni di tipo. Ad esempio, la seguente affermazione contrasta questa situazione.
Non viene utilizzato dinamico.
((Excel.Range)Excel. Celle[1, 1]). Value2 = "Nome";
Excel. Range = (Excel.Range) excel. Celle[1, 1];
Era un gioco dinamico.
Excel. Celle[1, 1]. Valore = "Nome";
Excel. Range = excel. Celle[1, 1]; |
Pubblicato su 07/07/2016 10:23:00
|
|
|
