O tipo dinâmico

No C # versão 4.0, a Microsoft introduziu um novo tipo: a dinâmica. Na verdade, é um tipo estático, mas, ao contrário de outros tipos estáticos, os membros (potenciais) de um objeto dinâmico não são verificados pelo compilador. Isso lhe dará algumas das vantagens das linguagens dinamicamente tipadas, mantendo as vantagens de um linguagem fortemente tipada em todos os outros casos.

Declarar uma dinâmica é como declarar qualquer outro tipo - simplesmente use a palavra-chave dinâmica em vez do tipo de dados:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;

Agora você tem três objetos diferentes - o primeiro é realmente nada neste ponto (nulo), enquanto o segundo é uma string e o terceiro é um inteiro. O interpretador decidirá automaticamente em tempo de execução, com base no que você atribui às variáveis. Isso também significa que o compilador não irá verificar o que você faz com essas variáveis, conforme ilustrado no próximo exemplo:

dynamic d1;
dynamic d2 = "A string";
dynamic d3 = 42;
Console.WriteLine(d2.Length);
Console.WriteLine(d3.Length);

Strings têm uma propriedade length, para decidir quanto tempo a string é, mas não um inteiro. Nesse caso, tento usar essa propriedade nas duas variáveis, e o compilador não vai reclamar sobre isso - se essas variáveis tivessem sido declaradas como uma string e um inteiro, o compilador teria interceptado. Mas desde que os tipos são dinâmicos, apenas compila e executa. No entanto, assim que o intérprete alcançar a última linha, uma exceção será lançada, porque obviamente você não pode acessar uma propriedade que não existe.

Isso também mostra o perigo dos tipos dinâmicos - você tem que estar ciente do que está fazendo e certificar-se de que você soletre cada propriedade e chamada de método corretamente, porque o compilador não irá checar seu trabalho, basicamente permitindo que você publique. código que falha toda vez.

Um objeto dinâmico

A palavra-chave dinâmica pode, é claro, ser usada para tipos mais complexos que inteiros e strings. Um ótimo exemplo disso é quando é usado para manter um objeto anônimo, assim:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.Name + " is " + user.Age + " years old");

Isso permite que você crie um objeto sem definir uma classe para ele primeiro. A palavra-chave dinâmica pode ser usada para segurá-la, mas também a palavra-chave var , que pode ser mais adequada em muitas situações.

Você pode pensar que, como o tipo é dinâmico, você pode simplesmente adicionar propriedades a ele mais tarde, desta forma:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
user.HomeTown = "New York";

Como nenhuma verificação em tempo de compilação é feita em um tipo dinâmico, esse código é executado, porque o compilador não valida a existência da propriedade HomeTown , mas assim que a última linha é alcançada, uma exceção será lançada. Enquanto um tipo dinâmico é muito dinâmico, ele não permite que você adicione dinamicamente novas propriedades a ele. Para isso, você pode usar um ExpandoObject, que discutiremos no próximo artigo.

Tipo de mudança

Uma variável declarada como dinâmica não é nada tipificada. Em vez disso, o C # tratará internamente como qualquer tipo de objeto que você tenha designado para ele. Em nosso primeiro exemplo, você verá como podemos declarar uma variável como dinâmica, atribuir uma string ou um inteiro a ela e começar a usar propriedades pertencentes a esses tipos. Você pode, no entanto, alterar facilmente o tipo de uma variável dinâmica - basta atribuir um novo valor a ela. Aqui está um exemplo:

dynamic user = new
{
    Name = "John Doe",
    Age = 42
};
Console.WriteLine(user.GetType() + ": " + user.Name + " is " + user.Age + " years old");
user = "Jane Doe";
Console.WriteLine(user.GetType() + ": String.Length = " + user.Length);

Observe como usamos a variável dinâmica usuário : primeiro ele contém um objeto anônimo e, em seguida, atribuímos uma string simples a ele. Nós o validamos usando o método GetType() encontrado em todos os objetos C # e, em ambos os casos, acessamos as propriedades encontradas no tipo que temos atualmente (propriedades Name/Age do objeto anônimo e a propriedade Length encontrada nos objetos string ).

Resumo

A palavra-chave dinâmica permite usar variáveis que não são específicas do tipo - em vez disso, elas atuam como o tipo de dados que elas contêm. Você pode facilmente atribuir um novo valor a uma variável dinâmica, e se o tipo de valor que você está atribuindo não for o mesmo que o atual, a variável dinâmica simplesmente mudará de tipo automaticamente.

As variáveis dinâmicas não são verificadas pelo compilador, permitindo que você acesse propriedades que podem ou não estar presentes. Isso os torna muito flexíveis, mas também torna seus aplicativos muito mais vulneráveis a erros. Especialmente por esse motivo, talvez você queira restringir o uso das palavras-chave dinâmicas a situações em que não consegue realizar o que deseja sem usá-lo. Exemplos de quando faz sentido usar a palavra-chave dinâmica são para interoperabilidade COM e ao interagir com formatos de dados como JSON e XML.