C# 4.0 introduserer en ny type: dynamisk, som er en statisk type, men en objektinstans av denne typen kan omgå den statiske typesjekkprosessen. I de fleste tilfeller fungerer typen som en objektklasse. Ved kompilering støtter en instans av en dynamisk klasse enhver operasjon, så det er ikke nødvendig å bekymre seg for om objektet er hentet fra et COM-API, eller et dynamisk språk som IronPython, fra HTML DOM, fra refleksjon eller et annet sted i programmet. Men hvis koden gjør noe ugyldig, blir feilen fanget opp under kjøring.
For eksempel har eksempelmetoden exampleMethod1 i følgende kodesnippet bare én parameter, og kompilatoren kan identifisere at den er ugyldig når den kaller ec.exampleMethod1(10,4) ved kompilering; Dette er en kompilasjonsfeil. Det andre kallet dynamic_ec.exampleMethod1(10,4) er ikke sjekket for statiske typer. Derfor rapporterer ikke kompilatoren kompileringsfeil. Men billen skjuler seg ikke for alltid; Den vil bli fanget opp under kjøring og utløse et unntak under kjøring.
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 ExampleClass {
public ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void exampleMetode2(streng str) { }
}
Her er et eksempel på å bruke dynamisk for å kalle IronPython:
bruk av IronPython.Hosting;
ved bruk av Microsoft.scrip{filtering}ting. Vertskap;
Console.WriteLine("Laster random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
dynamisk tilfeldig = py. UseFile("random.py");
Console.WriteLine("random.py lastet!");
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 elementer) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
For objekter eller uttrykk av dynamisk type er kompilatorens rolle å kapsle inn handlingene som hvert uttrykk forventes å utføre, og ved kjøring sjekke den lagrede informasjonen, og eventuelle ugyldige setninger vil utløse et runtime-unntak.
Typen resultat for de fleste dynamiske operasjoner er også dynamisk. For eksempel, hvis du holder musepekeren over testSum i følgende eksempel, vil smartprompten vise en (lokal variabel) dynamisk testSum.
dynamisk d = 1;
var testSum = d + 3;
Hold musepekeren over testSum under.
System.Console.WriteLine(testSum);
Typekonvertering
Overgangen mellom dynamiske instanser og andre typer instanser er enkelt, og utviklere kan enkelt bytte mellom dynamiske og ikke-dynamiske atferder. Enhver instans kan implisitt 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.Diagnostikk.Prosess.GetProcesses();
Omvendt kan en implisitt konvertering dynamisk anvendes på ethvert uttrykk av type dynamisk.
Og omvendt kan ethvert uttrykk av type dynamisk også implisitt konverteres til andre typer.
int i = d1;
streng str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Overbelastningsproblem med dynamiske typeparametere i metoden
Hvis en metode kalles passerer et objekt av typen dynamisk, eller objektet som kalles er av typen dynamisk, skjer vurderingen av overbelastning under kjøring og ikke ved kompileringstid.
Dynamisk språkkjøretids-DLR
Den dynamiske språkkjøretiden er . NET Framework 4 Beta 1 er et nytt sett med API-er som støtter dynamiske typer i C# og også implementerer dynamiske programmeringsspråk som IronPython og IronRuby.
COM-interoperabilitet
C# 4.0 inkluderer flere funksjoner som forbedrer interoperabiliteten med tradisjonelle COM API-grensesnitt som Office-automatisering. Dynamiske typer, navngitte parametere og valgfrie parametere er også en del av forbedringen.
Mange COM-metoder tillater at parameterne og returverdiene deres er av type objekt, så for sterkt typede språk som C# kreves mye tvungen typekonvertering. Men i C# 4.0, hvis du legger til /link-alternativet ved kompilering, får den dynamiske typen en ny effekt: den gjør objekttypen (parametertype eller returtype) i COM-grensesnittets metodesignatur ansett som dynamisk, og unngår dermed mye typekonvertering. For eksempel kontrasterer følgende utsagn dette.
Den brukes ikke dynamisk.
((Excel.Område) Excel. Celler[1, 1]). Value2 = "Navn";
Excel.Rekkevidde = (Excel.Rekkevidde)excel. Celler[1, 1];
Det var en dynamisk en.
Excel. Celler[1, 1]. Verdi = "Navn";
Excel. Range range = excel. Celler[1, 1]; |
Publisert på 07.07.2016 10:23:00
|
|
|
