dynamisch (C#-Referenz)

Die neueste Dokumentation für Visual Studio 2017 RC finden Sie in der Visual Studio 2017 RC-Dokumentation.

Bei Vorgängen, die über den dynamischen Typ implementiert werden, besteht die Rolle dieses Typs darin, die Typprüfung zur Kompilierungszeit zu umgehen und diese Vorgänge stattdessen zur Laufzeit aufzulösen. Der dynamische Typ vereinfacht den Zugriff auf COM-APIs (wie die Office Automation API), dynamische APIs (wie die IronPython-Bibliothek) und das HTML Document Object Model (DOM).

In den meisten Fällen verhalten sich dynamische Typen genauso wie Objekttypen. Allerdings werden Vorgänge, die Ausdrücke vom Typ „Dynamic“ enthalten, vom Compiler weder analysiert noch typgeprüft. Der Compiler packt Informationen zu diesem Vorgang zusammen und diese Informationen werden später zur Berechnung des Laufzeitvorgangs verwendet. Dabei werden Variablen vom Typ „dynamic“ in Variablen vom Typ „object“ kompiliert. Daher existiert der Typ „dynamic“ nur zur Kompilierungszeit und nicht zur Laufzeit.

Das folgende Beispiel vergleicht eine Variable vom Typ „dynamic“ mit einer Variablen vom Typ „object“. Um den Typ jeder Variablen zur Kompilierungszeit zu überprüfen, platzieren Sie den Mauszeiger über dyn oder obj in der WriteLine-Anweisung. IntelliSense zeigt die „Dynamik“ von dyn und das „Objekt“ von obj .

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());
        }
    }

WriteLine-Anweisung zeigt den Laufzeittyp von dyn und obj an. Zu diesem Zeitpunkt haben beide den gleichen Integer-Typ. Die folgende Ausgabe wird generiert:

System.Int32

System.Int32

Um den Unterschied zwischen dyn und obj , zwischen der Deklaration und der WriteLine-Anweisung im vorherigen zu sehen Beispiel Fügen Sie Folgendes zwischen den beiden Zeilen hinzu.

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

Compilerfehler für Versuche melden, Ganzzahlen und Objekte im Ausdruck obj + 3 hinzuzufügen. Dyn + 3-Fehler werden jedoch nicht gemeldet. Ausdrücke, die dyn enthalten, werden zur Kompilierungszeit nicht überprüft, da dyn vom Typ „dynamic“ ist.

Kontext

Das dynamische Schlüsselwort kann in den folgenden Situationen direkt oder als Komponente eines konstruierten Typs erscheinen:

In einer Deklaration ein Typ als Eigenschaft, Feld, Indexer, Parameter, Rückgabewert oder Typbeschränkung. Die folgende Klassendefinition verwendet Dynamic in mehreren verschiedenen Deklarationen.

class ExampleClass
    {        // A dynamic field.
        static dynamic field;        // A dynamic property.
        dynamic prop { get; set; }        // A dynamic return type and a dynamic parameter 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;
            }
        }
    }

Dienen bei einer expliziten Typkonvertierung als Zieltyp der 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 jedem Kontext, in dem ein Typ als Wert dient (z. B. der is-Operator oder die rechte Seite des as-Operators) oder Teil eines konstruierten Typs als Argument für typeof ist. Beispielsweise können Sie „dynamic“ in den folgenden Ausdrücken verwenden.

        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

Das folgende Beispiel verwendet Dynamic mit mehreren Deklarationen. Main verwendet auch die Typprüfung zur Laufzeit im Vergleich zur Typprüfung zur Kompilierungszeit.

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