Quando si suppone che "Try" sia usato nei nomi dei metodi C #?

Stavamo discutendo con i nostri colleghi su cosa significhi se il nome del metodo inizia con "Prova".

C'erano le seguenti opinioni:

• Utilizzare "Prova" quando il metodo può restituire un valore null.
• Utilizzare "Prova" quando il metodo non genera un'eccezione.

Qual è la definizione ufficiale? Cosa dice "Prova" nel nome del metodo? C'è qualche linea guida ufficiale su questo?

Questo è noto come modello TryParse ed è stato documentato da Microsoft. La pagina MSDN ufficiale di eccezioni e prestazioni dice :

Considerare il modello TryParse per i membri che possono generare eccezioni in scenari comuni per evitare problemi di prestazioni correlati alle eccezioni.

Pertanto, se si dispone di codice per il quale un caso d'uso normale significherebbe che potrebbe generare un'eccezione (come l'analisi di un int), il modello TryParse ha senso.

(Corretto) Esiste una linea guida ufficiale, come ha suggerito Erik.

Quando vedo il TrySomethingmetodo, lo presumo

• non getta
• ritorna bool
• se mi aspetto un valore, viene restituito tramite il parametro 'out'
• esiste un Somethingmetodo che mi consente di gestire da solo ogni eccezione. (modifica, suggerito da Jesse Webb)

Penso che dovresti usare tryquando vuoi procedere. Non importa che un metodo restituisca un valore o no.

Caso 1: se ritorna bene, puoi procedere in qualche modo.

Caso 2: se non ritorna: va ancora bene; puoi procedere in qualche altro modo.

E se ti aspetti un valore come output di quel metodo, usa il outparametro.

Esempio

int value
if (dictionary.TryGetValue("key", out value))
{
    // Proceed in some way
}
else
{
    // Proceed in some other way
}

Devi usare "Prova" nel nome del metodo, quando vuoi manifestare il fatto che l'invocazione del metodo può produrre risultati non validi. Seguire lo standard .NET, tra l'altro, non è una funzione che genera un'eccezione, ma la funzione che restituisce un valore VALIDo NON_VALID, dal punto di vista del programma, valore.

Alla fine, tutto questo sulla convenzione di denominazione che decidi di utilizzare nel tuo gruppo.

Assicurati di includere trynel tuo nome metodo se:

• non fai alcuna eccezione
• il tuo metodo ha la seguente firma: bool TrySomething(input, out yourReturn)

Quindi fondamentalmente se usiamo try-metodi otteniamo solo un risultato booleano.

Quindi il seguente codice non genererà alcuna eccezione:

string input = "blabla";
int number;
if (int.TryParse(input, out number))
{
// wooohooo we got an int!
} else
{
//dooh!
}

Considerando che questo codice può (e in questo caso) generare eccezioni:

string input = "blabla";
int number;
try
{
     number = int.Parse(input); //throws an exception
}
catch (Exception)
{
     //dooh!
}

L'uso dei metodi Try è un modo più sicuro e più difensivo per codificare. Inoltre, lo snippet di codice n. 2 richiede più prestazioni per essere eseguito se non è un numero intero.

Lo zio Bob fa l'esempio di seguito nel suo libro Clean Code . Ogni volta che ci aspettiamo che venga generata un'eccezione, possiamo usare il Tryprefisso per un nome di metodo:

public void sendShutDown()
{
    try{
        tryToShutDown();
    } catch (DeviceShutDownError e) {
        logger.log(e);            
    }
}

E poi (adattato):

private void tryToShutDown()
{
    //some code with no error handling, but
    //something might go wrong here
}

Il tryToShutDownmetodo non commette errori nella gestione, poiché questa è la responsabilità del sendShutDownmetodo.

Il TryParsemodello di Microsoft viola la linea guida del codice pulito che afferma che dovremmo evitare i parametri di output.

Se non stiamo sviluppando una nuova versione di C #, non dobbiamo attenerci a tutte le linee guida di Microsoft. A volte non sono i migliori.