dynamic (Referência de C#)dynamic (C# Reference)

O tipo dynamic habilita operações nas quais ele ocorre para ignorar a verificação de tipo em tempo de compilação.The dynamic type enables the operations in which it occurs to bypass compile-time type checking. Em vez disso, essas operações são resolvidas em tempo de execução.Instead, these operations are resolved at run time. O tipo dynamic simplifica o acesso a APIs COM, como as APIs de Automação do Office e também às APIs dinâmicas, como bibliotecas do IronPython e ao Modelo de Objeto do Documento (DOM) do HTML.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).

O tipo dynamic se comporta como o tipo object na maioria das circunstâncias.Type dynamic behaves like type object in most circumstances. No entanto, as operações que contêm expressões do tipo dynamic não são resolvidas ou verificadas pelo compilador.However, operations that contain expressions of type dynamic are not resolved or type checked by the compiler. O compilador junta as informações sobre a operação em pacotes e, posteriormente, essas informações são usadas para avaliar a operação em tempo de execução.The compiler packages together information about the operation, and that information is later used to evaluate the operation at run time. Como parte do processo, as variáveis do tipo dynamic são compiladas em variáveis do tipo object.As part of the process, variables of type dynamic are compiled into variables of type object. Portanto, o tipo dynamic existe somente em tempo de compilação e não em tempo de execução.Therefore, type dynamic exists only at compile time, not at run time.

O exemplo a seguir compara uma variável do tipo dynamic a uma variável do tipo object.The following example contrasts a variable of type dynamic to a variable of type object. Para verificar o tipo de cada variável no tempo de compilação, coloque o ponteiro do mouse sobre dyn ou obj nas instruções WriteLine.To verify the type of each variable at compile time, place the mouse pointer over dyn or obj in the WriteLine statements. O IntelliSense mostra dinâmico para dyn e objeto para 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());
    }
}

As instruções WriteLine exibem os tipos de tempo de execução de dyn e obj.The WriteLine statements display the run-time types of dyn and obj. Nesse ponto, ambos têm o mesmo tipo, inteiro.At that point, both have the same type, integer. A saída a seguir será produzida:The following output is produced:

System.Int32

System.Int32

Para ver a diferença entre dyn e obj em tempo de compilação, adicione as duas linhas a seguir entre as declarações e as instruções WriteLine no exemplo anterior.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;

Um erro de compilador será relatado em virtude da tentativa de adição de um inteiro e um objeto à expressão obj + 3.A compiler error is reported for the attempted addition of an integer and an object in expression obj + 3. No entanto, nenhum erro será relatado para dyn + 3.However, no error is reported for dyn + 3. A expressão contém dyn não é verificada em tempo de compilação, pois o tipo de dyn é dynamic.The expression that contains dyn is not checked at compile time because the type of dyn is dynamic.

ContextoContext

A palavra-chave dynamic pode aparecer diretamente ou como um componente de um tipo construído nas seguintes situações:The dynamic keyword can appear directly or as a component of a constructed type in the following situations:

  • Em declarações, como o tipo de uma propriedade, campo, indexador, parâmetro, valor retornado, variável local ou restrição de tipo.In declarations, as the type of a property, field, indexer, parameter, return value, local variable, or type constraint. A definição de classe a seguir usa dynamic em várias declarações diferentes.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;
            }
        }
    }
    
  • Em conversões explícitas de tipo, como o tipo de destino de uma conversão.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.
    // 7/25/2018 12:00:00 AM
    
  • Em qualquer contexto em que tipos sirvam como valores, como no lado direito de um operador is ou um operador as ou como o argumento para typeof como parte de um tipo construído.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. Por exemplo, dynamic pode ser usado nas expressões a seguir.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));
    

ExemploExample

O exemplo a seguir usa dynamic em várias declarações.The following example uses dynamic in several declarations. O método Main também compara a verificação de tipo em tempo de compilação com a verificação de tipo em tempo de execução.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, it does 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 obter mais informações e exemplos, consulte Usando o Tipo dynamic.For more information and examples, see Using Type dynamic.

Consulte tambémSee also