dinâmico (referência de C#)

Artigo
08/04/2011

O dynamic tipo permite que as operações em que ele ocorre para ignorar a verificação de tipo em tempo de compilação. Em vez disso, essas operações são resolvidas em tempo de execução. O dynamic tipo simplifica o acesso às APIs COM, como as APIs de automação do Office e também para APIs dinâmicas como, por exemplo, bibliotecas de IronPython e para o HTML documento objeto DOM (modelo).

Tipo de dynamic se comporta como um tipo de object na maioria das circunstâncias. No entanto, as operações que contenham expressões do tipo dynamic não foram resolvidos ou tipo marcado pelo compilador. Os pacotes do compilador juntas informações sobre a operação e que posteriormente é usada para avaliar a operação no tempo de execução. Como parte do processo, variáveis do tipo dynamic são compilados em variáveis do tipo object. Portanto, digite dynamic existe somente em tempo de compilação, não no tempo de execução.

O exemplo a seguir contrasta a uma variável do tipo dynamic a uma variável do tipo object. Para verificar o tipo de cada variável em tempo de compilação, coloque o ponteiro do mouse sobre dyn ou obj na WriteLine instruções. Apresentações de IntelliSense dinâmico para dyn e objeto para 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());
    }
}

O WriteLine instruções exibem os tipos de tempo de execução de dyn e obj. Nesse ponto, ambos têm o mesmo tipo inteiro. A seguinte saída é produzida:

System.Int32

Para ver a diferença entre dyn e obj em tempo de compilação, adicione as duas linhas seguintes entre as declarações e o WriteLine instruções no exemplo anterior.

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

Um erro do compilador é relatado para a adição de tentativa de um número inteiro e um objeto na expressão obj + 3. No entanto, nenhum erro é relatado para dyn + 3. A expressão que contém dyn não estiver marcada no momento da compilação porque o tipo de dyn é dynamic.

Contexto

O dynamic palavra-chave pode aparecer diretamente ou como um componente de um tipo construído nas seguintes situações:

Em declarações, como o tipo de uma propriedade, o campo, o indexador, o parâmetro, retornar o valor de variável local, ou digite a restrição. Os seguintes usos de definição de classe dynamic em várias declarações diferentes.

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

Em conversões de tipo explícito, como o tipo de destino de uma conversão.

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

Em qualquer contexto onde tipos servem como valores, como no lado direito de uma is operador ou uma as operador, ou como o argumento typeof como parte de um tipo construído. Por exemplo, dynamic pode ser usado em expressões a seguir.

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

Exemplo

O exemplo a seguir usa dynamic em várias declarações. O Main método também contrasta a verificação com verificação de tipos em tempo de execução de tipos em tempo de compilação.

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

Para mais informações e exemplos, consulte Usando o Tipo dinâmico (guia de programação C#).

Consulte também

Partilhar via

dinâmico (referência de C#)

Contexto

Exemplo

Consulte também

Tarefas

Referência

Outros recursos

Recursos adicionais