Verwenden des Typs dynamic (C#-Programmierhandbuch)

Visual C# 2010 stellt den neuen Typ dynamic bereit. Es handelt sich zwar um einen statischen Typ, aber ein Objekt des Typs dynamic umgeht die Überprüfung statischer Typen. Die Funktionsweise stimmt in den meisten Fällen mit der des Typs object überein. Zur Kompilierzeit wird davon ausgegangen, dass ein Element vom Typ dynamic jeden beliebigen Vorgang unterstützt. Aus diesem Grund müssen Sie sich keine Gedanken darüber machen, ob der Wert des Objekts von einer COM-API, von einer dynamischen Sprache wie IronPython, vom HTML-Dokumentobjektmodell (DOM), durch Reflektion oder von einem anderen Element im Programm abgerufen wird. Wenn der Code jedoch nicht gültig ist, werden zur Laufzeit Fehler abgefangen.

Beispiel: Wenn die Instanzmethode exampleMethod1 im folgenden Code nur einen Parameter aufweist, erkennt der Compiler den ersten Aufruf der Methode, ec.exampleMethod1(10, 4), als nicht gültig, weil darin zwei Argumente enthalten sind. Der Aufruf löst einen Compilerfehler aus. Der zweite Aufruf der Methode, dynamic_ec.exampleMethod1(10, 4), wird nicht vom Compiler überprüft, da der Typ von dynamic_ec dynamic ist. Somit wird kein Compilerfehler gemeldet. Der Fehler wird jedoch nicht unendlich verborgen. Er wird zur Laufzeit abgefangen und löst eine Laufzeitausnahme aus.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following line causes a compiler error if exampleMethod1 has only
    // one parameter.
    //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) { }
}

Die Rolle des Compilers in diesen Beispielen besteht darin, Informationen zu den Vorgängen zusammenzufassen, die die einzelnen Anweisungen für das Objekt oder den Ausdruck vom Typ dynamic vorsehen. Zur Laufzeit werden die gespeicherten Informationen geprüft, und nicht gültige Anweisungen lösen eine Laufzeitausnahme aus.

Das Ergebnis der meisten dynamischen Vorgänge ist ebenfalls dynamic. Wenn Sie z. B. im folgenden Beispiel mit der Maus auf die Verwendung von testSum zeigen, zeigt IntelliSense den Typ (lokale Variable) dynamic testSum an.

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

Zu den Vorgängen, bei denen das Ergebnis nicht dynamic ist, zählen Konvertierungen von dynamic in einen anderen Typ sowie Konstruktoraufrufe, die Argumente vom Typ dynamic einschließen. Beispiel: Der Typ von testInstance in der folgenden Deklaration ist ExampleClass, nicht dynamic.

var testInstance = new ExampleClass(d);

Konvertierungsbeispiele werden im folgenden Abschnitt "Konvertierungen" gezeigt.

Konvertierungen

Konvertierungen zwischen dynamischen Objekten und anderen Typen sind einfach. So können Entwickler zwischen dynamischem und nicht dynamischem Verhalten wechseln.

Jedes beliebige Objekt kann implizit in den dynamic-Typ konvertiert werden, wie in den folgenden Beispielen gezeigt.

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

Ebenso kann eine implizite Konvertierung dynamisch auf jeden beliebigen Ausdruck vom Typ dynamic angewendet werden.

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

Überladungsauflösung mit Argumenten vom Typ dynamic

Die Überladungsauflösung tritt zur Laufzeit statt zur Kompilierzeit auf, wenn mindestens eines der Argumente in einem Methodenaufruf den Typ dynamic aufweist, oder wenn der Empfänger des Methodenaufrufs den Typ dynamic aufweist. Wenn im folgenden Beispiel die einzige zugreifbare exampleMethod2-Methode so definiert wird, dass sie ein Zeichenfolgenargument erfordert, löst das Senden von d1 als Argument keinen Compilerfehler, aber eine Laufzeitausnahme aus. Die Überladungsauflösung schlägt zur Laufzeit fehl, da d1 den Laufzeittyp int aufweist und exampleMethod2 eine Zeichenfolge erfordert.

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

Dynamic Language Runtime

Die Dynamic Language Runtime (DLR) ist eine neue API in .NET Framework 4. Diese stellt die Infrastruktur bereit, die den dynamic-Typ in C# sowie die Implementierung von dynamischen Programmiersprachen wie IronPython und IronRuby unterstützt. Weitere Informationen zur DLR finden Sie unter Übersicht über die Dynamic Language Runtime.

COM-Interop

Visual C# 2010 bietet mehrere Funktionen zur Verbesserung der Interoperation mit COM-APIs, wie beispielsweise Office-Automatisierungs-APIs. Dazu zählen der dynamic-Typ sowie benannte und optionale Argumente.

Viele COM-Methoden ermöglichen die Variation von Argumenttypen und Rückgabetyp durch Festlegen der Typen als object. Dies erforderte zur Koordination mit stark typisierten Variablen in C# die explizite Umwandlung der Werte. Wenn Sie mit der /link (C#-Compileroptionen)-Option kompilieren, ermöglicht Ihnen der neue dynamic-Typ, die object-Vorkommen in COM-Signaturen wie Elemente vom Typ dynamic zu behandeln, sodass ein Großteil der Umwandlung nicht mehr erforderlich ist. Anhand der folgenden Beispielanweisungen können Sie den Zugriff auf eine Zelle in einem Microsoft Office Excel-Arbeitsblatt mit dem dynamic-Typ und ohne den dynamic-Typ vergleichen.

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

Verwandte Themen