Verwenden des Typs dynamic (C#-Programmierhandbuch)Using Type dynamic (C# Programming Guide)

C# 4 führt einen neuen Typ ein, dynamic. introduces a new type, dynamic. Bei diesem Typ handelt es sich um einen statischen Typ. Ein Objekt des Typs dynamic umgeht aber die Überprüfung statischer Typen.The type is a static type, but an object of type dynamic bypasses static type checking. In den meisten Fällen entspricht es der Funktionsweise des Typs object.In most cases, it functions like it has type object. Bei einem Element, das zur Kompilierzeit als dynamic typisiert wird, wird davon ausgegangen, dass es alle Vorgänge unterstützt.At compile time, an element that is typed as dynamic is assumed to support any operation. Daher müssen Sie sich keine Gedanken darüber machen, ob das Objekt seinen Wert von einer COM-API, einer dynamischen Sprache wie IronPython, vom HTML-DOM (Document Object Model), aus der Reflektion oder von einer anderen Quelle im Programm erhält.Therefore, you do not have to be concerned about whether the object gets its value from a COM API, from a dynamic language such as IronPython, from the HTML Document Object Model (DOM), from reflection, or from somewhere else in the program. Wenn der Code jedoch nicht gültig ist, werden Fehler zur Laufzeit abgefangen.However, if the code is not valid, errors are caught at run time.

Wenn z.B. die Instanzmethode exampleMethod1 im folgenden Code nur einen Parameter hat, erkennt der Compiler, dass der erste Aufruf der Methode, ec.exampleMethod1(10, 4), nicht gültig ist, da er zwei Argumente enthält.For example, if instance method exampleMethod1 in the following code has only one parameter, the compiler recognizes that the first call to the method, ec.exampleMethod1(10, 4), is not valid because it contains two arguments. Dieser Aufruf löst einen Compilerfehler aus.The call causes a compiler error. Der zweite Aufruf der Methode, dynamic_ec.exampleMethod1(10, 4), wird vom Compiler nicht überprüft, da der Typ von dynamic_ec dynamic ist.The second call to the method, dynamic_ec.exampleMethod1(10, 4), is not checked by the compiler because the type of dynamic_ec is dynamic. Daher wird kein Compilerfehler gemeldet.Therefore, no compiler error is reported. Allerdings bleibt der Fehler nicht unbegrenzt unbemerkt.However, the error does not escape notice indefinitely. Er wird zur Laufzeit abgefangen und führt zu einer Laufzeitausnahme.It is caught at run time and causes a run-time exception.

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

In diesen Beispielen ist es die Rolle des Compilers, Informationen darüber zusammenzustellen, was jede Anweisung für die Behandlung des Objekts oder des Ausdrucks vorschlägt, die als dynamic typisiert sind.The role of the compiler in these examples is to package together information about what each statement is proposing to do to the object or expression that is typed as dynamic. Die gespeicherten Informationen werden zur Laufzeit überprüft, und jede ungültige Anweisung verursacht eine Laufzeitausnahme.At run time, the stored information is examined, and any statement that is not valid causes a run-time exception.

Das Ergebnis der meisten dynamischen Vorgänge ist wiederum dynamic.The result of most dynamic operations is itself dynamic. Wenn Sie z.B. den Mauszeiger im folgenden Beispiel auf die Verwendung von testSum halten, zeigt IntelliSense den Typ (local variable) dynamic testSum an.For example, if you rest the mouse pointer over the use of testSum in the following example, IntelliSense displays the type (local variable) dynamic testSum.

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

Vorgänge, in denen das Ergebnis nicht dynamic ist, enthalten Konvertierungen von dynamic in einen anderen Typ, und Konstruktoraufrufe, die Argumente vom Typ dynamic enthalten.Operations in which the result is not dynamic include conversions from dynamic to another type, and constructor calls that include arguments of type dynamic. In der folgende Deklaration ist der Typ von testInstance z.B. ExampleClass, nicht dynamic.For example, the type of testInstance in the following declaration is ExampleClass, not dynamic.

var testInstance = new ExampleClass(d);

Im folgenden Abschnitt „Konvertierungen“ finden Sie Konvertierungsbeispiele.Conversion examples are shown in the following section, "Conversions."

KonvertierungenConversions

Konvertierungen zwischen dynamischen Objekten und anderen Typen sind sehr einfach.Conversions between dynamic objects and other types are easy. Dadurch kann der Entwickler zwischen dynamischem und nicht dynamischem Verhalten wechseln.This enables the developer to switch between dynamic and non-dynamic behavior.

Jedes Objekt kann implizit zu einem dynamischen Typ konvertiert werden, wie in den folgenden Beispielen gezeigt.Any object can be converted to dynamic type implicitly, as shown in the following examples.

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

Umgekehrt kann eine implizite Konvertierung dynamisch auf einen Ausdruck vom Typ dynamic angewendet werden.Conversely, an implicit conversion can be dynamically applied to any expression of type dynamic.

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

Überladungsauflösung mit Argumenten vom Typ „dynamic“Overload Resolution with Arguments of Type dynamic

Überladungsauflösung erfolgt zur Laufzeit anstatt zur Kompilierzeit, wenn eines oder mehrere der Argumente in einem Methodenaufruf vom Typ dynamic sind, oder wenn der Empfänger des Methodenaufrufs vom Typ dynamic ist.Overload resolution occurs at run time instead of at compile time if one or more of the arguments in a method call have the type dynamic, or if the receiver of the method call is of type dynamic. Im folgenden Beispiel wird durch das Senden von d1 als Argument kein Compilerfehler ausgelöst, wenn die einzige zugängliche exampleMethod2-Methode so definiert wird, dass sie ein Zeichenfolgenargument akzeptiert. Allerdings wird eine Laufzeitausnahme ausgelöst.In the following example, if the only accessible exampleMethod2 method is defined to take a string argument, sending d1 as the argument does not cause a compiler error, but it does cause a run-time exception. Die Überladungsauflösung schlägt zur Laufzeit fehl, da der Laufzeittyp von d1 int ist und exampleMethod2 eine Zeichenfolge benötigt.Overload resolution fails at run time because the run-time type of d1 is int, and exampleMethod2 requires a string.

// 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 RuntimeDynamic Language Runtime

Die Dynamic Language Runtime (DLR) ist eine neue API in .NET Framework 4.NET Framework 4.The dynamic language runtime (DLR) is a new API in .NET Framework 4.NET Framework 4. Sie bietet die Infrastruktur, die den Typ dynamic in C# und die Implementierung von dynamischen Programmiersprachen wie IronPython und IronRuby unterstützt.It provides the infrastructure that supports the dynamic type in C#, and also the implementation of dynamic programming languages such as IronPython and IronRuby. Weitere Informationen zur DLR finden Sie unter Übersicht über die Dynamic Language Runtime.For more information about the DLR, see Dynamic Language Runtime Overview.

COM-InteropCOM Interop

C# 4 enthält mehrere Funktionen, die die Benutzerfreundlichkeit bei Interoperationen mit COM-APIs wie den Automatisierungs-APIs in Microsoft Office verbessern. includes several features that improve the experience of interoperating with COM APIs such as the Office Automation APIs. Zu diesen Verbesserungen gehören die Verwendung des Typs dynamic und von benannten und optionalen Argumenten.Among the improvements are the use of the dynamic type, and of named and optional arguments.

Viele COM-Methoden ermöglichen die Variation von Argument- und Rückgabetypen durch Festlegen der Typen als object.Many COM methods allow for variation in argument types and return type by designating the types as object. Dadurch wird das explizite Umwandeln der Werte für die Koordination mit stark typisierten Variablen in C# notwendig.This has necessitated explicit casting of the values to coordinate with strongly typed variables in C#. Wenn Sie mit der Option /link (C#-Compileroptionen) kompilieren, ermöglicht es Ihnen die Einführung des Typs dynamic, das Vorkommen von object in COM-Signaturen so zu behandeln, als wäre es vom Typ dynamic. Dadurch können Sie einen Großteil der Umwandlung umgehen.If you compile by using the /link (C# Compiler Options) option, the introduction of the dynamic type enables you to treat the occurrences of object in COM signatures as if they were of type dynamic, and thereby to avoid much of the casting. Die folgenden Anweisungen unterscheiden z.B., wie Sie auf eine Zelle in einem Arbeitsblatt von Microsoft Office Excel mit dem Typ dynamic und ohne den Typ dynamic zugreifen.For example, the following statements contrast how you access a cell in a Microsoft Office Excel spreadsheet with the dynamic type and without the dynamic type.

// 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];
TitelTitle BeschreibungDescription
dynamicdynamic Beschreibt die Verwendung des Schlüsselworts dynamic.Describes the usage of the dynamic keyword.
Übersicht über die Dynamic Language RuntimeDynamic Language Runtime Overview Bietet eine Übersicht über die Dynamic Language Runtime (DLR), eine Laufzeitumgebung, die der Common Language Runtime (CLR) eine Reihe von Diensten für dynamische Sprachen hinzufügt.Provides an overview of the DLR, which is a runtime environment that adds a set of services for dynamic languages to the common language runtime (CLR).
Exemplarische Vorgehensweise: Erstellen und Verwenden von dynamischen ObjektenWalkthrough: Creating and Using Dynamic Objects Bietet eine ausführliche Anleitung zum Erstellen eines benutzerdefinierten dynamischen Objekts und zum Erstellen eines Projekts, das auf eine IronPython-Bibliothek zugreift.Provides step-by-step instructions for creating a custom dynamic object and for creating a project that accesses an IronPython library.
Gewusst wie: Zugreifen auf Office-Interop-Objekte mithilfe von Visual C#-FunktionenHow to: Access Office Interop Objects by Using Visual C# Features Veranschaulicht, wie Sie ein Projekt erstellen, das benannte und optionale Argumente, den Typ dynamic und andere Verbesserungen verwendet, die den Zugriff auf Office-API-Objekte vereinfachen.Demonstrates how to create a project that uses named and optional arguments, the dynamic type, and other enhancements that simplify access to Office API objects.