Imagem da Nebulosa de Orion, de cor roxa e rosada

O que é o tipo dynamic?

Trabalhando com alguns projetinhos pessoais, encontrei em diversos locais a sugestão de usar um tal de tipo dinâmico no C#, para recuperar resultados de APIs, por exemplo. Como boa fã de tipagem forte, não botei muita fé, mas acabei usando na resolução de um problema e confesso que, agora, estudando melhor para fazer esse post, até que vi vantagem. No meu post anterior, a última parte de um tutorial sobre Twitter API e C#, eu prometi escrever mais sobre ele, com mais detalhes e embasamento. E aqui está: afinal de contas, o que é o tipo dynamic, no C#?

Uma garotinha loira, de maria chiquinhas, chacoalhando a cabeça com os braços levantados.
Onde vive? Do que se alimenta? Hoje, no Olivia Repórter!

First things first…

O “tipo” dinâmico não é exatamente um tipo. Ele é uma palavra-chave no C# que determina uma forma diferente de fazer dispatch, que nada mais é que a escolha do que será chamado de fato.

Confuso, né? Calma, vou tentar melhorar:

O que acontece de fato é o seguinte: quando você declara uma variável dinâmica, você está dizendo para o compilador “associe um tipo para essa variável durante o tempo de execução”. Ou seja, ela vai ter um tipo definido, porém só quando o programa estiver executando. Inclusive, o tipo de uma variável dynamic pode mudar em tempo de execução.

Dada toda essa explicação, eu vou continuar chamando o tipo dinâmico de tipo porque acho que é mais fácil associá-lo a isso durante a explicação (e para o bem do SEO desse post 😅). Mas lembrem-se dessa explicação mais teórica, OK?

O que é tipo dynamic, afinal das contas?

O tipo dinâmico nasceu no C# 4 e funciona como se tivesse o tipo object. Em tempo de compilação, o compilador supõe que um elemento que tem o tipo dynamic dá suporte a qualquer operação. Ou seja, e creio que é uma das coisas mais importantes quando se fala desse tipo: se o código não for válido, os erros serão capturados em tempo de execução. Por isso é muito importante que, quando você estiver usando o tipo dynamic, você saiba com precisão a definição e/ou os elementos que você está utilizando.

Um pai segurando uma criança que, quando espirra, pega fogo, solta raios e um raio laser pelos olhos.
O Zezé, dos Incríveis, é um bebê do tipo dinâmico!

Pode parecer que o compilador não tem importância nesse rolê, mas tem sim: quando temos tipos dynamic no nosso código, o compilador é responsável por empacotar informações sobre o que cada declaração está propondo fazer com o objeto declarado. Quando a aplicação estiver rodando, a informação empacotada é examinada e cada declaração inválida vai gerar uma exceção em tempo de execução.

Resultados e conversões do tipo dynamic

O resultado da maioria das operações com o tipo dynamic também é dynamic, exceto:

  • Conversões de dynamic para outros tipos
  • Chamadas de construtores que incluam argumentos de tipo dynamic
var testInstance = new ExampleClass(parametroDinamico);
/* A variável testInstance é do tipo ExampleClass, mesmo que o parâmetro do construtor da classe seja do tipo dynamic */

Qualquer objeto pode ser convertido implicitamente para dynamic e o inverso também é possível.

/* Todas as conversões abaixo funcionam direitinho*/
dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

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

Relacionado às conversões do tipo dynamic, também é bom saber que as resoluções de sobrecarga também ocorrem em tempo de execução quando o usamos.

/* Método de exemplo*/
public static void MetodoExemplo(string nome) { }

/* Sucesso em tempo de execução */
dynamic d1 = "string";
MetodoExemplo(d1);

/* Erro em tempo de execução, apesar de "passar" pelo navegador */
dynamic d2 = 1;
MetodoExemplo(d2);

O que o tal de DLR tem a ver com a história?

DLR é a sigla de Dynamic Language Runtime, que nada mais é que a API que dá suporte ao tipo dinâmico. É um ambiente de runtime que adiciona um conjunto de serviços à CLR (Common Language Runtime).

Foi adicionada no .NET Framework 4 e é graças a ela que podemos usar essa belezinha de tipo dinâmico.

Diferença entre object, var e dynamic

Confesso que, quando eu estava estudando para esse post, essa foi a dúvida que mais ficou na minha cabeça. Afinal de contas, qual é a grande diferença entre essas três palavrinhas reservadas do C#? Encontrei uma resposta maravilhosa sobre isso no StackOverflow (devidamente linkado na seção de fontes ali embaixo) e trago aqui pra vocês:

object

O tipo object vem da classe System.Object, que é base para todos os tipos do C#, tantos os tipos de referência (string) quanto os tipos de valor (int). É um tipo que permite que se associe qualquer tipo de dados à ele: se for uma classe, por exemplo, vai acontecer uma atribuição simples à variável; caso seja um tipo-valor, como int, por exemplo, vai acontecer um boxing seguido de uma atribuição (o compilador vai “converter” o valor para int e depois vai atribuí-lo ao object). O tipo object também permite tratamento para tipos nullable.

object x = 1; // vai ocorrer boxing do valor 1, pois Int32 é um value-type
object y = "str"; // não vai haver boxing, pois String é uma reference-type

int? i = null;
int? j = 10;
object z1 = i; // z1 será null
object z2 = j; // z2 terá um Int32 com o valor 10 boxed e atribuido à variável

var

O var nada mais é do que uma palavra chave para uma inferência de tipo. O compilador vai precisar “adivinhar” o tipo da variável na hora de compilar.

var x = 1;
var y = "str";
var z = new Objeto();

/* O compilador traduzirá as variáveis acima para: */

Int32 x = 1;
String y = "str";
Objeto z = new Objeto();

dynamic

O dynamic permite chamar métodos e propriedades de um objeto sem que o compilador saiba quais são seus tipos, numa técnica conhecida como late-binding; ou seja, só vai haver a associação da chamada ao método/propriedade quando a chamada em questão for feita em tempo de execução.

Há alguns programadores que argumentam que pode haver perda de performance com o uso do tipo dynamic, porém, de acordo com a fonte já citada, as chamadas sobre o dynamic são muito eficientes, sendo “lentas” somente da primeira vez para cada tipo.

Conclusão: tipagem fraca também é possível no C#!

Dito tudo isso, cabe a você decidir quando é o melhor momento para usar tipagem forte ou fraca dentro do C#. Eu, pessoalmente, não sou muito fã da tipagem fraca, mas confesso que depois de ter estudado um pouco melhor, consigo ver algumas facilidades em usar essa outra abordagem em algumas situações. Espero que esse artigo tenha te ajudado a entender melhor o que é o tipo dynamic, quais podem ser suas aplicações e a história por trás dele.

Curtiu? Prefere qual tipo de tipagem? Vai usar o dynamic pra tudo agora? 😅 Me conta!

Um minion digitando em um teclado e olhando para um monitor

📚 Fontes e referências

Using type dynamic (C# Programming Guide) – Microsoft

C# – Tipos dinâmicos – Macoratti.Net

Diferença entre object, dynamic e var – por Miguel Angelo, via Stack Overflow


📜 Posts relacionados

Twitter API e C#: um tutorial – parte 3


💌 Recadinhos

Gostou do texto? Tem algo a adicionar? Alguma crítica construtiva? Feedbacks? Sugestões? Pedidos? Fique à vontade para me contatar via email (oli.pmatt@gmail.com), via Twitter (@oliviamattiazzo) ou pela caixa de comentários aqui embaixo! Vai ser um prazer conversar contigo! ✨

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.