Usando o tipo dinâmico

O dynamic tipo é um tipo estático, mas um objeto do tipo dynamic ignora a verificação de tipo estático. Na maioria dos casos, funciona como se tivesse tipo object. O compilador assume que um dynamic elemento suporta qualquer operação. Portanto, você não precisa determinar se o objeto obtém seu valor de uma API COM, de uma linguagem dinâmica como IronPython, do HTML Document Object Model (DOM), da reflexão ou de outro lugar no programa. No entanto, se o código não for válido, os erros aparecem em tempo de execução.

Por exemplo, se o método exampleMethod1 de instância 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álida porque contém dois argumentos. A chamada causa um erro de compilador. O compilador não verifica a segunda chamada para o método, dynamic_ec.exampleMethod1(10, 4)porque o tipo de dynamic_ec é dynamic. Portanto, nenhum erro do compilador é relatado. No entanto, o erro não escapa à atenção indefinidamente. Ele aparece em tempo de execução e causa uma exceção de tempo de execução.

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) { }
}

O papel do compilador nesses exemplos é empacotar informações sobre o que cada instrução está se propondo a fazer com o dynamic objeto ou expressão. O tempo de execução examina as informações armazenadas e qualquer instrução que não seja válida causa uma exceção em tempo de execução.

O resultado da maioria das operações dinâmicas é ele próprio dynamic. Por exemplo, se você posicionar o ponteiro do mouse sobre o uso do exemplo a testSum seguir, o IntelliSense exibirá o tipo (variável local) dynamic testSum.

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

Operações em que o resultado não dynamic inclui:

• Conversões de dynamic para outro tipo.
• Chamadas de construtor que incluem argumentos do tipo dynamic.

Por exemplo, o tipo de testInstance declaração a seguir é ExampleClass, não dynamic:

var testInstance = new ExampleClass(d);

Conversões

As conversões entre objetos dinâmicos e outros tipos são fáceis. As conversões permitem que o desenvolvedor alterne entre comportamento dinâmico e não dinâmico.

Você pode converter qualquer um para dynamic implicitamente, como mostrado nos exemplos a seguir.

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

Por outro lado, você pode aplicar dinamicamente qualquer conversão implícita a qualquer expressão do tipo dynamic.

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

Resolução de sobrecarga com argumentos do tipo dinâmico

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 tiverem o tipo dynamic, ou se o recetor da chamada de método for do tipo dynamic. No exemplo a seguir, se o único método acessível exampleMethod2 usa um argumento de cadeia de caracteres, enviar d1 como o argumento não causa um erro de compilador, mas causa uma exceção em tempo de execução. A resolução de sobrecarga falha em tempo de execução porque o tipo de tempo de execução é int, e exampleMethod2 requer uma cadeia de d1 caracteres.

// 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âmica

O dynamic language runtime (DLR) fornece a infraestrutura que suporta o dynamic tipo em C#, e também a implementação de linguagens de programação dinâmicas como IronPython e IronRuby. Para obter mais informações sobre o DLR, consulte Visão geral do Dynamic Language Runtime.

Interoperabilidade COM

Muitos métodos COM permitem variação nos tipos de argumento e tipo de retorno designando os tipos como object. A interoperabilidade COM requer a conversão explícita dos valores para coordenar com variáveis fortemente tipadas em C#. Se você compilar usando a opção EmbedInteropTypes (C# Compiler Options), a dynamic introdução do tipo permitirá que você trate as ocorrências de object assinaturas COM como se fossem do tipo dynamice, assim, evitar grande parte da transmissão. Para obter mais informações sobre como usar o dynamic tipo com objetos COM, consulte o artigo sobre Como acessar objetos de interoperabilidade do Office usando recursos C#.

Artigos relacionados

Title	Description
dinâmico	Descreve o dynamic uso da palavra-chave.
Visão geral do Dynamic Language Runtime	Fornece uma visão geral do DLR, que é um ambiente de tempo de execução que adiciona um conjunto de serviços para linguagens dinâmicas ao Common Language Runtime (CLR).
Passo a passo: Criando e usando objetos dinâmicos	Fornece instruções passo a passo para criar um objeto dinâmico personalizado e para criar um projeto que acessa uma IronPython biblioteca.