C# 4.0 introducerer en ny type: dynamisk, som er en statisk type, men en objektinstans af denne type kan omgå den statiske typekontrolproces. I de fleste tilfælde fungerer typen som en objektklasse. Ved kompilering understøtter en instans af en dynamisk klasse enhver operation, så der er ingen grund til at bekymre sig om, hvorvidt objektet er taget fra et COM API, eller et dynamisk sprog som IronPython, fra HTML DOM, fra refleksion eller et andet sted i programmet. Men hvis koden gør noget ugyldigt, bliver fejlen fanget under kørsel.
For eksempel har eksempelmetoden exampleMethod1 i det følgende kodeuddrag kun én parameter, og compileren kan identificere, at den er ugyldig, når den kaldes ec.exampleMethod1(10,4) ved kompilering; Dette er en kompileringsfejl. Det andet kald dynamic_ec.exampleMethod1(10,4) kontrolleres ikke for statiske typer. Derfor rapporterer compileren ikke kompileringsfejl. Men insektet gemmer sig ikke for evigt; Den vil blive fanget under kørsel og udløse en kørselsundtagelse.
statisk void Main(string[] args){
ExampleClass ec = ny ExampleClass();
dynamisk dynamic_ec = ny ExampleClass();
dynamic_ec.eksempelMetode1(10, 4);
dynamic_ec.someMethod("some argument", 7, null);
dynamic_ec.nonexistentMethod();
}
klasse EksempelKlasse {
public ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMetode1(int i) { }
public void exampleMetode2(streng str) { }
}
Her er et eksempel på at bruge dynamisk til at kalde IronPython:
ved brug af IronPython.Hosting;
ved brug af Microsoft.scrip{filtering}ting. Vært;
Console.WriteLine("Indlæser random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
dynamisk tilfældigt = py. UseFile("random.py");
Console.WriteLine ("random.py indlæst!");
var-items = Enumerable.Range(1, 7). ToArray();
for (int s = 0; s < 10.000; s++) {
random.shuffle(items);
Console.Write("Sekvens {0}: ", s);
foreach (int i i items) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
For objekter eller udtryk af dynamisk type er compilerens rolle at indkapsle de handlinger, som hvert udtryk forventes at udføre, og ved eksekveringen kontrollere de lagrede oplysninger, og eventuelle ugyldige sætninger vil udløse en runtime-undtagelse.
Typen af resultat af de fleste dynamiske operationer er også dynamisk. For eksempel, hvis du holder musepekeren over testSum i det følgende eksempel, vil smart-prompten vise en (lokal variabel) dynamisk testSum.
dynamisk d = 1;
var testSum = d + 3;
Hold musemarkøren over testSum nedenfor.
System.Console.WriteLine(testSum);
Typekonvertering
Overgangen mellem dynamiske instanser og andre typer instanser er simpel, og udviklere kan nemt skifte mellem dynamiske og ikke-dynamiske adfærdsfunktioner. Enhver instans kan implicit konverteres til en dynamisk type instans, se følgende eksempel:
dynamisk d1 = 7;
dynamisk d2 = "en streng";
dynamisk d3 = System.DateTime.Today;
dynamisk d4 = System.Diagnostik.Proces.GetProcess();
Omvendt kan en implicit konvertering dynamisk anvendes på ethvert udtryk af typen dynamisk.
Og omvendt kan ethvert udtryk af typen dynamisk også implicit konverteres til andre typer.
int i = d1;
streng str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Overbelastningsproblem med dynamiske typeparametre i metoden
Hvis en metode kaldes passerer et objekt af typen dynamisk, eller det objekt, der kaldes, er af typen dynamisk, så sker vurderingen af overbelastning under kørsel og ikke ved kompileringstidspunktet.
Dynamisk sprog-runtime DLR
Den dynamiske sprog-runtime er . NET Framework 4 Beta 1 er et nyt sæt API'er, der understøtter dynamiske typer i C# og også implementerer dynamiske programmeringssprog som IronPython og IronRuby.
COM-interoperabilitet
C# 4.0 indeholder flere funktioner, der forbedrer interoperabiliteten med traditionelle COM API-grænseflader såsom Office-automatisering. Dynamiske typer, navngivne parametre og valgfrie parametre er også en del af forbedringen.
Mange COM-metoder tillader, at deres parametre og returværdier er af typen objekt, så for stærkt typede sprog som C# kræves der meget tvungen typekonvertering. Men i C# 4.0, hvis du tilføjer /link-muligheden ved kompilering, har den dynamiske type en ny effekt: den gør objekttypen (parametertype eller returtype) i COM-interface-metodesignaturen for dynamisk, hvilket undgår meget typekonvertering. For eksempel kontrasterer følgende udsagn dette.
Det bruges ikke dynamisk.
((Excel.Område) Excel. Celler[1, 1]). Value2 = "Navn";
Excel.Range range = (Excel.Range)excel. Celler[1, 1];
Det var en dynamisk en.
Excel. Celler[1, 1]. Værdi = "Navn";
Excel. Rækkeviddeområde = Excel. Celler[1, 1]; |
Opslået på 07/07/2016 10.23.00
|
|
|
