Utilização da dinâmica do tipo (Guia de Programação C#)

C# 4 introduz um novo tipo, dynamic. O tipo é um tipo estático, mas um objeto de tipo dynamic contorna a verificação do tipo estático. Na maioria dos casos, funciona como se fosse do tipo object. No momento da compilação, um elemento que é dactilografado como dynamic se presume apoiar qualquer operação. Portanto, não precisa de se preocupar se o objeto obtém o seu valor a partir de uma API COM, a partir de uma linguagem dinâmica como IronPython, do Modelo de Objeto de Documento HTML (DOM), de reflexão ou de outro lugar do programa. No entanto, se o código não for válido, os erros são apanhados no tempo de execução.

Por exemplo, se o método exampleMethod1 de instância no seguinte código tiver apenas um parâmetro, o compilador reconhece 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 do compilador. A segunda chamada para o método, dynamic_ec.exampleMethod1(10, 4)não é verificada pelo compilador porque o tipo de dynamic_ec .dynamic Portanto, não é reportado qualquer erro do compilador. No entanto, o erro não escapa indefinidamente ao aviso. É apanhado no tempo de execução e causa uma exceção ao 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 nestes exemplos é embalar em conjunto informações sobre o que cada declaração está a propor fazer ao objeto ou expressão que é dactilografado como dynamic. No tempo de execução, as informações armazenadas são examinadas, e qualquer declaração que não seja válida causa uma exceção no tempo de execução.

O resultado da maioria das operações dinâmicas é em si dynamic. Por exemplo, se apoiar o ponteiro do rato sobre a utilização do testSum seguinte exemplo, o IntelliSense exibe o tipo (variável local) testSum dinâmico.

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:

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

Por exemplo, o tipo de testInstance declaração que se segue não dynamicéExampleClass:

var testInstance = new ExampleClass(d);

Exemplos de conversão são mostrados na seguinte secção, "Conversões".

Conversões

As conversões entre objetos dinâmicos e outros tipos são fáceis. Isto permite ao desenvolvedor alternar entre comportamento dinâmico e não dinâmico.

Qualquer objeto pode ser convertido para tipo dinâmico implicitamente, como mostrado nos seguintes exemplos.

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

Inversamente, uma conversão implícita pode ser aplicada dinamicamente 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 de dinâmica tipo

A resolução de sobrecarga ocorre no tempo de execução em vez de no momento de compilação se um ou mais dos argumentos de uma chamada de método tiver o tipo dynamic, ou se o recetor da chamada do método for do tipo dynamic. No exemplo seguinte, se o único método acessível exampleMethod2 for definido para tomar um argumento de corda, enviar d1 como o argumento não causa um erro de compilador, mas causa uma exceção de tempo de execução. A resolução de sobrecarga falha no tempo de execução porque o tipo de tempo de execução d1 é int, e exampleMethod2 requer uma corda.

// 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 dinâmico da linguagem

O tempo dinâmico de execução da linguagem (DLR) é uma API que foi introduzida em .NET Framework 4. Fornece a infraestrutura que suporta o dynamic tipo em C#, e também a implementação de linguagens dinâmicas de programação como IronPython e IronRuby. Para obter mais informações sobre o DLR, consulte a Visão Geral do Tempo de Execução da Linguagem Dinâmica.

Interop COM

O C# 4 inclui várias funcionalidades que melhoram a experiência de interoperação com APIs com COM, como as APIs de Automação Office. Entre as melhorias estão a utilização do dynamic tipo, e de argumentos nomeados e opcionais.

Muitos métodos com COM permitem a variação dos tipos de argumentos e do tipo de retorno, designando os tipos como object. Isto exigiu uma fundição explícita dos valores para coordenar com variáveis fortemente dactilografadas em C#. Se compilar utilizando a opção EmbedInteropTypes (Opções de Compiler C# ), a introdução do dynamic tipo permite-lhe tratar as ocorrências de object assinaturas COM como se fossem do tipo dynamic, evitando assim grande parte do casting. Por exemplo, as seguintes declarações contrastam com a forma como acede a uma célula numa folha de cálculo Microsoft Office Excel com o dynamic tipo e sem o dynamic tipo.

// 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ítulo Descrição
dynamic Descreve o uso da dynamic palavra-chave.
Visão geral do tempo de execução da linguagem dinâmica Fornece uma visão geral do DLR, que é um ambiente de tempo de execução que adiciona um conjunto de serviços para línguas dinâmicas ao tempo comum de execução da linguagem (CLR).
Walkthrough: Criar e utilizar objetos dinâmicos Fornece instruções passo a passo para criar um objeto dinâmico personalizado e para criar um projeto que acede a uma IronPython biblioteca.
Como aceder a objetos de interop Office utilizando funcionalidades C# Demonstra como criar um projeto que usa argumentos nomeados e opcionais, o dynamic tipo e outras melhorias que simplificam o acesso a objetos Office API.