generate - remarks c#
C#4: Ejemplo del mundo real de tipos dinámicos (6)
Creo que tengo mi cerebro a medias alrededor del concepto de Tipos Dinámicos en C # 4, pero no puedo, por mi vida, descubrir un escenario en el que realmente quisiera usarlo.
Estoy seguro de que hay muchos, pero simplemente estoy teniendo problemas para establecer una conexión en cuanto a cómo podría diseñar una solución que se resuelva mejor con dinámicas en lugar de interfaces, inyección de dependencias, etc.
Entonces, ¿cuál es un escenario de aplicación en el mundo real donde el uso de tipo dinámico es apropiado?
Creo que otros han dado algunas respuestas geniales hasta ahora, así que solo quiero agregar este ejemplo de David Hanson. Hist post muestra la aplicación más práctica que he encontrado hasta ahora para los tipos dinámicos en C # donde los usa para crear objetos proxy. En este ejemplo, crea un proxy que permite generar excepciones en los errores de enlace de WPF. No estoy seguro de si esto también podría lograrse en el caso de los enlaces WPF mediante el uso de CustomTypeDescriptors y los conceptos del descriptor de propiedades en general, pero independientemente del uso del nuevo tipo dinámico C # 4.0 es una gran demostración de sus capacidades.
Generando excepciones vinculantes en WPF y Silverlight con .net 4.0 Dynamics
Otro uso que se me ocurre para los tipos dinámicos es crear proxies que, de manera similar, se pueden conectar como DataContext en WPF o en otros lugares donde se espera un tipo de objeto genérico y los métodos de reflexión normalmente se usan para interrogar al tipo. En estos casos, especialmente cuando se crean pruebas, se puede usar un tipo dinámico que luego permitiría que los objetos de acceso de propiedad sean llamados y registrados por el objeto proxy de manera dinámica sin tener que codificar las propiedades dentro de una clase de solo prueba.
Del blog de Walter Almeida: un escenario de uso de la palabra clave dinámica en C # para mejorar la orientación a objetos:
Hay un ejemplo en MSDN :
Muchos métodos COM permiten la variación en los tipos de argumento y el tipo de retorno al designar los tipos como objeto. Esto ha requerido la conversión explícita de los valores para coordinar con variables fuertemente tipadas en C #. Si compila utilizando la opción / link (Opciones de compilador de C #), la introducción del tipo dinámico le permite tratar las ocurrencias de objetos en firmas COM como si fueran de tipo dinámico y, por lo tanto, evitar gran parte de la conversión.
Otro ejemplo es si tienes que interoperar con lenguajes dinámicos.
También hay ocasiones en las que desea generar un código genérico, pero no puede porque, aunque los objetos implementan el mismo método, no comparten una interfaz o clase base adecuada que declare los métodos que necesita. Un ejemplo de esto es tratar de hacer algo genérico con ints y cortos. Es un poco difícil, pero dinámico te permite llamar a los mismos métodos en estos diferentes tipos, lo que permite más reutilización de código.
Actualización: un poco de búsqueda aquí encontró esta publicación relacionada .
Leí un artículo interesante sobre esto (adjunto) por Scott Hanselman. Señala que, a diferencia del uso de objetos, puede usar la dinámica para hacer referencia a métodos de objetos COM más antiguos en los que el compilador no sabe que existe un método. He encontrado el enlace útil.
Scott Watermasysk escribió un artículo sobre el uso de la dinámica para el mapeo de propiedades clave del diccionario en el controlador C # de MongoDB.
Hay muchos casos en los que ya está utilizando la tipificación dinámica y el enlace dinámico en la actualidad . Simplemente no te das cuenta, porque todo está oculto detrás de cadenas o System.Object , ya que hasta C # 4, el soporte necesario no estaba allí.
Un ejemplo es la interoperabilidad COM: COM es en realidad un sistema de objetos semi-dinámico. Cuando hace interoperabilidad COM, muchos métodos devuelven un objeto dinámico, pero como C # no los admitió, fueron devueltos como System.Object y tuvo que System.Object usted mismo, posiblemente detectando excepciones en el camino.
Otro ejemplo es la interacción con datos tipificados dinámicamente (o incluso no tipificados), como JSON, CSV, HTML, XML sin esquemas, servicios web sin esquemas, bases de datos sin esquemas (que son, después de todo, el nuevo hotness). Hoy, usas cuerdas para esos. Una API XML se vería como
var doc = new XmlDocument("/path/to/file.xml");
var baz = doc.GetElement("foo").GetElement("qux");
y así. Pero ¿qué hay de
dynamic doc = new XmlDocument("/path/to/file.xml");
var baz = doc.foo.qux;
¿No se ve bien?
Un tercer ejemplo es la reflexión. Hoy en día, la invocación de un método a través de la reflexión se realiza pasando una cadena a InvokeMember (o como se llame). ¿No sería mejor, ya sabes, simplemente invocar la maldita cosa?
Luego, hay generación de datos dinámicos (básicamente lo opuesto al segundo ejemplo). Aquí hay un ejemplo de cómo generar un XML dinámico:
dynamic doc = new XmlBuilder();
doc.articles(id=42, type="List", () => {
article(() => {
number(42);
title("blahblubb");});});
Esto no es tan hermoso como el equivalente de Ruby, pero es lo mejor que se me ocurre en tan poco tiempo :-)
Y por último, pero no menos importante, la integración con un lenguaje de tipo dinámico. Ya sea que se trate de JavaScript en una aplicación de Silverlight, un motor de reglas personalizadas incrustado en su aplicación de negocios o una instancia de DLR que aloje en su programa CAD / IDE / editor de texto.