Falhas de usar tipos dinâmicos em c #

14

Recentemente, estudei mais sobre os tipos dinâmicos em C #. Com alguns exemplos, entendi que uma vez que o código é compilado, ele não precisa ser recompilado novamente, mas pode ser executado diretamente.

Sinto que a flexibilidade fornecida pela palavra-chave para realmente alterar o tipo de dados à vontade é uma grande vantagem .

Pergunta,

Existem quaisquer deficiências específicas além de chamadas incorretas de método dinâmico que lançam exceções de tempo de execução que os desenvolvedores devem conhecer antes de iniciar a implementação.

    
por Karthik Sreenivasan 15.02.2012 / 10:56
fonte

4 respostas

16

A principal falha é que você joga fora uma das propriedades principais (não necessariamente as vantagens) do C # - que é estaticamente digitado (e para a maioria das partes é seguro).

O problema com digitação dinâmica é que muitas vezes esconde bugs que seriam revelados durante a compilação. Tal bug só se manifesta em tempo de execução, o que, é claro, dificulta muito a detecção.

Existem algumas razões para usar a tipagem dinâmica em C #, sendo a principal delas a colaboração com idiomas dinamicamente tipificados ( que é AFAIK, a razão pela qual a dinâmica foi introduzida em primeiro lugar).

Se você quiser fazer programação totalmente dinâmica, você deve olhar para alguma linguagem que é projetada para ser dinâmica, e não para ser dinâmica. Você pode usar, por exemplo, IronPython se quiser usar bibliotecas .Net

    
por 15.02.2012 / 11:44
fonte
9

Não tenho certeza do tipo de falha que você está procurando, mas se você quiser saber sobre recursos que funcionam com a tipagem estática, mas não com dynamic , há poucos:

  1. Os métodos de extensões não funcionam. Este é provavelmente o maior deles. Se você tiver dynamic collection , não poderá usar código como collection.Distinct() . Isso porque os métodos de extensão disponíveis dependem do namespace using s e o DLR não tem como conhecê-los.

    Como solução alternativa, você pode invocar o método como se fosse um método estático normal: Enumerable.Distinct(collection) . Ou você pode alterar o tipo da coleção para algo como IEnumerable<dynamic> .

  2. foreach requer IEnumerable . Em C # normal, foreach é baseado em padrões. Ou seja, não requer nenhuma interface específica, apenas um método GetEnumerator() que retorna um objeto adequado. Se você usar foreach on dynamic , a implementação de IEnumerable será necessária. Mas como a razão para esse comportamento é que o C # 1.0 não tinha genéricos, essa "deficiência" é praticamente irrelevante.

por 15.02.2012 / 13:22
fonte
7

O problema com tipos dinâmicos (não variáveis declaradas como dinâmicas) em .net é que eles não têm muitas funcionalidades disponíveis para tipos estáticos.

  • não há reflexão (você pode iterar sobre os membros, mas não muito mais)
  • sem metadados (lá vai sua validação em sites de dados dinâmicos / mvc)
  • absolutamente nenhuma verificação em tempo de compilação (quaisquer erros ortográficos não serão detectados)
  • , já que esse é um recurso poderoso que os noobs tendem a abusar / usar mal / mal entendido
  • código escrito com tipos dinâmicos tende a ser difícil de manter e muito difícil refatorar
  • por causa da digitação de pato e outros recursos, os gurus podem escrever código ilegível para qualquer outra pessoa

Portanto, não escreva código com tipos dinâmicos, a menos que você saiba o que está fazendo.

    
por 15.02.2012 / 18:48
fonte
6

Como dynamic é apenas um tipo de valor de caixas object marcado.

Isso pode ter implicações no desempenho, mas como eu usaria a tipagem estática no código crítico de desempenho de qualquer forma, isso provavelmente não é um problema na prática.

Esse boxe também interfere nos tipos de valores mutáveis. Se você modificá-las com dynamic , modifique apenas a cópia em caixa. Mas como você não deve usar tipos de valores mutáveis, isso também não é um grande problema.

    
por 15.02.2012 / 17:45
fonte