¿Por qué el mundo .Net parece adoptar cadenas mágicas en lugar de alternativas tipeadas estáticamente?

47

Entonces, trabajo en .Net. Realizo proyectos de código abierto en .Net. Uno de mis mayores problemas no es necesariamente con .Net, sino con la comunidad y los marcos que lo rodean. Parece en todas partes que los esquemas y cadenas de nombres mágicos se tratan como la mejor manera de hacer todo. Declaración en negrita, pero míralo:

ASP.Net MVC:

Hola ruta mundial:

        routes.MapRoute(
            "Default",                                              // Route name
            "{controller}/{action}/{id}",                           // URL with parameters
            new { controller = "Home", action = "Index", id = "" }  // Parameter defaults
        );

Lo que esto significa es que ASP.Net MVC buscará de alguna manera HomeControlleren su código. De alguna manera, cree una nueva instancia y luego llame a la función Index aparentemente con un idparámetro de algún tipo. Y luego hay otras cosas como:

RenderView("Categories", categories);
...or..
ViewData["Foobar"]="meh";

Y luego hay cosas similares con XAML también. DataContextse trata como un objeto y tienes que esperar y rezar para que se resuelva del tipo que deseas. DependencyProperties debe usar cadenas mágicas y convenciones de nombres mágicos. Y cosas como esta:

  MyData myDataObject = new MyData(DateTime.Now);      
  Binding myBinding = new Binding("MyDataProperty");
  myBinding.Source = myDataObject;

Aunque se basa más en el lanzamiento y en varios soportes mágicos de tiempo de ejecución.

De todos modos, digo todo eso para terminar aquí: ¿Por qué esto es tan bien tolerado en el mundo .Net? ¿No estamos usando lenguajes estáticamente escritos para saber casi siempre qué tipo de cosas son? ¿Por qué se prefiere tanto la reflexión y el tipo / método / propiedad / cualquier nombre (como cadenas) en comparación con los genéricos y los delegados o incluso la generación de código?

¿Hay razones heredadas que me faltan por qué la sintaxis de enrutamiento de ASP.Net se basa casi exclusivamente en la reflexión para resolver realmente cómo manejar una ruta? Odio cuando cambio el nombre de un método o propiedad y de repente las cosas se rompen, pero no parece haber ninguna referencia a ese método o propiedad y, por supuesto, no hay errores de compilación. ¿Por qué la aparente conveniencia de las cuerdas mágicas se considera "vale la pena"?

Sé que también hay alternativas comúnmente escritas estáticamente para algunas cosas, pero por lo general pasan a segundo plano y parecen nunca estar en tutoriales u otro material para principiantes.

Earlz
fuente
14
El dinamismo sin sentido ha estado de moda desde que nuestras CPU fueron lo suficientemente rápidas para ejecutarlo.
DeadMG
77
¿Cómo es eso? No he visto ningún ejemplo con LINQ.
DeadMG
66
Mi humilde suposición es que la alternativa tipeada estáticamente es demasiado inconveniente. Ese es un tema que aparece mucho con la mayoría de los sistemas de tipos realmente: "Nos gustaría hacer esto en el sistema de tipos, pero no es lo suficientemente expresivo". (O lo contrario: "Expresamos esto con éxito en el sistema de tipos, pero hizo las cosas tres veces más complejas"). @ GlenH7 No estoy muy familiarizado con todo LINQ, pero los bits que he usado no muestran cualquier cosa, incluso cerca de lo que describe esta publicación. ¿Te importa dar un ejemplo?
2
@Earlz Más importante aún, los objetos anónimos se escriben estáticamente. No hay cadenas mágicas, el compilador conoce el nombre y el tipo de todo lo relacionado. Ahorre para cualquier otro uso de var.
1
@Earlz es interesante, aunque uno podría argumentar que la sintaxis lambda es la hinchazón adicional aquí. Supongo que siguieron el enfoque de la cadena mágica / convención porque es muy simple, "lo suficientemente bueno" para muchos, y siempre pueden adaptar las herramientas para brindar orientación / seguridad. Es una compensación entre seguridad y conveniencia, en mi humilde opinión. El uso de un ViewBag dinámico también insinúa esta mentalidad (no es que esté totalmente de acuerdo con ella).
Daniel B

Respuestas:

31

En realidad, hay un retroceso en el mundo .NET contra estas mismas cosas que mencionaste. Sin embargo, en el primer ejemplo que dio, el motor de enrutamiento recibe una convención para mapear la ruta predeterminada. El hecho mismo de que las rutas sean dinámicas hace casi imposible usar una configuración estática.

También mencionas XAML / WPF, que estaban en desarrollo mucho antes de que los genéricos se introdujeran en .NET y volver a admitir los genéricos habría retrasado aún más un producto que ya era muy tardío (Longhorn / Vista).

Hay ejemplos dentro del marco ASP.NET MVC de usar expresiones lambda en lugar de cadenas mágicas y Entity Framework / LINQ lo lleva aún más lejos donde el lenguaje y el marco proporcionan soporte nativo para componer consultas SQL sobre un gráfico de objeto estático (en lugar de construir cadenas mágicas de SQL, obtiene la validación en tiempo de compilación de sus consultas).

Para otros ejemplos de configuración estática, vea el mapa de estructura y otros contenedores modernos de inyección de dependencias, y otros marcos que necesitan inspeccionar el gráfico de objetos en tiempo de ejecución, pero permiten al desarrollador proporcionar pistas estáticamente utilizando expresiones lambda.

Entonces, la respuesta corta es que, históricamente, .NET no admitía el recorrido estático de un gráfico de objeto hasta la versión 3.5. Ahora que lo tenemos, muchos desarrolladores lo prefieren a las cadenas mágicas y muchos han estado presionando por un soporte aún más profundo, como un operador symbolOf que funciona de manera similar al operador typeOf.

Michael Brown
fuente
3
XAML es detallado como lo es ... agregar soporte para genéricos lo haría aún más (sí, sé que todo el XAML no está hecho para humanos). Además, veo XAML como más parecido a HTML que un lenguaje de programación real. No debería importarle el tipo de objetos que muestra, sino cómo mostrarlo.
Michael Brown
2
Los genéricos llegaron en 2.0, pero no obtuvimos Expresiones hasta 3.5 (con LINQ). Las expresiones son el poder que LINQ y la comunidad han tomado ese poder y corren con él. La técnica se conoce como reflexión estática
Michael Brown
1
Buen punto sobre la reflexión estática. Olvidé que se introdujera en 3.5
Earlz
2
Esta es una gran respuesta y definitivamente estoy de acuerdo con el rechazo. Evito todas estas cosas como la peste porque si hay un error tipográfico o un error, solo se detectan en el tiempo de ejecución, lo que significa que se pueden pasar por alto fácilmente. También hacen que la refactorización sea extremadamente diferente. Evitar evitar evitar!
Rocklan
2
De acuerdo sobre el retroceso. T4MVC es un proyecto que viene a la mente que aspira a eliminar muchas cadenas y reemplazarlas con código fuertemente tipado.
Carson63000