Deficiencias en el uso de tipos dinámicos en C #

La principal deficiencia es que desecha una de las propiedades principales (no necesariamente las ventajas) de C #: que está tipificada de forma estática (y para la mayoría de los tipos de partes es segura).

El problema con la escritura dinámica es que a menudo oculta errores que de otra manera se revelarían durante la compilación. Dicho error solo se manifiesta en tiempo de ejecución, lo que, por supuesto, hace que sea mucho más difícil de detectar.

Hay IMO muy pocas razones para usar la escritura dinámica en C #, la principal es la colaboración con lenguajes de tipo dinámico ( que es AFAIK, la razón por la que se introdujo la dinámica en primer lugar).

Si desea realizar una programación completamente dinámica, debe mirar un lenguaje diseñado para ser dinámico, no hackear C # para ser dinámico. Puede usar, por ejemplo, IronPython si desea usar las bibliotecas .Net

No estoy seguro de qué tipo de deficiencias está buscando, pero si desea conocer las funciones que funcionan con la escritura estática, pero no con dynamic , hay algunas:

1. Los métodos de extensiones no funcionan. Este es probablemente el más grande. Si tiene dynamic collection , no puede usar código como collection.Distinct() . Esto se debe a que los métodos de extensión disponibles dependen del espacio de nombres using s y el DLR no tiene forma de conocerlos.

   Como solución alternativa, puede invocar el método como si fuera un método estático normal: Enumerable.Distinct(collection) . O puede cambiar el tipo de la colección a algo como IEnumerable<dynamic> .

2. foreach requiere IEnumerable . En C # normal, foreach está basado en patrones. Es decir, no requiere ninguna interfaz específica, solo un método GetEnumerator() que devuelve el objeto adecuado. Si usa foreach en dynamic , se requiere la implementación de IEnumerable . Pero como la razón de este comportamiento es que C # 1.0 no tenía genéricos, esta "deficiencia" es bastante irrelevante.

El problema con tipos dinámicos (no variables declaradas como dinámicas) en .net es que no tienen mucha funcionalidad disponible para los tipos estáticos.

• no hay reflejo (puedes iterar sobre miembros pero no mucho más)
• sin metadatos (ahí va su validación en sitios de datos dinámicos / mvc)
• absolutamente ninguna comprobación en el momento de la compilación (no se detectarán errores de ortografía)
• ya que esta es una característica poderosa, los noobs pueden tender a abusar / usar mal o no entenderla
• el código escrito con tipos dinámicos tiende a ser difícil de mantener y muy difícil de refactorizar
• debido a la escritura de pato y otras características, los gurús pueden escribir código que es ilegible para cualquier otra persona

Así que no escriba código con tipos dinámicos a menos que sepa lo que está haciendo.

Dado que dynamic es solo un object it marca los tipos de valor.

Esto puede tener implicaciones de rendimiento, pero como de todos modos usaría la escritura estática en el código crítico de rendimiento, probablemente no sea un problema en la práctica.

Este boxeo también interfiere con los tipos de valores mutables. Si los modifica con dynamic , solo modifica la copia en caja. Pero como no debería usar tipos de valores mutables en primer lugar, esto tampoco es un gran problema.