Partilhar via

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. Aparece durante a execução e causa uma exceção nesse momento.

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. A execução em tempo real examina as informações armazenadas e qualquer declaração invá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 o utilizador posicionar o ponteiro do rato sobre o uso de testSum no exemplo a seguir, o IntelliSense exibe 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 nas quais o resultado não é dynamic incluem:

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

Por exemplo, o tipo de testInstance na 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 aceita um argumento de string, passar d1 como 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 em tempo de execução de d1 é int, e exampleMethod2 requer uma cadeia de texto.

// 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.
// Uncomment the line to see the 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 os compatibilizar com variáveis de tipo forte em C#. Se compilar usando a opção EmbedInteropTypes (Opções do Compilador C#), a introdução do tipo dynamic permitirá tratar as ocorrências de object nas assinaturas COM como se fossem do tipo dynamic, evitando assim a maior parte do casting. 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#.

Título Descrição
dinâmico Descreve o uso da palavra-chave dynamic.
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.
  • Last updated on