Visual C# 2010 introduces a new type, dynamic. The type is a static type, but an object of type dynamic bypasses static type checking. In most cases, it functions like it has type object. At compile time, an element that is typed as dynamic is assumed to support any operation. 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. However, if the code is not valid, errors are caught at run time.

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. The call causes a compiler error. 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. Therefore, no compiler error is reported. However, the error does not escape notice indefinitely. It is caught at run time and causes a run-time exception.

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

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. At run time, the stored information is examined, and any statement that is not valid causes a run-time exception.

The result of most dynamic operations is itself dynamic. 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);

Operations in which the result is not dynamic include conversions from dynamic to another type, and constructor calls that include arguments of type dynamic. For example, the type of testInstance in the following declaration is ExampleClass, not dynamic.

var testInstance = new ExampleClass(d);

Conversion examples are shown in the following section, "Conversions."

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.