Este artigo foi traduzido por máquina.

Cutting Edge

Usando a palavra-chave dinâmica no C# 4.0

Dino Esposito

Dino Esposito
A introdução de verificação de tipo estático representado uma etapa importante no histórico de linguagens de programação. Na década de 70, idiomas, como Pascal e C iniciado aplicar tipos estáticos e verificação de tipo forte. Com verificação de tipo estático, o compilador produzirá um erro quando qualquer chamada que não consegue passar um argumento de método do tipo apropriado. Da mesma forma, você deve esperar um erro do compilador se você tentar chamar um método ausente em uma instância de tipo.

Outros idiomas frente empurrar a abordagem oposta — verificação de tipos dinâmico — passaram com o passar dos anos. Verificação de tipos dinâmico contradiz a idéia de que o tipo de uma variável deve ser determinado estaticamente no momento da compilação e nunca pode alterar enquanto a variável está no escopo. Observe, entretanto, a verificação de tipos dinâmicos não confere o atacado liberdade para tipos mistos, simulando que são o mesmo. Por exemplo, mesmo com verificação de tipos dinâmico, você ainda não é possível adicionar um valor booleano para um inteiro. A diferença com verificação de tipos dinâmicos é que a verificação ocorre quando o programa é executado em vez de quando ele compila.

Digitado estaticamente ou dinamicamente Typed

O Visual Studio 2010 e translation from VPE for Csharp 4.0 oferecem uma nova palavra-chave, dinâmica, que permite digitar dinâmico na qual tem sido tradicionalmente um idioma digitado estaticamente. No entanto, antes de mergulhar nos aspectos dinâmicos de translation from VPE for Csharp 4.0, é necessário obter algumas terminologias básicas para baixo.

Definir uma variável Let’s como local de armazenamento é restrito aos valores de um tipo específico. Em seguida, especifique let’s quatro propriedades fundamentais de um idioma digitado estaticamente:

  • Cada expressão é de um tipo conhecido em tempo de compilação.
  • As variáveis são restritas a um tipo conhecido em tempo de compilação.
  • O compilador garante que restrições de tipo de atribuições de expressões em variáveis de atendam as restrições de variáveis.
  • Tarefas de análise da semântica, tais como resolução de sobrecarga ocorrem em tempo de compilação e os resultados são gerados no assembly.

Uma linguagem dinâmica possui as propriedades opostas. Nem toda expressão é de um tipo conhecido em tempo de compilação, nem é cada variável. Restrições de armazenamento, se houver, são verificadas no tempo de execução e ignoradas em tempo de compilação. Análise da semântica ocorre apenas em tempo de execução.

Um idioma digitado estaticamente permitem que você tornar dinâmico algumas operações. O operador de conversão existe, portanto você pode tentar uma conversão de tipo como uma operação de tempo de execução. A conversão é parte do código do programa e você pode resumir a semântica expresso pelo operador de conversão como “ dinamicamente verifica a validade dessa conversão em tempo de execução. ”

No entanto, referentes ao atributos como dinâmico e estático (ou talvez fortes e fracos): Hoje em dia são melhor aplicados a recursos individuais de uma linguagem de programação que o idioma como um todo.

Let’s brevemente considere Python e PHP. Ambos são linguagens dinâmicas, permitem que você use variáveis e permitir que o ambiente de tempo de execução descobrir o tipo real armazenado nele. Mas com PHP você pode armazenar, por exemplo, inteiros e seqüências de caracteres na mesma variável no mesmo escopo. Nesse aspecto, PHP (como JavaScript) é uma linguagem dinâmica, sem rigidez de tipos.

Por outro lado, Python oferece apenas uma oportunidade de definir o tipo de uma variável, o que torna mais rigidez de tipos. Dinamicamente, você pode atribuir o tipo a uma variável e ter o tempo de execução inferi-lo do valor atribuído. Depois disso, no entanto, você não está tem permissão para armazenar qualquer valor de um tipo inadequado em dessa variável.

Tipos dinâmicos no translation from VPE for Csharp

Translation from VPE for Csharp 4.0 tem recursos que tornam dinâmicos e estáticos, bem como os sem rigidez e altamente digitado. Embora nascido como um idioma digitado estaticamente, translation from VPE for Csharp torna-se dinamicamente digitados em qualquer contexto em que você usar a palavra-chave dynamic, como este:

dynamic number = 10;
Console.WriteLine(number);

E como dinâmica é uma palavra-chave contextual, não um nome reservado, isso ainda é se você tem variáveis existentes ou métodos chamados dinâmico.

Observe que translation from VPE for Csharp 4.0 não forçar a utilização dinâmica, da mesma maneira que translation from VPE for Csharp 3.0 não forçar a usar var, lambdas ou inicializadores de objeto. Translation from VPE for Csharp 4.0 fornece a nova palavra-chave dinâmica especificamente para facilitar a lidar com alguns cenários bastante conhecidos. A linguagem essencialmente permanecerá digitada estaticamente, mesmo que ele adicionou a capacidade de interagir de forma mais eficaz com objetos dinâmicos.

Por que você deseja usar um objeto dinâmico? Primeiro, você pode não saber o tipo de objeto que você está lidando. Você pode ter pistas mas não a certeza estaticamente digitar uma determinada variável — que é o que acontece em muitas situações comuns, como ao trabalhar com objetos COM, ou quando você usa reflexão para pegar ocorrências. Nesse contexto, a palavra-chave dynamic faz algumas situações menos doloroso lidar com. Código escrito com dinâmico é mais fácil de ler e gravar, para um aplicativo que é mais fácil de entender e manter.

Segundo, o objeto pode ter uma natureza inerentemente mutável. Você pode estar trabalhando com objetos criados em ambientes de programação dinâmicas como, por exemplo, IronPython e IronRuby. Mas você também pode usar essa funcionalidade com objetos HTML DOM (sujeito às propriedades expando) e os objetos do Microsoft .NET Framework 4 especificamente criados para ter natures dinâmicos.

Uso dinâmico

É importante compreender o conceito de que o translation from VPE for Csharp digite system, dinâmico é um tipo. Ele tem um significado muito especial, mas é definitivamente um tipo e é importante para tratá-lo como tal. Você pode indicar dinâmico como o tipo de uma variável declarada, o tipo de itens em uma coleção ou o valor de retorno de um método. Você também pode usar dinâmico como o tipo de um parâmetro de método. Por outro lado, não é possível usar dinâmicos com o operador typeof e você não pode usá-lo como o tipo de uma classe base.

O código a seguir mostra como declarar uma variável no corpo de um método dinâmica:

public void Execute()  { 
  dynamic calc = GetCalculator();
  int result = calc.Sum(1, 1);
}

Se você sabe bastante sobre o tipo de objeto que está sendo retornado pelo método GetCalculator, você pode declarar a variável calc desse tipo ou você pode declarar a variável como var, permitindo que o compilador descobrir os detalhes exatos. Mas usando var ou um tipo explícito estático exigiria a certeza de que um método que Sum existe no contrato exposto pelo tipo que GetCalculator retorna. Se o método não existir, você obterá um erro do compilador.

Com dinâmico, você pode adiar qualquer decisão sobre a correção da expressão em tempo de execução. O código é compilado e é resolvido em tempo de execução, desde que um método Sum está disponível o tipo armazenado em calc. variável

Você também pode usar a palavra-chave para definir uma propriedade em uma classe. Ao fazer isso, você pode decorar o membro com qualquer modificador de visibilidade você que, como público, protegido e até mesmo estático.

Figura 1 mostra a versatilidade da palavra-chave dynamic. O programa principal tenho uma variável dinâmica instanciada com o valor de retorno de chamada de função. Isso seria nenhuma grande problema se ele não foram pelo fato de que a função recebe e retorna um objeto dinâmico. É interessante ver o que acontece quando, como no exemplo, você passa um número e, em seguida, tente clique duas vezes dentro da função.

Figura 1 Uso dinâmico na assinatura de uma função

class Program {
  static void Main(string[] args) {
    // The dynamic variable gets the return 
    // value of a function call and outputs it.
    dynamic x = DoubleIt(2);
    Console.WriteLine(x);

    // Stop and wait
    Console.WriteLine(“Press any key”);
    Console.ReadLine();
  }

  // The function receives and returns a dynamic object 
  private static dynamic DoubleIt(dynamic p) {
    // Attempt to "double" the argument whatever 
    // that happens to produce
    
    return p + p;
  }
}

Se um valor de 2 de alimentação e tente este código, você receberá um valor de 4. Se alimentar 2 como uma seqüência de caracteres, você obterá 22 em vez disso. Dentro da função, a + operador é resolvido dinamicamente com base no tipo de tempo de execução dos operandos. Se você alterar o tipo para System.Object, você obterá um erro de compilação, porque o + operador não está definido em System.Object. A palavra-chave dynamic permite cenários que não eram possíveis sem ele.

dinâmicos vs. System.Object

Até que o .NET Framework 4, tendo um método retornar tipos diferentes de acordo com diferentes condições era possível apenas pela necessidade de uma classe base comum. Provavelmente você já resolveu esse problema pela necessidade de System.Object. Uma função que retorna System.Object torna disponível para o chamador uma instância pode ser convertida em praticamente qualquer coisa. Como está usando melhor do que usar System.Object dinâmico?

Em translation from VPE for Csharp 4, o tipo real por trás da variável declarada dinâmica foi resolvido em tempo de execução e o compilador simplesmente pressupõe que o objeto em uma variável declarada dinâmica apenas oferece suporte a todas as operações. Isso significa que você realmente pode escrever código que chama um método no objeto que você pretende estar lá no momento da execução, conforme ilustrado aqui:

dynamic p = GetSomeReturnValue();
p.DoSomething();

Translation from VPE for Csharp 4.0, o compilador não reclamará sobre esse código. O código análogo usando System.Object não compilar e exige alguns hackers por conta própria — reflexo ou elenco adventurous — para que funcionem.

var vs. dinâmico

As palavras-chave var e dinâmicos só são aparentemente semelhantes. Var indica que o tipo da variável tem a ser definida para o tipo de tempo de compilação do inicializador.

Mas dinâmico significa que o tipo da variável é do tipo dinâmico disponíveis no translation from VPE for Csharp 4.0. No final, dinâmico e var têm significado oposto bastante. Var é sobre reforçando e melhorando a digitação estática. Ele tem como objetivo garantir que o tipo de uma variável é inferido pelo compilador olhando para o tipo exato que estão sendo retornado pelo inicializador.

A palavra-chave dinâmica é sobre como evitar a digitação estática completamente. Quando usado em uma declaração de variável, dinâmico instrui o compilador pare de funcionar sem o tipo da variável em todos os. O tipo deve servir como o tipo acontece para que o tempo de execução. Com var, seu código é como digitado estaticamente, teria sido tinha você tiver optado pela abordagem clássica de uso de tipos explícitos em uma declaração de variável.

Outra diferença entre as duas palavras-chave é que var só pode aparecer dentro de uma declaração de variável local. Var não é possível usar para definir uma propriedade em uma classe, nem pode você usá-lo para especificar o valor de retorno ou parâmetro de uma função.

Como desenvolvedor, você usar que a palavra-chave dynamic com variáveis esperado para conter objetos de tipo incerto como objetos retornados de uma COM ou a API do DOM; obtido de uma linguagem dinâmica (IronRuby, por exemplo); de reflexão; de objetos incorporados dinamicamente translation from VPE for Csharp 4.0 usando o novo expandir recursos.

O tipo dinâmico não ignora verificações de tipo, embora. Ele move apenas eles todo tempo de execução. Se forem descobertas incompatibilidades de tipo em tempo de execução, exceções são lançadas.

Dino Esposito é autor do futuro “ Programming ASP.NET MVC ” da Microsoft Press e co-autor dos livros “ .NET da Microsoft: Arquitetando aplicativos para a empresa ” (Microsoft Press, 2008). Esposito, que se baseia na Itália, é um palestrante sempre presente em eventos do setor no mundo inteiro. Você pode ingressar em seu blog em weblogs.ASP.net/despos.

Graças ao especialista técnico seguir para revisar este artigo:   Eric Lippert