C# 4.0 introduceert een nieuw type: dynamisch, wat een statisch type is, maar een objectinstantie van dit type kan het statische typecontroleproces omzeilen. In de meeste gevallen werkt het type als een objectklasse. Tijdens compilatie ondersteunt een instantie van een dynamische klasse elke bewerking, dus er is geen reden om je zorgen te maken of het object afkomstig is van een COM-API, of een dynamische taal zoals IronPython, van de HTML DOM, of van reflectie, of ergens anders in het programma. Als de code echter iets ongeldig doet, wordt de fout tijdens runtime gevangen.
Bijvoorbeeld, de voorbeeldmethode exampleMethod1 in het volgende codefragment heeft slechts één parameter, en de compiler kan identificeren dat deze ongeldig is bij het aanroepen van ec.exampleMethod1(10,4) tijdens compileer; Dit is een compilatiefout. De tweede aanroep dynamic_ec.exampleMethod1(10,4) wordt niet gecontroleerd voor statische types. Daarom rapporteert de compiler geen compilatiefouten. De bug blijft echter niet voor altijd verstopt; Het wordt tijdens runtime gevangen en triggert een runtime-uitzondering.
statische void Main(string[] args){
ExampleClass ec = nieuwe ExampleClass();
dynamic dynamic_ec = nieuwe ExampleClass();
dynamic_ec.voorbeeldMethod1(10, 4);
dynamic_ec.someMethod("some argument", 7, null);
dynamic_ec.nonexistentMethod();
}
klasse VoorbeeldKlasse {
publieke ExampleClass() { }
publieke ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void voorbeeldMethod2(string str) { }
}
Hier is een voorbeeld van het gebruik van dynamisch om IronPython aan te roepen:
gebruik van IronPython.Hosting;
met behulp van Microsoft.scrip{filtering}ting. Hosten;
Console.WriteLine("Laden random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
dynamisch willekeurig = py. UseFile("random.py");
Console.WriteLine ("random.py geladen!");
var-items = Enumerable.Range(1, 7). ToArray();
voor (int s = 0; s < 10.000; s++) {
random.shuffle(items);
Console.Write("Sequence {0}: ", s);
foreach (int i in items) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
Voor objecten of expressies van type-dynamisch is de rol van de compiler om de acties die elke expressie moet uitvoeren te encapsuleren, en bij uitvoering de opgeslagen informatie te controleren, waarbij ongeldige statements een runtime-uitzondering zullen activeren.
Het type resultaat van de meeste dynamische bewerkingen is ook dynamisch. Als je bijvoorbeeld met je muisaanwijzer over de testSum in het volgende voorbeeld beweegt, zal de slimme prompt een (lokale variabele) dynamische testSum tonen.
dynamisch d = 1;
var testSum = d + 3;
Beweeg de muisaanwijzer boven de testSum hieronder.
System.Console.WriteLine(testSum);
Typeconversie
Het overschakelen tussen dynamische instanties en andere typen instanties is eenvoudig, en ontwikkelaars kunnen gemakkelijk schakelen tussen dynamisch en niet-dynamisch gedrag. Elke instantie kan impliciet worden omgezet in een dynamisch type instantie, zie het volgende voorbeeld:
dynamisch d1 = 7;
dynamisch d2 = "een snaar";
dynamisch d3 = System.DateTime.Today;
dynamisch d4 = System.Diagnostics.Process.GetProcesses();
Omgekeerd kan een impliciete conversie dynamisch worden toegepast op elke uitdrukking van type dynamisch.
En omgekeerd kan elke uitdrukking van type dynamisch ook impliciet worden omgezet naar andere types.
int i = d1;
snaar str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Overbelastingsprobleem met dynamische typeparameters in de methode
Als een methode wordt aangeroepen een object van type dynamisch laat passeren, of het object dat wordt aangeroepen van type dynamisch is, vindt de beoordeling van overbelasting plaats tijdens runtime en niet tijdens compilatie.
Dynamische taalruntime DLR
De dynamische taalruntime is . NET Framework 4 Beta 1 is een nieuwe set API's die ondersteuning bieden voor dynamische types in C# en ook dynamische programmeertalen zoals IronPython en IronRuby implementeren.
COM-interoperabiliteit
C# 4.0 bevat verschillende functies die de interoperabiliteit verbeteren met traditionele COM API-interfaces zoals Office-automatisering. Dynamische types, benoemde parameters en optionele parameters maken ook deel uit van de verbetering.
Veel COM-methoden laten hun parameters en retourwaarden van type object zijn, dus voor sterk getypeerde talen zoals C# is veel geforceerde typeconversie vereist. In C# 4.0 echter, als je de /link-optie toevoegt tijdens compileren, heeft het dynamische type een nieuw effect: het maakt het objecttype (parametertype of retourtype) in de COM-interface-methodehandtekening dynamisch, waardoor veel typeconversie wordt vermeden. Bijvoorbeeld, de volgende uitspraak contrasteert dit.
Het wordt niet dynamisch gebruikt.
((Excel.Bereik)excel. Cellen[1, 1]). Value2 = "Naam";
Excel.Bereik = (Excel.Bereik)excel. Cellen[1, 1];
Het was een dynamisch avontuur.
Excel. Cellen[1, 1]. Waarde = "Naam";
Excel. Bereikbereik = excel. Cellen[1, 1]; |
Geplaatst op 07-07-2016 10:23:00
|
|
|
