È disponibile una ricerca sulla manutenibilità del paradigma "guardia" rispetto al paradigma "uscita singola"?

Question

Mi chiedo se ci sia stata qualche ricerca (sia casuale che robusta) sulla manutenibilità di progetti che usano il paradigma della "dichiarazione di sicurezza" rispetto al paradigma "exit point a singola funzione"?

Guardia esempio economico (in C#):

string GetSomeString() 
{ 
    if(necessaryConditionFails) { return null; } 
    if(!FunctionWithBoolReturn(someAttribute)) { return null; } 
    //all necessary conditions have been met 
    //do regular processing... 
    return finalStringValue; 
} 

solo esempio punto funzione exit (in C#):

string GetSomeString() 
{ 
    string valueToReturn = null; 
    if(necessaryConditionPasses && FunctionWithBoolReturn(someAttribute)) 
    { 
     //all necessary conditions have been met 
     //do regular processing... 
     valueToReturn = finalStringValue; 
    } 
    return valueToReturn; 
} 

so i meriti e le mancanze di entrambi sono stati dibattuto all'infinito su SO , ma sto cercando un'effettiva ricerca sul modo in cui è possibile mantenere ogni paradigma *. Questo potrebbe essere sconosciuto, ma ho pensato che se le informazioni fossero là fuori, qualcuno su SO avrebbe saputo dov'era. Le mie ricerche sul Web non sono state finora riuscite.

** Sono anche consapevole del fatto che molti programmatori (incluso me) utilizzano entrambi i principi in tutto il codice, a seconda della situazione. Spero solo di scoprire quale ha una comprovata esperienza di maggiore manutenibilità da utilizzare come paradigma preferito. *

Answer 1

Forcing per avere punti di uscita singoli hanno alcuni problemi.

Il primo è che può portare a costruzioni complesse. Immagine una funzione in cui devi aprire un file, leggere una riga, convertire la linea in un numero e restituire quel numero o zero se qualcosa va storto. Con un singolo punto di uscita, si finisce per usare un sacco di if annidati (se il file esiste aperto, se aperto riesce a leggere la riga, se letto riesce a convertire il valore in un intero), il che rende il codice illeggibile. Alcuni di questi possono essere risolti avendo un'etichetta alla fine della funzione e usando goto (dovevamo usarlo in passato poiché usavamo anche il punto di uscita singolo e la leggibilità preferita) ma non è l'ideale.

In secondo luogo, se si utilizzano eccezioni, si è costretti a catturare tutto se si desidera nuovamente il punto di uscita singolo.

Quindi, personalmente, preferisco inserire molti controlli (e asserzioni) all'inizio e durante l'esecuzione della funzione, e uscire dalla funzione al primo segno di difficoltà.