Código marco robusto?

Question

Me gusta escribir código que hace que mi software más sólida. Esto es algo que el marco debería haber hecho! Por lo tanto, es consciente de que nadie un código de "mejorar" utilidad que solidifica el código?

Si tuviera que crear algo como esto por mí mismo, que funcionaría de la siguiente manera: Cuando se está compilando el código con una bandera de depuración, lo haría de auto-mágicamente añadir código de "solidificación" para cada método:

Deformar el código con un try-catch y poner un Debug.Assert (verdadero) en la captura (de modo que las excepciones son capturadas en su origen).

Registro de entrada, impresión "ToString ()" de cada método de valores de argumentos, por lo que puede rastrear lo que está pasando.

Compruebe cada argumento para nulo.

Utilice un marco "IsValid" para comprobar el propio objeto y cada argumento, donde IsValid () es la forma del objeto de declarar que sus expectativas son verdaderas (por ejemplo, si yo soy un TableOfContentsEntry espero estar siempre en una libro que es IsValid () y para apuntar a una página que está IsValid ().

Así que, ¿por qué no?

Answer 1

Si desea registrar las llamadas de método, se puede utilizar un marco AOP como PostSharp . Cosas como la aplicación de método de pre / post-condiciones se lograrían mejor uso de los mecanismos de diseño por contrato como el nuevo Code Contracts biblioteca que serán entregados en el .net4.0. Sin duda, no tiene sentido sólo comprobar los argumentos a favor nula ya que esto puede ser un valor válido en función del método. Inyectables Debug.Asserts en código podría ser problemático, ya que es posible que no quiere / ser capaz de manejar excepciones en función de la fuente. Creo que sería poco práctico, si no imposible, para crear un marco genérico para este tipo de cosas ya que los requisitos serán tan diferentes entre los proyectos.

EDIT: Para aclarar mi comentario sobre la adición de las afirmaciones de depuración en métodos - He leído su propuesta sea para convertir un cuerpo de método en algo como esto:

public void SomeMethod(args)
{
    try
    {
        //original method body
    }
    catch(Exception ex)
    {
        Debug.Assert(false);
        throw;
    }
}

El problema con esto es que Asserts indican cosas que nunca debe ser falsa - por lo que esta construcción significa que el método no puede tirar lo cual no es cierto en general. El problema ahora es que si el método no tirar, la afirmación se producirá un error incluso si el método de llamada controla la excepción adecuadamente. Desde su comentario parece que usted está haciendo algo como esto:

public void SomeMethod(object arg)
{
    Debug.Assert(arg != null);
    if(arg == null) throw new ArgumentNullException("arg");

    //rest of method
}

Esta es una práctica útil, y yo creo que el código contrae 'legado' condición previa de la biblioteca soporta la comprobación (excepciones que lanzan) en su análisis estático.

Answer 2

Es agradable ver mi libro está enchufado! El gran problema para mí es que creo que la generación de código debe aspirar a ser "al lado de" código del desarrollador - es decir. Lo ideal sería que el código generado no se entremezcla con el código del desarrollador. Me pregunto si hay alguna forma de añadir el código 'solidfying' como una clase parcial o como un proxy que fijaría entre la clase y el cliente que se llama ella? Por supuesto, es ciertamente posible para generar el código e insertarlo en el código del desarrollador, pero te gustaría crear algún tipo de convención de modo que cuando el desarrollador hace un cambio y regenera el código "soldifying", la herramienta podría eliminar el viejo código y generar nuevo código basado en la última versión del código del desarrollador.

Answer 3

Me encantaría algo que no pierde su pila cuando se pasa algo fuera de un subproceso de trabajo. Ni siquiera sé de una solución para este (C #). Sería bueno saber la pila del padre hilo hasta el punto en que fue creado el subproceso de trabajo.

En general creo que tendría que ser incorporado en un lenguaje mucho las cosas realmente útil y en realidad no puede ser alcanzado limpiamente por una biblioteca o marco solo. Recuerdo que en la escuela se les enseña a escribir siempre en condiciones de pre / post en los comentarios para una función, pero lo que realmente me gustaría ver es la escritura condiciones pre / post que se comprueban si es posible en tiempo de compilación, si no, por lo tiempo de ejecución. Habían ser marcados de alguna manera tal que un editor, opcionalmente, puede mostrar u ocultar ellos por lo que no se interpone en el camino de la lectura del código real.

Answer 4

dudo que haya algo así y si, a continuación, seguro que no es tan utilizable. Depende de sus definiciones reglas, diferentes personas piensan diferentes, tienen diferentes necesidades y marcos ... Las cosas que usted describió podrían lograrse metaprogramming o algún sistema de macro. En Java, hay algunos proyectos que podrían ayudar a implementar un enfoque anotaciones tales usign, no sé si hay algún equivalente en C # universo. La funcionalidad isValid () sin embargo ve más o menos como el diseño por contrato idea, tal vez hay algunos marcos para ello.