dynamické (C#-Reference)

Článek
05/01/2013

dynamic Typ umožňuje operace, v nichž se vyskytuje obejít kontrolu typu v čase kompilace.Místo toho tyto operace jsou v době spuštění.dynamic Typu zjednodušuje přístup k rozhraní COM API jako Office Automation API a také dynamické rozhraní API, jako jsou knihovny IronPython a k HTML modelu DOM (Document Object).

Typ dynamic se chová jako typ object ve většině případů.Však operací, které obsahují výrazy typu dynamic nejsou překládány nebo typ kontrolovány kompilátorem.Kompilátor balíčků, které dohromady informace o operaci a tyto informace později použita k vyhodnocení operaci v běhu.Jako součást procesu proměnné typu dynamic jsou zkompilovány do proměnné typu object.Zadejte proto dynamic existuje pouze v době kompilace, není v době spuštění.

Následující příklad porovnání proměnné typu dynamic proměnné typu object.Chcete-li ověřit jednotlivé proměnné typu v čase kompilace, umístěte ukazatel myši dyn nebo obj v WriteLine příkazy.Technologie IntelliSense ukazuje dynamické pro dyn a objektu pro 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 Příkazy zobrazit typy spuštění dyn a obj.V tomto okamžiku mají stejného typu celé číslo.Následující výsledek:

System.Int32

Rozdíl mezi dyn a obj v době kompilace, přidejte následující dva řádky mezi prohlášeními a WriteLine prohlášení v předchozím příkladu.

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

Pokus o přidání celé a objekt ve výrazu je hlášena chyba kompilátoru obj + 3.Však žádné chybové hlášení pro dyn + 3.Výraz, který obsahuje dyn není zaškrtnuta v době kompilace, protože typ dyn je dynamic.

Kontext

dynamic Klíčové slovo můžete zobrazit přímo nebo jako součást typu vyrobeno v následujících situacích:

V prohlášení jako typ vlastnosti, pole, indexování, parametr vrácení hodnoty místní proměnné nebo zadejte omezení.Následující třídy používá definici dynamic v několika různých prohlášení.

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

V typu explicitní převody jako cílový typ převodu.

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

V libovolném kontextu, kde se typy sloužit jako hodnoty, jako například na pravé straně is operátor nebo as operátor, nebo jako argument typeof jako součást konstrukce typu.Například dynamic lze použít v následujících výrazů.

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

Příklad

Následující příklad používá dynamic v několika prohlášení.Main Metoda porovnání také kontrola typu v době spuštění kontrola typu v čase kompilace.

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

Další informace a příklady naleznete v tématu Pomocí dynamického typu (C# program televize).

Viz také

Sdílet prostřednictvím

dynamické (C#-Reference)

Kontext

Příklad

Viz také

Úkoly

Referenční dokumentace

Další zdroje

Další materiály