dynamic (odwołanie w C#)

Artykuł
06/10/2015

dynamic Typu umożliwia operacji, w których występuje ominąć, kontrola typów w czasie kompilacji.Zamiast tego operacje te są rozwiązane w czasie wykonywania.dynamic Typu upraszcza dostęp do interfejsów COM API, takie jak interfejsy API automatyzacji pakietu Office i również API dynamicznych, takich jak biblioteki IronPython oraz do HTML Document Object Model (DOM).

Typ dynamic zachowuje się jak typ object w większości przypadków.Jednak operacje, które zawierają wyrażenia typu dynamic nie są rozpoznawane lub typu sprawdzone przez kompilator.Pakiety kompilator razem informacji na temat operacji oraz że informacje później jest używany do oceny działania w czasie wykonywania.Jako część procesu, zmienne typu dynamic są kompilowane do zmiennych typu object.W związku z tym, należy wpisać dynamic istnieje tylko w czasie kompilacji, a nie w czasie wykonywania.

Poniższy przykład Kontrastuje zmiennej typu dynamic do zmiennej typu object.Aby sprawdzić typ każdej zmiennej w czasie kompilacji, umieść wskaźnik myszy nad dyn lub obj w WriteLine instrukcji.Pokazuje IntelliSense dynamiczne do dyn i obiektu do 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 Instrukcje wyświetlane typy run-time dyn i obj.W tym punkcie mają tego samego typu integer.Są następujące wyniki:

System.Int32

Aby zobaczyć różnicę między dyn i obj w czasie kompilacji, należy dodać następujące dwie linie między deklaracjami i WriteLine instrukcji w poprzednim przykładzie.

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

Zgłosiła błąd kompilatora, próba dodania integer i obiekt w wyrażeniu obj + 3.Jednakże nie będzie zgłaszany błąd dla dyn + 3.Wyrażenie zawiera dyn nie jest zaznaczone w czasie kompilacji, ponieważ typ dyn jest dynamic.

Kontekst

dynamic Słowa kluczowego mogą pojawiać się bezpośrednio lub jako składnik typu skonstruowane w następujących sytuacjach:

W deklaracji, jako typ właściwości, pole, indeksowania, parametr zwraca wartość zmiennej lokalnej, lub wpisz warunek ograniczający.Następujące klasy zastosowania definicji dynamic w kilku różnych deklaracji.

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

W Konwersje jawne typu jako typ docelowy konwersji.

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

W dowolnym kontekście, gdy typy służyć jako wartości, takich jak na prawej stronie is operatora lub as operator, lub jako argument do typeof jako część typu konstruowanej.Na przykład dynamic mogą być używane w następujących wyrażeń.

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

Przykład

W poniższym przykładzie użyto dynamic w kilku zgłoszeń.Main Metoda również Kontrastuje typów w czasie kompilacji sprawdzanie z kontrola typów w czasie wykonywania.

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

Aby uzyskać dodatkowe informacje i przykłady, zobacz Używanie typu dynamicznego (Przewodnik programowania w języku C#).

Zobacz też

Udostępnij za pośrednictwem

dynamic (odwołanie w C#)

Kontekst

Przykład

Zobacz też

Zadania

Informacje

Inne zasoby

Dodatkowe zasoby