Usar o tipo dinâmico (C# Programming Guide)

Visual C# 2010 apresenta um novo tipo, dynamic.O tipo é um tipo estático, mas um objeto de verificação de tipo estático de desvios de dynamic do tipo.Em a maioria dos casos, ele funciona como ele tem o tipo object.Em tempo de compilação, um elemento que é digitado como dynamic é assumido oferecer suporte a qualquer operação.Portanto, você não tem que se preocupar com o objeto obtém o valor da API de um idioma dinâmico, como IronPython, o modelo de objeto (DOM) de documento HTML, reflexão, ou em outro lugar dentro do programa.Em o entanto, se o código é inválido, os erros são capturados em tempo de execução.

Por exemplo, se o método exampleMethod1 de instância 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 ele 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 é verificado pelo compilador porque o tipo de dynamic_ec é dynamic.Portanto, nenhum erro do compilador é relatado.Em o entanto, o erro não libera o aviso indefinidamente.É capturado 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) { }
}

A função do compilador em este exemplo é empacotar juntos informações sobre o que cada declaração é proposto fazer o objeto ou para a expressão que é digitada como dynamic.Em tempo de execução, as informações armazenadas é examinada, e qualquer instrução que faz com que um seja inválidos a exceção de tempo de execução.

O resultado da maioria das operações dinâmicos é próprias dynamic.Por exemplo, se você posicionar o ponteiro do mouse sobre o uso de testSum no 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);

Operações no qual o resultado não é dynamic incluem conversões de dynamic para outro tipo, e o construtor chama que incluem argumentos de tipo dynamic.Por exemplo, o tipo de testInstance na seguinte declaração é ExampleClass, não dynamic.

var testInstance = new ExampleClass(d);

Exemplos de conversão são mostrados na seção, “conversões.”

conversões

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

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

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 dinamicamente pode ser aplicada a qualquer expressão de classificação dynamic.

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

Resolução de sobrecarga com os argumentos de tipo dinâmicos

Resolução de sobrecarregamento ocorre em tempo de execução em vez de em tempo de compilação se um ou mais dos argumentos em um chamada de método tem o tipo dynamic, ou se o receptor da chamada de método é do tipo dynamic.Em o exemplo, se o único método acessível de exampleMethod2 é definido para obter um argumento de cadeia de caracteres, enviar d1 como o argumento não causa um erro do compilador, mas causa uma exceção de tempo de execução.Resolução de sobrecarregamento falha em tempo de execução porque o tipo em tempo de execução d1 é int, e exampleMethod2 requer uma cadeia 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);

Tempo de execução da linguagem dinâmico

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

Interoperabilidade COM

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

Muitos métodos de COM permitem a variação de tipos em e tipo de retorno do argumento designando os tipos como object.Isso necessitou conversão explícita de valores para coordenar com variáveis fortemente tipados em C#.Se você compilar usando a opção de /link (Opções do compilador de C#) , a introdução do tipo de dynamic permite que você manipule as ocorrências de object em assinaturas de COM como se fossem de tipo dynamic, e para evitar essa maneira muito da conversão.Por exemplo, as seguintes declarações contrastam como você acessa uma célula em uma planilha do Microsoft Office Excel com o tipo de dynamic e sem o tipo de dynamic .

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