È una ctriggers pratica restituire da dentro un blocco try catch finally?

Così mi sono imbattuto in un codice stamattina che assomigliava a questo:

try { x = SomeThingDangerous(); return x; } catch (Exception ex) { throw new DangerousException(ex); } finally { CleanUpDangerousStuff(); } 

Ora questo codice si compila bene e funziona come dovrebbe, ma non sembra giusto tornare da un blocco try, specialmente se alla fine è associato.

Il mio problema principale è che cosa succede se alla fine getta un’eccezione proprio? Hai una variabile restituita ma anche un’eccezione da trattare … quindi sono interessato a sapere cosa pensano gli altri di tornare da un blocco try?

No, non è una ctriggers pratica. Mettere il return dove ha senso migliora la leggibilità e la manutenibilità e rende il tuo codice più semplice da capire. Non dovresti preoccuparti perché alla finally blocco verrà eseguito se si incontra un’istruzione di return .

Alla fine verrà eseguito indipendentemente da cosa, quindi non importa.

Personalmente, eviterei questo tipo di codice in quanto non mi sento di vedere le dichiarazioni di ritorno prima delle dichiarazioni finali.

La mia mente è semplice e processa le cose in modo piuttosto lineare. Pertanto, quando passo il codice per la corsa a secco, avrò la tendenza a pensare che una volta raggiunto l’estratto conto, tutto ciò che segue non ha importanza che ovviamente è abbastanza sbagliato in questo caso (non che influenzerebbe la dichiarazione di ritorno ma quali potrebbero essere gli effetti collaterali).

Quindi, sistemerei il codice in modo che l’istruzione di ritorno appaia sempre dopo le dichiarazioni finali.

Questo potrebbe rispondere alla tua domanda

Cosa succede veramente in una prova {return x; } finally {x = null; } dichiarazione?

Dalla lettura di questa domanda sembra che tu possa avere un’altra struttura di cattura nella dichiarazione finale se pensi che possa generare un’eccezione. Il compilatore capirà quando restituire il valore.

Detto questo, potrebbe essere meglio ristrutturare il codice in ogni caso solo così non ti confonderà più tardi o qualcun altro che potrebbe non essere a conoscenza di questo.

Funzionalmente non c’è differenza.

Tuttavia c’è una ragione per non farlo. Metodi più lunghi con diversi punti di uscita sono spesso più difficili da leggere e analizzare. Ma questa obiezione ha più a che fare con dichiarazioni di ritorno che catture e infine blocchi.

Nel tuo esempio in entrambi i casi è equivalente, non sarei nemmeno sorpreso se il compilatore generasse lo stesso codice. Se si verifica un’eccezione nel blocco finally, si verificano gli stessi problemi sia che si inserisca l’istruzione return in blocco o al di fuori di essa.

La vera domanda è stilisticamente la migliore. Mi piace scrivere i miei metodi in modo che ci sia una sola istruzione return, in questo modo è più facile vedere il stream fuori dal metodo, ne consegue che mi piace anche inserire l’ultima dichiarazione di ritorno in modo che sia facile vedere che è la fine del metodo e questo ciò che ritorna.

Penso che con la dichiarazione di ritorno così ordinatamente posizionata come ultima affermazione, altri hanno meno probabilità di venire e cospargere dichiarazioni di reso multiple in altre parti del metodo.