Deficiências do uso de tipos dinâmicos em C #

Estive recentemente estudando mais sobre os tipos dinâmicos em c #. Com alguns exemplos que entendi quando 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 .

Questão,

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

A principal falha é que você joga fora uma das principais propriedades (não necessariamente vantagens) do C # - que é estaticamente tipada (e na maior parte do tipo é segura).

O problema com a digitação dinâmica é que muitas vezes oculta erros que seriam revelados durante a compilação. Esse bug se manifesta apenas no tempo de execução, o que, obviamente, dificulta a detecção.

Existem muito poucas razões para usar a digitação dinâmica em C # da IMO, a principal delas é a colaboração com linguagens de tipo dinâmico (que é AFAIK, a razão pela qual a dinâmica foi introduzida em primeiro lugar).

Se você deseja fazer uma programação totalmente dinâmica, digite alguma linguagem projetada para ser dinâmica, e não faça com que o C # seja dinâmico. Você pode usar, por exemplo, o IronPython, se quiser usar as bibliotecas .Net

Não tenho certeza de que tipo de deficiências você está procurando, mas se quiser saber sobre os recursos que funcionam com a digitação estática, mas não com dynamic, existem alguns:

1. Métodos de extensões não funcionam. Este é provavelmente o maior. Se você tiver dynamic collection, não poderá usar código como collection.Distinct(). Isso ocorre porque os métodos de extensão disponíveis dependem do espaço para nomeusing o DLR não tem como conhecê-los.

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

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

O problema com os tipos dinâmicos (não variáveis ​​declaradas como dinâmicas) no .net é que eles não têm muita funcionalidade disponível para os tipos estáticos.

• não há reflexão (você pode interagir com os membros, mas não muito mais)
• sem metadados (a validação é feita nos sites de dados dinâmicos / mvc)
• absolutamente nenhuma verificação no tempo de compilação (nenhum erro de ortografia será detectado)
• já que esse é um recurso poderoso, os noobs tendem a abusar / abusar / interpretar mal
• código escrito com tipos dinâmicos tende a ser difícil de manter e muito difícil de refatorar
• por causa da digitação do pato e outros recursos, os gurus podem escrever um 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.

Uma vez que dynamicé apenas uma marcaobject ele tipos de valor.

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

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