Dinamikus típus használata

A dynamic típus statikus típus, de egy típusobjektum dynamic megkerüli a statikus típusellenőrzést. A legtöbb esetben úgy működik, mint a típus object. A fordító feltételezi, hogy egy dynamic elem bármilyen műveletet támogat. Ezért nem kell meghatároznia, hogy az objektum egy COM API-ból, egy dinamikus nyelvből, például az IronPythonból, a HTML-dokumentumobjektum-modellből (DOM) kapja-e meg az értékét a tükröződésből vagy a program más helyéről. Ha azonban a kód nem érvényes, a hibák futásidőben jelentkezhetnek.

Ha például a következő kód példánymetódusa exampleMethod1 csak egy paramétert tartalmaz, a fordító felismeri, hogy a metódus első hívása érvénytelen, ec.exampleMethod1(10, 4)mert két argumentumot tartalmaz. A hívás fordítóhibát okoz. A fordító nem ellenőrzi a metódus második hívásátdynamic_ec, dynamic_ec.exampleMethod1(10, 4)mert a típus az dynamic. Ezért a jelentés nem jelent fordítóhibát. A hiba azonban nem tűnik el határozatlan ideig. Futásidőben jelenik meg, és futásidejű kivételt okoz.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following call to exampleMethod1 causes a compiler error
    // if exampleMethod1 has only one parameter. Uncomment the line
    // to see the error.
    //ec.exampleMethod1(10, 4);

    dynamic dynamic_ec = new ExampleClass();
    // The following line is not identified as an error by the
    // compiler, but it causes a run-time exception.
    dynamic_ec.exampleMethod1(10, 4);

    // The following calls also do not cause compiler errors, whether
    // appropriate methods exist or not.
    dynamic_ec.someMethod("some argument", 7, null);
    dynamic_ec.nonexistentMethod();
}

class ExampleClass
{
    public ExampleClass() { }
    public ExampleClass(int v) { }

    public void exampleMethod1(int i) { }

    public void exampleMethod2(string str) { }
}

A fordító szerepe ezekben a példákban az, hogy összecsomagolják az egyes állítások objektumokkal dynamic vagy kifejezésekkel kapcsolatos teendőit. A futtatókörnyezet megvizsgálja a tárolt adatokat, és minden érvénytelen utasítás futásidejű kivételt okoz.

A legtöbb dinamikus művelet eredménye maga dynamic. Ha például az egérmutatót a következő példában használja testSum , az IntelliSense megjeleníti a típust (helyi változó) dinamikus testSum.

dynamic d = 1;
var testSum = d + 3;
// Rest the mouse pointer over testSum in the following statement.
System.Console.WriteLine(testSum);

Olyan műveletek, amelyekben az eredmény nem dynamic szerepel:

• Konvertálás másik típusra dynamic .
• Konstruktorhívások, amelyek típus dynamicargumentumokat tartalmaznak.

Például a következő deklaráció típusa testInstance nemdynamic:ExampleClass

var testInstance = new ExampleClass(d);

Konverziók

A dinamikus objektumok és más típusok közötti átalakítások egyszerűek. A konverziók lehetővé teszik a fejlesztő számára a dinamikus és a nem dinamikus viselkedés közötti váltást.

Bármelyiket dynamic implicit módon konvertálhatja, ahogy az alábbi példákban is látható.

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

Ezzel szemben bármilyen implicit átalakítást dinamikusan alkalmazhat bármilyen típusú dynamickifejezésre.

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

Túlterhelés feloldása dinamikus típusú argumentumokkal

A túlterhelés feloldása futásidőben történik a fordítási idő helyett, ha egy metódushívás egy vagy több argumentuma típussal dynamicrendelkezik, vagy ha a metódushívás fogadója típusú dynamic. Az alábbi példában, ha az egyetlen elérhető exampleMethod2 metódus sztring argumentumot használ, az argumentumként való küldés d1 nem okoz fordítási hibát, de futásidejű kivételt okoz. A túlterhelés feloldása futásidőben meghiúsul, mert a futási idő típusa d1int, és exampleMethod2 sztringet igényel.

// Valid.
ec.exampleMethod2("a string");

// The following statement does not cause a compiler error, even though ec is not
// dynamic. A run-time exception is raised because the run-time type of d1 is int.
ec.exampleMethod2(d1);
// The following statement does cause a compiler error.
//ec.exampleMethod2(7);

Dinamikus nyelvi futtatókörnyezet

A dinamikus nyelvi futtatókörnyezet (DLR) biztosítja a C#-típust támogató dynamic infrastruktúrát, valamint olyan dinamikus programozási nyelvek implementálását, mint az IronPython és az IronRuby. A DLR-ről további információt a Dinamikus nyelvi futtatókörnyezet áttekintése című témakörben talál.

COM interop

Számos COM-metódus lehetővé teszi az argumentumtípusok eltérését és a típus visszaadását a típusok mintaként objectvaló kijelölésével. A COM-interop megköveteli az értékek explicit öntését, hogy a C#-ban erősen begépelt változókkal összehangolható legyen. Ha az EmbedInteropTypes (C# Compiler Options) beállítással fordít, a típus bevezetésével dynamic úgy kezelheti a COM-aláírások előfordulásait object , mintha azok típus dynamiclennének, és így elkerülheti az öntés nagy részét. A típus COM-objektumokkal való használatáról dynamic további információt az Office-objektumok C#-funkciókkal való eléréséről szóló cikkben talál.

Kapcsolódó cikkek

Cím	Leírás
dinamikus	A kulcsszó használatát dynamic ismerteti.
Dinamikus nyelvi futtatókörnyezet áttekintése	Áttekintést nyújt a DLR-ről, amely egy futtatókörnyezet, amely dinamikus nyelvek szolgáltatáskészletét adja hozzá a közös nyelvi futtatókörnyezethez (CLR).
Útmutató: Dinamikus objektumok létrehozása és használata	Részletes útmutatást nyújt egy egyéni dinamikus objektum létrehozásához és egy tárhoz hozzáférő IronPython projekt létrehozásához.