Usando o tipo dynamic (Guia de Programação em C#)Using type dynamic (C# Programming Guide)

O C# 4 apresenta um novo tipo, dynamic.C# 4 introduces a new type, dynamic. O tipo é um tipo estático, mas um objeto do tipo dynamic ignora a verificação de tipo estático.The type is a static type, but an object of type dynamic bypasses static type checking. Na maioria dos casos, ele funciona como se tivesse o tipo object.In most cases, it functions like it has type object. Em tempo de compilação, supõem-se que um elemento que tem o tipo dynamic dá suporte a qualquer operação.At compile time, an element that is typed as dynamic is assumed to support any operation. Portanto, você não precisa se preocupar se o objeto obtém seu valor de uma API COM, de uma linguagem dinâmica como o IronPython, do HTML DOM (Modelo de Objeto do Documento), a reflexão ou de algum outro lugar no programa.Therefore, you do not have to be concerned about whether the object gets its value from a COM API, from a dynamic language such as IronPython, from the HTML Document Object Model (DOM), from reflection, or from somewhere else in the program. No entanto, se o código não for válido, os erros serão capturados em tempo de execução.However, if the code is not valid, errors are caught at run time.

Por exemplo, se método de instância exampleMethod1 no código a seguir tiver apenas um parâmetro, o compilador reconhecerá que a primeira chamada para o método, ec.exampleMethod1(10, 4), não é válido porque ele contém dois argumentos.For example, if instance method exampleMethod1 in the following code has only one parameter, the compiler recognizes that the first call to the method, ec.exampleMethod1(10, 4), is not valid because it contains two arguments. Essa chamada causa um erro do compilador.The call causes a compiler error. A segunda chamada para o método, dynamic_ec.exampleMethod1(10, 4), não é verificada pelo compilador porque o tipo de dynamic_ec é dynamic.The second call to the method, dynamic_ec.exampleMethod1(10, 4), is not checked by the compiler because the type of dynamic_ec is dynamic. Portanto, nenhum erro de compilador é relatado.Therefore, no compiler error is reported. No entanto, o erro não escapa o aviso indefinidamente.However, the error does not escape notice indefinitely. Ele é detectado em tempo de execução e causa uma exceção de tempo de execução.It is caught at run time and causes a run-time exception.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following call to exampleMethod1 causes a compiler error 
    // if exampleMethod1 has only one parameter. Uncomment the line
    // to see the error.
    //ec.exampleMethod1(10, 4);

    dynamic dynamic_ec = new ExampleClass();
    // The following line is not identified as an error by the
    // compiler, but it causes a run-time exception.
    dynamic_ec.exampleMethod1(10, 4);

    // The following calls also do not cause compiler errors, whether 
    // appropriate methods exist or not.
    dynamic_ec.someMethod("some argument", 7, null);
    dynamic_ec.nonexistentMethod();
}
class ExampleClass
{
    public ExampleClass() { }
    public ExampleClass(int v) { }

    public void exampleMethod1(int i) { }

    public void exampleMethod2(string str) { }
}

A função do compilador nesses exemplos é reunir informações sobre o que cada instrução está propondo fazer para o objeto ou expressão que tem o tipo dynamic.The role of the compiler in these examples is to package together information about what each statement is proposing to do to the object or expression that is typed as dynamic. Em tempo de execução, as informações armazenadas são examinadas e qualquer instrução inválida causa uma exceção de tempo de execução.At run time, the stored information is examined, and any statement that is not valid causes a run-time exception.

O resultado de operações mais dinâmicas é dynamic.The result of most dynamic operations is itself dynamic. Por exemplo, se você passar o ponteiro do mouse sobre o uso de testSum no exemplo a seguir, o IntelliSense exibirá o tipo (variável local) testSum dinâmico.For example, if you rest the mouse pointer over the use of testSum in the following example, IntelliSense displays the type (local variable) dynamic testSum.

dynamic d = 1;
var testSum = d + 3;
// Rest the mouse pointer over testSum in the following statement.
System.Console.WriteLine(testSum);

As operações em que o resultado não é dynamic incluem:Operations in which the result is not dynamic include:

  • Conversões de dynamic em outro tipo.Conversions from dynamic to another type.
  • Chamadas de construtor que incluem argumentos do tipo dynamic.Constructor calls that include arguments of type dynamic.

Por exemplo, o tipo de testInstance na seguinte declaração é ExampleClass e não dynamic:For example, the type of testInstance in the following declaration is ExampleClass, not dynamic:

var testInstance = new ExampleClass(d);

Exemplos de conversão são mostrados na seção a seguir, "Conversões".Conversion examples are shown in the following section, "Conversions."

ConversõesConversions

As conversões entre objetos dinâmicos e outros tipos são fáceis.Conversions between dynamic objects and other types are easy. Isso permite que o desenvolvedor mude entre o comportamento dinâmico e o não dinâmico.This enables the developer to switch between dynamic and non-dynamic behavior.

Qualquer objeto pode ser convertido no tipo dinâmico implicitamente, conforme mostrado nos exemplos a seguir.Any object can be converted to dynamic type implicitly, as shown in the following examples.

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

Por outro lado, uma conversão implícita pode ser aplicada dinamicamente a qualquer expressão do tipo dynamic.Conversely, an implicit conversion can be dynamically applied to any expression of type dynamic.

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

Resolução de sobrecarga com argumentos de tipo dynamicOverload resolution with arguments of type dynamic

A resolução de sobrecarga ocorre em tempo de execução em vez de em tempo de compilação se um ou mais dos argumentos em uma chamada de método tem o tipo dynamic ou se o receptor da chamada do método é do tipo dynamic.Overload resolution occurs at run time instead of at compile time if one or more of the arguments in a method call have the type dynamic, or if the receiver of the method call is of type dynamic. No exemplo a seguir, se o único método exampleMethod2 acessível for definido para obter um argumento de cadeia de caracteres, enviar d1 como o argumento não causará um erro de compilador, mas causará uma exceção de tempo de execução.In the following example, if the only accessible exampleMethod2 method is defined to take a string argument, sending d1 as the argument does not cause a compiler error, but it does cause a run-time exception. A resolução de sobrecarga falha em tempo de execução porque o tipo de tempo de execução de d1 é int e exampleMethod2 requer uma cadeia de caracteres.Overload resolution fails at run time because the run-time type of d1 is int, and exampleMethod2 requires a string.

// Valid.
ec.exampleMethod2("a string");

// The following statement does not cause a compiler error, even though ec is not
// dynamic. A run-time exception is raised because the run-time type of d1 is int.
ec.exampleMethod2(d1);
// The following statement does cause a compiler error.
//ec.exampleMethod2(7);

Tempo de execução de linguagem dinâmicoDynamic language runtime

O DLR (Dynamic Language Runtime) é uma nova API no .NET Framework 4.The dynamic language runtime (DLR) is a new API in .NET Framework 4. Ele fornece a infraestrutura que dá suporte ao tipo dynamic em C# e também à implementação das linguagens de programação dinâmicas como IronPython e IronRuby.It provides the infrastructure that supports the dynamic type in C#, and also the implementation of dynamic programming languages such as IronPython and IronRuby. Para obter mais informações sobre o DLR, consulte Visão geral do Dynamic Language Runtime.For more information about the DLR, see Dynamic Language Runtime Overview.

interoperabilidade COMCOM interop

O C# 4 inclui vários recursos que aprimoram a experiência de interoperar com APIs COM, como as APIs de Automação do Office.C# 4 includes several features that improve the experience of interoperating with COM APIs such as the Office Automation APIs. Entre os aperfeiçoamentos estão o uso do tipo dynamic e de argumentos nomeados e opcionais.Among the improvements are the use of the dynamic type, and of named and optional arguments.

Muitos métodos COM permitem variação nos tipos de argumento e tipo de retorno, especificando os tipos como object.Many COM methods allow for variation in argument types and return type by designating the types as object. Isso exigiu a conversão explícita dos valores para coordenar com variáveis fortemente tipadas no C#.This has necessitated explicit casting of the values to coordinate with strongly typed variables in C#. Se você compilar usando a opção -link (C# opções do compilador) , a introdução do tipo de dynamic permite tratar as ocorrências de object em assinaturas com como se fossem do tipo dynamic e, portanto, evitar grande parte da conversão.If you compile by using the -link (C# Compiler Options) option, the introduction of the dynamic type enables you to treat the occurrences of object in COM signatures as if they were of type dynamic, and thereby to avoid much of the casting. Por exemplo, as seguintes instruções de contrastam como acessar uma célula em uma planilha do Microsoft Office Excel com o tipo dynamic e sem o tipo dynamic.For example, the following statements contrast how you access a cell in a Microsoft Office Excel spreadsheet with the dynamic type and without the dynamic type.

// Before the introduction of dynamic.
((Excel.Range)excelApp.Cells[1, 1]).Value2 = "Name";
Excel.Range range2008 = (Excel.Range)excelApp.Cells[1, 1];
// After the introduction of dynamic, the access to the Value property and
// the conversion to Excel.Range are handled by the run-time COM binder.
excelApp.Cells[1, 1].Value = "Name";
Excel.Range range2010 = excelApp.Cells[1, 1];
TítuloTitle DescriçãoDescription
dynamicdynamic Descreve o uso da palavra-chave dynamic.Describes the usage of the dynamic keyword.
Visão geral do Dynamic Language RuntimeDynamic Language Runtime Overview Fornece uma visão geral do DLR, que é um ambiente de tempo de execução que adiciona um conjunto de serviços para as linguagens dinâmicas para o CLR (Common Language Runtime).Provides an overview of the DLR, which is a runtime environment that adds a set of services for dynamic languages to the common language runtime (CLR).
Passo a passo: Criando e usando objetos dinâmicosWalkthrough: Creating and Using Dynamic Objects Fornece instruções passo a passo para criar um objeto dinâmico personalizado e para criar um projeto que acessa uma biblioteca IronPython.Provides step-by-step instructions for creating a custom dynamic object and for creating a project that accesses an IronPython library.
Como acessar objetos de interoperabilidade do Office usando recursos do Visual C#How to: Access Office Interop Objects by Using Visual C# Features Demonstra como criar um projeto que usa argumentos nomeados e opcionais, o tipo dynamic e outros aprimoramentos que simplificam o acesso aos objetos de API do Office.Demonstrates how to create a project that uses named and optional arguments, the dynamic type, and other enhancements that simplify access to Office API objects.