Ogni volta che sto scrivendo il codice, cancello sempre fuori i miei metodi come questo (non necessariamente usando i generici):
public T MyMethod()
{
T result = default(T); // or null
return result;
}
Questo mi mette sempre nel posto giusto per compilare la logica e assicurarmi di avere una variabile di ritorno da tracciare durante il processo. Dopo averlo fatto abbastanza a lungo ho trovato un modello di sviluppo, e non sono sicuro di quale direzione prendere. Di solito in alcune operazioni relativamente banali:
public bool AddRecord(Record r)
{
bool result = false;
if(_collection != null)
{
_collection.Add(r);
result = true;
}
return result;
}
Per inciso, in genere assegnerei il risultato del callee interno a result ma alcuni metodi (come Add ) non hanno alcun risultato.
Questo metodo, così com'è, va bene. Ma per alcuni sistemi, lo scriverei un po 'diverso.
public bool AddRecord(Record r)
{
bool result = false;
if(_collection == null)
{
_collection = new List<Record>();
}
_collection.Add(r);
result = true;
return result;
}
Ed è qui che rifletto su cosa dovrei fare. Il ritorno sempre di true non fornisce alcun valore all'utente finale, secondo me. Ma poi dico: "Beh, se in futuro questo metodo diventasse più complesso, vorresti cambiare la firma del metodo e far sì che tutti i chiamanti aggiornino la loro reazione a questo? O preferiresti solo return true per ora? " a cui tendo a preferire quest'ultimo, a meno che non sia qualcosa di così banalmente semplice che ho molta fiducia che non cambierà (che, di per sé, ha il 50% di possibilità di sbagliare). Un'altra opzione sarebbe supporre che, sebbene questa logica interna non possa generare una condizione falsa, potrebbe generare un'eccezione. Il mio metodo dovrebbe gestirlo e restituire un flag che indica se è stata lanciata un'eccezione? Pensando a questo, penso:
- Mangiare le eccezioni è male, e a meno che non possa fare qualcosa con le informazioni che mi sono state date, non dovrei farlo e dovrei lasciare che sia il chiamante a gestirle.
- Il chiamante si interessa anche di questa eccezione, o si preoccupano solo se questa operazione è riuscita nel suo insieme?
Questo mi porta a questo stato in cui ho un metodo in cui non sono sicuro di cosa fare, quindi in genere restituisco una costante true e non consumo l'eccezione.
La mia domanda è: Nel caso generale, qual è il modo migliore per avvicinarsi a questo?
Capisco che i casi specifici richiedano una considerazione specifica e, mentre scrivo il mio codice, considero sempre il caso unico presentato da ciascun metodo. Ma quando mi rendo conto che un metodo non è più unico di un altro, vorrei avere qualche idea in più su cosa dovrei fare. Molte grazie in anticipo per la tua opinione.