Použití typu Dynamic (Průvodce programováním v C#)

C# 4 zavádí nový typ, dynamic . Typ je statický typ, ale objekt typu dynamic obchází kontrolu statického typu. Ve většině případů funguje jako typ object . V době kompilace se předpokládá, že element, který je zadán jako, dynamic má podporovat jakoukoli operaci. Proto nemusíte mít obavy o tom, zda objekt získá svou hodnotu z rozhraní API modelu COM, z dynamického jazyka, jako je například Ironpythonu, z HTML model DOM (Document Object Model) (DOM), z reflexe nebo z jiného důvodu v programu. Pokud však kód není platný, jsou chyby zachyceny za běhu.

Například pokud metoda instance exampleMethod1 v následujícím kódu má pouze jeden parametr, kompilátor rozpozná, že první volání metody, ec.exampleMethod1(10, 4) , není platné, protože obsahuje dva argumenty. Volání způsobí chybu kompilátoru. Druhé volání metody, dynamic_ec.exampleMethod1(10, 4) , není zkontrolováno kompilátorem, protože typ dynamic_ec je dynamic . Proto není hlášena žádná chyba kompilátoru. Tato chyba ale neumožňuje bez omezení řídicího oznámení. Je zachycena v době běhu a způsobuje 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) { }
}

Role kompilátoru v těchto příkladech je zabalit informace o tom, co jednotlivé příkazy navrhují k objektu nebo výrazu, který je zadán jako dynamic . V době spuštění jsou zkontrolovány uložené informace a jakýkoli příkaz, který není platný, způsobuje výjimku za běhu.

Výsledek většiny dynamických operací je sám sebou dynamic . Například pokud umístíte ukazatel myši na použití testSum v následujícím příkladu, technologie IntelliSense zobrazí typ (místní proměnná) dynamického 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 dynamic nezahrnuje:

• Převody z dynamic na jiný typ.
• Volání konstruktoru, která obsahují argumenty typu dynamic .

Například typ testInstance v následující deklaraci není ExampleClass dynamic :

var testInstance = new ExampleClass(d);

Příklady převodu jsou uvedeny v následující části "převody".

Převody

Převody mezi dynamickými objekty a dalšími typy jsou jednoduché. To umožňuje vývojáři přepínat mezi dynamickým a nedynamickým chováním.

Libovolný objekt lze převést na dynamický typ 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 implicitní převod lze dynamicky použít na jakýkoli výraz typu dynamic .

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

Rozlišení přetěžování s argumenty typu Dynamic

K rozlišení přetěžování dochází za běhu místo v době kompilace, pokud jeden nebo více argumentů ve volání metody má typ dynamic , nebo pokud je příjemce volání metody typu dynamic . V následujícím příkladu, pokud je jediná dostupná exampleMethod2 metoda definována pro převzetí řetězcového argumentu, odeslání d1 jako argumentu nezpůsobí chybu kompilátoru, ale vyvolá výjimku za běhu. Rozlišení přetěžování se v době běhu nezdařilo, protože typ modulu runtime d1 je int a 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 jazyka Dynamic

modul dynamického jazyka (DLR) je rozhraní API, které bylo zavedeno ve .NET Framework 4. Poskytuje infrastrukturu, která podporuje dynamic typ v jazyce C#, a také implementaci dynamických programovacích jazyků, jako je ironpythonu a IronRuby. Další informace o DLR najdete v tématu Přehled dynamického jazykového modulu runtime.

zprostředkovatel komunikace s objekty COM

C# 4 obsahuje několik funkcí, které zlepšují možnosti spolupráce s rozhraními api modelu COM, jako jsou Office rozhraní api pro automatizaci. Mezi vylepšení jsou použití dynamic typu a pojmenovaných a nepovinných argumentů.

Mnoho metod modelu COM umožňuje variace typů argumentů a návratového typu určením typů jako object . To vyžaduje explicitní přetypování hodnot pro koordinaci s proměnnými silného typu v jazyce C#. Pokud kompilujete pomocí možnosti EmbedInteropTypes (možnosti kompilátoru C#) , zavedení dynamic typu vám umožní nakládat s VÝSKYTY object v rámci signatur modelu COM, jako kdyby byly typu dynamic , a tak zabránit nadměrnému přetypování. například následující příkazy kontrastují přístup k buňce v Microsoft Office Excel tabulce s dynamic typem a bez dynamic typu.

// Before the introduction of dynamic.
((Excel.Range)excelApp.Cells[1, 1]).Value2 = "Name";
Excel.Range range2008 = (Excel.Range)excelApp.Cells[1, 1];

// After the introduction of dynamic, the access to the Value property and
// the conversion to Excel.Range are handled by the run-time COM binder.
excelApp.Cells[1, 1].Value = "Name";
Excel.Range range2010 = excelApp.Cells[1, 1];

Související témata