Usando o Tipo dinâmico (guia de programação C#)

Visual C# 2010apresenta um novo tipo, dynamic. O tipo é um tipo estático, mas um objeto do tipo dynamic ignora a verificação de tipo estático. Na maioria dos casos, ele funciona como o tipo de object. Em tempo de compilação, um elemento que é digitado como dynamic presume-se para dar suporte à operação. Portanto, você não precisará preocupar-se o objeto obtém seu valor a partir de uma API COM, a partir de uma linguagem dinâmica, como, por exemplo, IronPython, do HTML documento objeto DOM (modelo), de reflexão ou de algum outro lugar no programa. No entanto, se o código não é válido, os erros são interceptados em tempo de execução.

Por exemplo, se método de instância exampleMethod1 no código a seguir tem apenas um parâmetro, o compilador reconhece que a primeira chamada para o método ec.exampleMethod1(10, 4), não é válido porque contém dois argumentos. A chamada faz com que 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, nenhum erro de compilador é relatado. No entanto, o erro não escape aviso indefinidamente. Ele fica preso em tempo de execução e faz com que uma exceção de tempo de execução.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following line causes a compiler error if exampleMethod1 has only
    // one parameter.
    //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 é reúnem informações sobre como fazer para o objeto ou expressão que é digitada como está propondo cada instrução dynamic. Em tempo de execução, as informações armazenadas são examinadas e qualquer instrução que não é válida faz com que uma exceção de tempo de execução.

O resultado de operações mais dinâmicos próprio é dynamic. Por exemplo, se o ponteiro do mouse é posicionado sobre o uso de testSum no exemplo a seguir, IntelliSense exibe o tipo de a testSum dinâmico (variável local).

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 incluem conversões de dynamic para outro tipo e chamadas de construtor, que incluem os argumentos do tipo dynamic. Por exemplo, o tipo de testInstance na seguinte declaração é ExampleClass, e não dynamic.

var testInstance = new ExampleClass(d);

Exemplos de conversão são mostrados na seção a seguir, "Conversões".

Conversões

Conversões entre objetos dinâmicos e outros tipos são fáceis. Isso permite que o desenvolvedor alternar entre o comportamento dinâmico e não dinâmicos.

Qualquer objeto pode ser convertido para o tipo dinâmico implicitamente, conforme mostrado nos exemplos a seguir.

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 para a expressão do tipo dynamic.

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

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

Resolução de sobrecarga ocorre em tempo de execução em vez de em tempo de compilação se uma ou mais argumentos em uma chamada de método têm o tipo de dynamic, ou se o receptor da chamada do método é do tipo dynamic. No exemplo a seguir, se somente acessível por exampleMethod2 método está definido para tirar um argumento de seqüência de caracteres, enviando d1 como o argumento não causa um erro do compilador, mas faz com que uma exceção de tempo de execução. Falha de resolução de sobrecarga em tempo de execução porque o tipo de tempo de execução de d1 é int, e exampleMethod2 requer uma seqüência de 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);

Dynamic Language Runtime

O runtime de linguagem dinâmico (DLR) é uma nova API em .NET Framework 4. Ele fornece a infra-estrutura que suporta a dynamic tipo de C# e também a implementação de linguagens de programação dinâmicas, como o IronPython e IronRuby. Para obter mais informações sobre o DLR, consulte Visão geral de Runtime de linguagem dinâmica.

Interoperabilidade COM

Visual C# 2010inclui vários recursos que aprimoram a experiência de interoperação com APIs de COM, como as APIs de automação do Office. Entre as melhorias estão o uso da dynamic o tipo e de argumentos nomeados e opcionais.

Muitos métodos de COM permitem a variação de tipos de argumento e tipo de retorno, especificando os tipos como object. Isso necessitaram de conversão explícita dos valores para coordenar com variáveis com rigidez de tipos em C#. Se você compilar usando o /link ( Opçõesdo compilador TRANSLATION FROM VPE FOR CSHARP) opção, a introdução da dynamic tipo permite que você trate as ocorrências de object em assinaturas de COM como se fossem do tipo dynamice assim evitar muita elenco. Por exemplo, as seguintes instruções de contrastem de como acessar uma célula em uma planilha do Excel de Microsoft Office com o dynamic tipo e sem a 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ópicos relacionados