A C# 4.0 új típust vezet be: dinamikus, amely statikus típus, de egy ilyen típusú objektumpéldány képes megkerülni a statikus típusellenőrzési folyamatot. A legtöbb esetben a típus úgy működik, mint egy objektumosztály. Fordítás idején egy dinamikus osztály példánya bármilyen műveletet támogat, így nem kell aggódni amiatt, hogy az objektum egy COM API-ból, egy dinamikus nyelvből, például az IronPythonból, a HTML DOM-ból, a reflektorációból vagy a program más helyéről származik-e. Azonban, ha a kód valami érvénytelen hibát csinál, a hibát futásidőben elkapják.
Például a következő kódrészletben található exampleMethod1 példás metódus csak egy paraméterrel rendelkezik, és a fordító felismerheti, hogy ez érvénytelen, amikor ec.exampleMethod1(10,4) hívja a fordításkor; Ez egy fordítási hiba. A második hívás dynamic_ec.exampleMethod1(10,4) nem ellenőrzik statikus típusok esetén. Ezért a fordító nem jelent fordítási hibákat. Azonban a bogár nem rejtőzik örökké; Futásidőben fogják elkapni, és futtatóidő kivételt indít el.
static void Main(string[] args){
ExampleClass ec = új ExampleClass();
dinamikus dynamic_ec = új ExampleClass();
dynamic_ec.exampleMethod1(10, 4);
dynamic_ec.someMethod("egy érv", 7, null);
dynamic_ec.nonexistentMethod();
}
class ExampleClass {
public ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void exampleMethod2(string str) { }
}
Íme egy példa arra, hogyan használjuk a dinamikát az IronPython meghívására:
IronPython.Hosting használatával;
using Microsoft.scrip{filtering}ting. Házigazda;
Console.WriteLine("Betöltés random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
dinamikus véletlenszerű = py. UseFile("random.py");
Console.WriteLine("random.py betöltve!");
var items = Enumerable.Range(1, 7). ToArray();
esetén (int s = 0; s < 10000; s++) {
random.shuffle(tárgyak);
Console.Write("Sequence {0}: ", s);
foreach (int i az elemekben) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
Dinamikus típusú objektumok vagy kifejezések esetén a fordító feladata, hogy lekapsulozza az egyes kifejezések által elvárt műveleteket, és a végrehajtáskor ellenőrizze a tárolt információkat, és az esetleges érvénytelen utasítások futtatási kivételt indítanak el.
A legtöbb dinamikus művelet eredménye is dinamikus. Például, ha az alábbi példában az egérmutatót a testSum fölé viszed, az okos prompt egy (helyi változó) dinamikus testSum-t fog megjeleníteni.
dinamikus d = 1;
var testSum = d + 3;
Vidd az egérmutatót a testSum fölé lent.
System.Console.WriteLine(testSum);
Típusátalakítás
A dinamikus típusú példányok és más példánytípusok közötti váltás egyszerű, és a fejlesztők könnyedén válthatnak a dynmic és nem dinamikus viselkedések között. Bármely példány implicit módon átalakítható dinamikus típusú példányokká, lásd az alábbi példát:
dinamikus d1 = 7;
dinamikus d2 = "egy string";
dinamikus d3 = System.DateTime.Today;
dinamikus d4 = System.Diagnostics.Process.GetProcesses();
Ezzel szemben az implicit átalakítás dinamikusan alkalmazható bármely típusdinamikus kifejezésre.
Fordítva, bármely típusdinamikus kifejezés implicit módon más típusokra is átalakítható.
int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Túlterhelés problémája a dinamikus típusparaméterekkel a módszerben
Ha egy metódus egy dinamikus típusú objektumot passzol, vagy a hívott objektum dinamikus, akkor a túlterhelés megítélése futásidőben történik, nem fordításkor.
Dinamikus nyelvi futási idejű DLR
A dinamikus nyelvi futás ideje . A NET Framework 4 Beta 1 egy új API-készlet, amely támogatja a dinamikus típusokat C#-ban, és dinamikus programozási nyelveket is valósít meg, mint az IronPython és az IronRuby.
COM interoperabilitás
A C# 4.0 több olyan funkciót tartalmaz, amelyek javítják az interoperabilitást a hagyományos COM API interfészekkel, például az Office automatizálással. A dinamikus típusok, elnevezett paraméterek és opcionális paraméterek is részei a fejlesztésnek.
Sok COM metódus lehetővé teszi, hogy paraméterei és visszaküldési értékei típusobjektumhoz tartozzanak, így erősen típusozott nyelvek, például C# esetén sok kényszer típusátalakítás szükséges. Azonban a C# 4.0-ban, ha a fordításkor hozzáadod a /link opciót, a dinamikus típus új hatást kap: dinamikussá teszi a COM interfész módszer aláírásában lévő objektumtípust (paramétertípus vagy visszaküldési típus) dinamikusnak, így elkerülve a sok típusváltást. Például a következő állítás ezzel szembenéz.
Nem használják dinamikusan.
((Excel.Range)excel. Cellák[1, 1]). Value2 = "Név";
Excel.Range range = (Excel.Range)excel. Cellák[1, 1];
Ez egy dinamikus volt.
Excel. Cellák[1, 1]. érték = "név";
Excel.Range range = excel. Cellák[1, 1]; |
Közzétéve 2016. 07. 07. 10:23:00
|
|
|
