dynamic (C#-Referenz)dynamic (C# Reference)

Der dynamic-Typ ermöglicht die Vorgänge, in denen er auftritt, um die Typüberprüfung zur Kompilierzeit zu umgehen.The dynamic type enables the operations in which it occurs to bypass compile-time type checking. Stattdessen werden diese Vorgänge zur Laufzeit aufgelöst.Instead, these operations are resolved at run time. Der dynamic-Typ vereinfacht den Zugriff auf COM-APIs, z.B. die Office Automation-APIs, und auch auf dynamische APIs, beispielsweise IronPython-Bibliotheken und auf das HTML-Dokumentobjektmodell (Document Object Model, DOM).The dynamic type simplifies access to COM APIs such as the Office Automation APIs, and also to dynamic APIs such as IronPython libraries, and to the HTML Document Object Model (DOM).

Der Typ dynamic verhält sich in den meisten Fällen wie Typ object.Type dynamic behaves like type object in most circumstances. Jedoch werden Vorgänge, die Ausdrücke des Typs dynamic enthalten, nicht aufgelöst oder durch den Compiler typgeprüft.However, operations that contain expressions of type dynamic are not resolved or type checked by the compiler. Der Compiler packt Informationen über den Vorgang. Diese Informationen werden später zur Evaluierung des Vorgangs zur Laufzeit verwendet.The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. Als Teil dieses Prozesses werden Variablen des Typs dynamic in Variablen des Typs object kompiliert.As part of the process, variables of type dynamic are compiled into variables of type object. Deshalb existiert der Typ dynamic nur zur Kompilierzeit und nicht zur Laufzeit.Therefore, type dynamic exists only at compile time, not at run time.

Das folgende Beispiel vergleicht den Unterschied einer Variable des Typs dynamic mit einer Variable des Typs object.The following example contrasts a variable of type dynamic to a variable of type object. Um den Typ jeder Variable zur Kompilierzeit zu überprüfen, zeigen Sie mit dem Mauszeiger auf dyn oder obj in den WriteLine-Anweisungen.To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statements. IntelliSense zeigt dynamic für dyn und object für obj.IntelliSense shows dynamic for dyn and object for 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());
    }
}

Die WriteLine-Anweisungen zeigen die Laufzeittypen von dyn und obj.The WriteLine statements display the run-time types of dyn and obj. Zu diesem Zeitpunkt verfügen beide denselben Typ, Integer.At that point, both have the same type, integer. Es wird die folgende Ausgabe generiert:The following output is produced:

System.Int32

System.Int32

Um den Unterschied zwischen dyn und obj zur Kompilierzeit anzuzeigen, fügen Sie die folgenden zwei Zeilen zwischen die Deklarationen und die WriteLine-Anweisungen im vorherigen Beispiel ein.To see the difference between dyn and obj at compile time, add the following two lines between the declarations and the WriteLine statements in the previous example.

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

Es wird ein Kompilierfehler für den Versuch, einen Integer und ein Objekt im Ausdruck obj + 3 einzufügen, ausgegeben.A compiler error is reported for the attempted addition of an integer and an object in expression obj + 3. Es wird jedoch kein Fehler für dyn + 3 gemeldet.However, no error is reported for dyn + 3. Der Ausdruck, der dyn enthält, wird nicht zur Kompilierzeit überprüft, da der Typ von dyn dynamic ist.The expression that contains dyn is not checked at compile time because the type of dyn is dynamic.

KontextContext

Das Schlüsselwort dynamic kann direkt oder als Komponente eines konstruierten Typs in den folgenden Situationen erscheinen:The dynamic keyword can appear directly or as a component of a constructed type in the following situations:

  • In Deklarationen, als Typ einer Eigenschaft, als Feld, Indexer, Parameter, Rückgabewert, lokale Variable oder Typeinschränkung.In declarations, as the type of a property, field, indexer, parameter, return value, local variable, or type constraint. Die folgende Klassendefinition verwendet dynamic in einigen unterschiedlichen Deklarationen.The following class definition uses dynamic in several different declarations.

    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;
            }
        }
    }
    
  • In expliziten Typkonvertierungen als Zieltyp einer Konversion.In explicit type conversions, as the target type of a conversion.

    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 Typen als Werte, z.B. auf der rechten Seite eines is-Operators oder eines as-Operators oder als Argument für typeof als Teil eines konstruierten Typs dienen.In any context where types serve as values, such as on the right side of an is operator or an as operator, or as the argument to typeof as part of a constructed type. Zum Beispiel kann dynamic in den folgenden Ausdrücken verwendet werden.For example, dynamic can be used in the following expressions.

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

BeispielExample

Das folgende Beispiel verwendet dynamic in einigen Deklarationen.The following example uses dynamic in several declarations. Die Main-Methode unterscheidet auch die Typüberprüfung zur Kompilierzeit und die Laufzeittypüberprüfung.The Main method also contrasts compile-time type checking with run-time type checking.

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 von dynamischen Typen.For more information and examples, see Using Type dynamic.

Siehe auchSee Also

System.Dynamic.ExpandoObject
System.Dynamic.DynamicObject
Verwenden von dynamischen TypenUsing Type dynamic
objectobject
isis
asas
typeoftypeof
Gewusst wie: Sichere Umwandlung mit den Operatoren "as" und "is"How to: Safely Cast by Using as and is Operators
Exemplarische Vorgehensweise: Erstellen und Verwenden von dynamischen ObjektenWalkthrough: Creating and Using Dynamic Objects