C# 4.0 introducerar en ny typ: dynamisk, vilket är en statisk typ, men en objektinstans av denna typ kan kringgå den statiska typkontrollprocessen. I de flesta fall fungerar typen som en objektklass. Vid kompilering stödjer en instans av en dynamisk klass vilken operation som helst, så det finns ingen anledning att oroa sig för om objektet tas från ett COM-API, eller ett dynamiskt språk som IronPython, från HTML-DOM:en, från reflektion eller någon annanstans i programmet. Men om koden gör något ogiltigt, fångas felet vid körning.
Till exempel har exempelmetoden exampleMethod1 i följande kodutdrag endast en parameter, och kompilatorn kan identifiera att den är ogiltig när den anropar ec.exampleMethod1(10,4) vid kompilering; Detta är ett kompileringsfel. Det andra anropet dynamic_ec.exampleMethod1(10,4) kontrolleras inte för statiska typer. Därför rapporterar kompilatorn inga kompileringsfel. Men insekten gömmer sig inte för evigt; Den fångas vid körning och utlöser ett körtidsundantag.
statiskt tomrum Main(string[] args){
ExampleClass ec = ny ExampleClass();
dynamisk dynamic_ec = ny ExampleClass();
dynamic_ec.exampleMethod1(10, 4);
dynamic_ec.someMethod("some argument", 7, null);
dynamic_ec.nonexistentMethod();
}
klass ExampleClass {
public ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void exampleMethod2(sträng str) { }
}
Här är ett exempel på att använda dynamisk för att anropa IronPython:
använda IronPython.Hosting;
med Microsoft.scrip{filtering}ting. Värdskap;
Console.WriteLine ("Laddar random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
dynamisk slumpmässig = py. UseFile("random.py");
Console.WriteLine("random.py laddad!");
var-items = Enumerable.Range(1, 7). ToArray();
för (int s = 0; s < 10 000; s++) {
random.shuffle(items);
Console.Write("Sequence {0}: ", s);
foreach (int i i items) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
För objekt eller uttryck av typdynamisk typ är kompilatorns roll att kapsla in de åtgärder som varje uttryck förväntas utföra, och vid exekveringen kontrollera den lagrade informationen, och eventuella ogiltiga satser kommer att utlösa ett körtidsundantag.
Typen av resultat för de flesta dynamiska operationer är också dynamisk. Till exempel, om du håller muspekaren över testSum i följande exempel, kommer smartprompten att visa en (lokal variabel) dynamisk testSum.
dynamisk d = 1;
var testSum = d + 3;
Håll muspekaren över testSum nedan.
System.Console.WriteLine(testSum);
Typkonvertering
Att växla mellan dynamiska instanser och andra typer av instanser är enkelt, och utvecklare kan enkelt växla mellan dynamiska och icke-dynamiska beteenden. Varje instans kan implicit konverteras till en dynamisk typinstans, se följande exempel:
dynamisk d1 = 7;
dynamisk d2 = "en sträng";
dynamisk d3 = System.DateTime.Today;
dynamisk d4 = System.Diagnostik.Process.GetProcesses();
Omvänt kan en implicit konvertering dynamiskt tillämpas på vilket uttryck av typ dynamiskt som helst.
Och vice versa kan varje uttryck av typ dynamisk också implicit konverteras till andra typer.
int i = d1;
sträng str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Överbelastningsproblem med dynamiska typparametrar i metoden
Om en metod anropas passerar ett objekt av typen dynamisk, eller om objektet som anropas är av typen dynamiskt, sker bedömningen av överbelastning vid körning och inte vid kompileringstid.
Dynamiskt språk runtime DLR
Den dynamiska språkkörningen är . NET Framework 4 Beta 1 är en ny uppsättning API:er som erbjuder stöd för dynamiska typer i C# och även implementerar dynamiska programmeringsspråk som IronPython och IronRuby.
COM-interoperabilitet
C# 4.0 innehåller flera funktioner som förbättrar interoperabiliteten med traditionella COM API-gränssnitt såsom Office-automation. Dynamiska typer, namngivna parametrar och valfria parametrar är också en del av förbättringen.
Många COM-metoder tillåter att deras parametrar och returvärden är av typobjekt, så för starkt typade språk som C# krävs mycket tvingad typkonvertering. Men i C# 4.0, om du lägger till /link-alternativet vid kompilering, får den dynamiska typen en ny effekt: den gör objekttypen (parametertyp eller returtyp) i COM-gränssnittets metodsignatur dynamisk, vilket undviker mycket typkonvertering. Till exempel kontrasterar följande påstående detta.
Det används inte dynamiskt.
((Excel.Range)excel. Celler[1, 1]). Value2 = "Namn";
Excel.Intervall = (Excel.Intervall)excel. Celler[1, 1];
Det var en dynamisk sådan.
Excel. Celler[1, 1]. Värde = "Namn";
Excel. Intervall = excel. Celler[1, 1]; |
Publicerad på 2016-07-07 10:23:00
|
|
|
