dynamic (C#-Referenz)

Artikel
08/10/2011

Der dynamic-Typ ermöglicht die Vorgänge, in denen die Überprüfung des Kompilierzeittyps umgangen wird. Stattdessen werden diese Vorgänge zur Laufzeit aufgelöst. Der dynamic-Typ vereinfacht den Zugriff auf COM-APIs wie Office-Automatisierungs-APIs und zudem auf dynamische APIs wie IronPython-Bibliotheken und auf das HTML-Dokumentobjektmodell (DOM).

Der Typ dynamic verhält sich in den meisten Umständen wie der Typ object. Vorgänge, die Ausdrücke vom Typ dynamic enthalten, werden jedoch nicht aufgelöst, oder der Compiler führt keine Typüberprüfung aus. Der Compiler verpackt Informationen zum Vorgang, und diese Informationen werden später dazu verwendet, den Vorgang zur Laufzeit auszuwerten. Als Teil des Prozesses werden Variablen des Typs dynamic in Variablen des Typs object kompiliert. Daher ist der dynamic-Typ nur zur Kompilierzeit vorhanden, jedoch nicht zur Laufzeit.

Im folgenden Beispiel wird eine Variable vom Typ dynamic einer Variable vom Typ object gegenüber gestellt. Um zur Kompilierzeit den Typ jeder Variable zu überprüfen, setzen Sie den Mauszeiger in den WriteLine-Anweisungen über dyn oder obj. IntelliSense zeigt dynamisch für dyn und Objekt für obj an.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

Die WriteLine-Anweisungen zeigen die Laufzeittypen von dyn und obj an. An diesem Punkt haben beide den gleichen Typ, ganze Zahl. Die folgende Ausgabe wird generiert:

System.Int32

Um zur Kompilierzeit den Unterschied zwischen dyn und obj zu erkennen, fügen Sie die folgenden zwei Zeilen zwischen den Deklarationen und den WriteLine-Anweisungen im vorherigen Beispiel hinzu.

dyn = dyn + 3;
obj = obj + 3;

Ein Compilerfehler wird gemeldet für die versuchte Hinzufügung einer ganzen Zahl und eines Objekts in Ausdruck obj + 3. Für dyn + 3 wird jedoch kein Fehler gemeldet. Der Ausdruck, der dyn enthält, wird zur Kompilierzeit nicht überprüft, da der Typ von dyndynamic ist.

Kontext

Das dynamic-Schlüsselwort kann in den folgenden Situationen direkt oder als Komponente eines konstruierten Typs angezeigt werden:

In Deklarationen als Typ einer Eigenschaft, eines Felds, eines Indexers, eines Parameters, eines Rückgabewerts, einer lokalen Variablen oder einer Typeinschränkung. Die folgende Klassendefinition verwendet dynamic in mehreren anderen Deklarationen.

class ExampleClass
{
    // A dynamic field.
    static dynamic field;

    // A dynamic property.
    dynamic prop { get; set; }

    // A dynamic return type and a dynamic paramater type.
    public dynamic exampleMethod(dynamic d)
    {
        // A dynamic local variable.
        dynamic local = "Local variable";
        int two = 2;

        if (d is int)
        {
            return local;
        }
        else
        {
            return two;
        }
    }
}

In expliziten Typkonvertierungen als Zieltyp einer Konvertierung.

static void convertToDynamic()
{
    dynamic d;
    int i = 20;
    d = (dynamic)i;
    Console.WriteLine(d);

    string s = "Example string.";
    d = (dynamic)s;
    Console.WriteLine(d);

    DateTime dt = DateTime.Today;
    d = (dynamic)dt;
    Console.WriteLine(d);

}
// Results:
// 20
// Example string.
// 2/17/2009 9:12:00 AM

In einem beliebigen Kontext, in dem Typen als Werte dienen, z. B. auf der rechten Seite eines is-Operators oder eines as-Operators, oder als Argument für typeof als Teil eines konstruierten Typs. Beispielsweise kann dynamic in den folgenden Ausdrücken verwendet werden.

int i = 8;
dynamic d;
// With the is operator.
// The dynamic type behaves like object. The following
// expression returns true unless someVar has the value null.
if (someVar is dynamic) { }

// With the as operator.
d = i as dynamic;

// With typeof, as part of a constructed type.
Console.WriteLine(typeof(List<dynamic>));

// The following statement causes a compiler error.
//Console.WriteLine(typeof(dynamic));

Beispiel

Im folgenden Beispiel wird dynamic in mehreren Deklarationen verwendet. Die Main-Methode stellt auch die Überprüfung von Kompilier- und Laufzeittyp einander gegenüber.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.exampleMethod(10));
            Console.WriteLine(ec.exampleMethod("value"));

            // The following line causes a compiler error because exampleMethod
            // takes only one argument.
            //Console.WriteLine(ec.exampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.exampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to exampleMethod
            // with two arguments does not produce an error at compile time.
            // However, itdoes cause a run-time error. 
            //Console.WriteLine(dynamic_ec.exampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic field;
        dynamic prop { get; set; }

        public dynamic exampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results:
// Local variable
// 2
// Local variable

Weitere Informationen und Beispiele finden Sie unter Verwenden des Typs dynamic (C#-Programmierhandbuch).

Siehe auch

dynamic (C#-Referenz)

Kontext

Beispiel

Siehe auch

Aufgaben

Referenz

Weitere Ressourcen

Zusätzliche Ressourcen