quadro codice robusto?

Question

Odio scrivere codice che fa il mio software più solido. Questo è qualcosa che il quadro avrebbe dovuto fare! Quindi, è qualcuno a conoscenza di un codice di "valorizzare" utility che solidifica il codice?

Se ho dovuto creare qualcosa di simile me, che avrebbe funzionato come segue: Quando si sta compilando il codice con una bandiera di debug, sarebbe auto-magicamente aggiungere il codice "solidificazione" per ogni metodo:

Altera il codice con un try-catch e mettere un Debug.Assert (vero) il fermo (in modo che le eccezioni sono intrappolati al loro origine).

voce del registro, la stampa "ToString ()" di ogni metodo di valori di argomenti, in modo da poter rintracciare quello che sta succedendo.

Controlla ogni argomento per nulla.

Utilizzare un quadro "IsValid" per controllare l'oggetto stesso e ogni argomento, in cui IsValid () è senso dell'oggetto di dichiarare che le sue aspettative sono vere (ad esempio, se sono un TableOfContentsEntry mi aspetto di essere sempre in un libro che è IsValid () e per puntare a una pagina che è IsValid ().

Quindi, perché no?

Answer 1

Se si desidera registrare le chiamate di metodo, è possibile utilizzare un framework AOP come PostSharp . Cose come far rispettare metodo pre / postcondizioni sarebbero realizzati meglio mediante meccanismi di progettazione per contratto come il nuovo Code Contracts libreria che sarà disponibile con .net4.0. Certamente non ha senso controllare solo argomenti per nulla dal momento che questo può essere un valore valido a seconda del metodo. Iniettando Debug.Asserts in codice potrebbe essere problematico in quanto è possibile che non si vuole / essere in grado di gestire le eccezioni nella funzione di origine. Penso che sarebbe impraticabile se non impossibile, creare un quadro generico per questo genere di cose dal momento che i requisiti saranno diversi così grandemente tra i progetti.

EDIT: Per chiarire il mio commento circa l'aggiunta di asserzioni di debug in metodi - ho letto la tua proposta di essere per convertire un corpo di un metodo in qualcosa di simile a questo:

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

Il problema di questo è che asserisce indicano le cose che non dovrebbe mai essere falso - così questo costrutto significa che il metodo non può mai buttare il che non è vero in generale. Il problema ora è che se il metodo non gettare, l'asserzione fallirà anche se il metodo di chiamata gestisce l'eccezione in modo appropriato. Dal tuo commento sembra che si sta facendo qualcosa di simile:

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

    //rest of method
}

Questa è una pratica utile, e credo che il codice dei contratti 'Legacy' precondizione supporti biblioteca controllo (eccezioni lancio) nella sua analisi statica.

Answer 2

E 'bello vedere il mio libro sia collegato! Il grande problema per me è che io penso che la generazione di codice dovrebbe mirare ad essere "accanto a" codice dello sviluppatore - cioè. idealmente, il codice generato non sarebbe essere miscelato con il codice dello sviluppatore. Mi chiedo se c'è un modo per aggiungere questo codice 'solidificando' come una classe parziale o come un proxy che avrebbe stabilito tra la classe e il cliente che stava chiamando? Naturalmente, è certamente possibile per generare il codice e inserirlo nel codice dello sviluppatore, ma che ci si vuole creare una sorta di convenzione in modo che quando lo sviluppatore apporta una modifica e rigenera il codice "soldifying", lo strumento potrebbe eliminare il vecchio codice e generare un nuovo codice basato sulla più recente versione del codice dello sviluppatore.

Answer 3

Mi piacerebbe qualcosa che non perde il vostro stack quando si passa qualcosa fuori ad un thread di lavoro. Io non so nemmeno di una soluzione per questo (C #). Sarebbe bello sapere la pila del genitore filo fino al punto in cui è stato creato il thread di lavoro.

In generale credo che un sacco di roba veramente utile dovrebbe essere costruito in un linguaggio e non può davvero essere raggiunto in modo pulito da una biblioteca o di un quadro da solo. Mi ricordo che al liceo hanno insegnato a scrivere sempre in condizioni di pre / post nei commenti di una funzione, ma quello che mi piacerebbe davvero vedere è la scrittura condizioni pre / post che vengono controllati, se possibile, al momento della compilazione, se non allora a runtime. Sarebbero segnalati qualche modo tale che un editore può opzionalmente mostrare o nascondere loro in modo da non ottenere nel modo di lettura del codice vero e proprio.

Answer 4

Dubito che ci sia qualcosa di simile, e se, quindi sicuramente non è quella utilizzabile. Dipende dalle vostre definizioni di regole, diverse persone think different, hanno esigenze diverse e quadri ... Le cose che hai descritto potrebbe essere raggiunto da metaprogrammazione o qualche sistema macro. In Java, ci sono alcuni progetti che potrebbero contribuire a realizzare tale approccio annotazioni usign, non so se c'è qualche equivalente in C # nell'universo. Il () funzionalità isValid però assomiglia molto disegno di idea del contratto, forse ci sono alcuni quadri per questo.