Použití dynamického typu

Typ dynamic je statický typ, ale objekt typu dynamic obchází kontrolu statického typu. Ve většině případů funguje stejně jako typ object. Kompilátor předpokládá, že dynamic element podporuje jakoukoli operaci. Proto nemusíte určit, jestli objekt získá jeho hodnotu z rozhraní COM API, z dynamického jazyka, jako je IronPython, z modelu DOM (Document Object Model) HTML, z reflexe nebo někam jinam v programu. Pokud ale kód není platný, zobrazí se chyby za běhu.

Pokud má například metoda exampleMethod1 instance v následujícím kódu pouze jeden parametr, kompilátor rozpozná, že první volání metody , není platné, ec.exampleMethod1(10, 4)protože obsahuje dva argumenty. Volání způsobí chybu kompilátoru. Kompilátor nekontroluje druhé volání metody, dynamic_ec.exampleMethod1(10, 4)protože typ dynamic_ec je dynamic. Proto není hlášena žádná chyba kompilátoru. Tato chyba ale neunikne do nekonečna. Zobrazí se v době běhu a způsobí výjimku za běhu.

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) { }
}

Rolí kompilátoru v těchto příkladech je zabalit informace o tom, co jednotlivé příkazy navrhují k provedení objektu nebo výrazu dynamic . Modul runtime prozkoumá uložené informace a všechny příkazy, které nejsou platné, způsobí výjimku za běhu.

Výsledek většiny dynamických operací je sám dynamic. Pokud například umístíte ukazatel myši na použití testSum v následujícím příkladu, IntelliSense zobrazí typ (místní proměnná) dynamické testSum.

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

Operace, ve kterých výsledek není dynamic :

• Převody z dynamic jiného typu.
• Konstruktor volá, které obsahují argumenty typu dynamic.

Například typ testInstance v následující deklaraci je ExampleClass, nikoli dynamic:

var testInstance = new ExampleClass(d);

Převody

Převody mezi dynamickými objekty a jinými typy jsou jednoduché. Převody umožňují vývojáři přepínat mezi dynamickým a ne dynamicovým chováním.

Libovolnou možnost můžete převést na dynamic implicitně, jak je znázorněno v následujících příkladech.

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

Naopak můžete dynamicky použít jakýkoli implicitní převod na libovolný výraz typu dynamic.

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

Rozlišení přetížení s argumenty typu dynamic

K rozlišení přetížení dochází v době běhu místo v době kompilace, pokud jeden nebo více argumentů volání metody mají typ dynamic, nebo pokud příjemce volání metody je typu dynamic. V následujícím příkladu, pokud jediná přístupná exampleMethod2 metoda přebírá řetězcový argument, odeslání d1 jako argument nezpůsobuje chybu kompilátoru, ale způsobuje výjimku za běhu. Řešení přetížení selže v době běhu, protože typ d1 běhu je inta exampleMethod2 vyžaduje řetězec.

// 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);

Modul runtime dynamického jazyka

Modul runtime dynamického jazyka (DLR) poskytuje infrastrukturu dynamic , která podporuje typ v jazyce C#, a také implementaci dynamických programovacích jazyků, jako je IronPython a IronRuby. Další informace o DLR naleznete v tématu Přehled modulu runtime dynamického jazyka.

zprostředkovatel komunikace s objekty COM

Mnoho metod MODELU COM umožňuje variantu v typech argumentů a návratový typ tak, že typy označí jako object. Spolupráce modelu COM vyžaduje explicitní přetypování hodnot, aby bylo možné koordinovat s proměnnými silného typu v jazyce C#. Pokud zkompilujete pomocí možnosti EmbedInteropTypes (Možnosti kompilátoru jazyka C#), umožňuje zavedení dynamic typu zacházet s výskyty object v podpisech modelu COM, jako by byly typu dynamic, a tím se vyhnout velké části přetypování. Další informace o použití dynamic typu s objekty COM najdete v článku o tom, jak získat přístup k objektům interoperability Office pomocí funkcí jazyka C#.

Související články