¿Cuándo se supone que se debe usar "Try" en los nombres de métodos de C #?

Estábamos discutiendo con nuestros compañeros de trabajo sobre lo que significa si el nombre del método comienza con "Probar".

Hubo las siguientes opiniones:

• Use "Probar" cuando el método pueda devolver un valor nulo.
• Use "Probar" cuando el método no arroje una excepción.

¿Cuál es la definición oficial? ¿Qué dice "Probar" en el nombre del método? ¿Hay alguna directriz oficial sobre esto?

Esto se conoce como el patrón TryParse y ha sido documentado por Microsoft. La página oficial de Excepciones y rendimiento de MSDN dice :

Considere el patrón TryParse para los miembros que pueden lanzar excepciones en escenarios comunes para evitar problemas de rendimiento relacionados con las excepciones.

Por lo tanto, si tiene un código para el que un caso de uso regular significaría que podría arrojar una excepción (como analizar un int), el patrón TryParse tiene sentido.

(Corregido) Existe una directriz oficial, como sugirió Erik.

Cuando veo el TrySomethingmétodo, lo asumo

• no tira
• devoluciones bool
• si espero valor, se devuelve a través del parámetro 'out'
• Existe un Somethingmétodo que me permite manejar cualquier excepción yo mismo. (editar, sugerido por Jesse Webb)

Creo que deberías usar trycuando quieras continuar. No importa que un método devuelva algún valor o no.

Caso 1: si vuelve bien, puede proceder de alguna manera.

Caso 2: si no regresa: todavía está bien; puedes proceder de otra manera.

Y si espera algún valor como resultado de ese método, use el outparámetro.

Ejemplo

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

Debe usar "Probar" en el nombre del método, cuando desee manifestar el hecho de que la invocación del método puede producir un resultado no válido. Siguiendo el estándar .NET, por cierto, no es una función que genera una excepción, sino la función que devuelve algo VALIDo NON_VALID, desde la perspectiva del programa, valor.

Al final, se trata de una convención de nomenclatura que decides usar en tu grupo.

Asegúrese de incluir tryen su nombre de método si:

• no lanzas ninguna excepción
• su método tiene la siguiente firma: bool TrySomething(input, out yourReturn)

Básicamente, si usamos try-methods solo obtenemos un resultado booleano.

Entonces, el siguiente código no arrojará ninguna excepción:

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

Mientras que este código puede (y en este caso lo hará) lanzar excepciones:

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

Usar métodos Try es una forma más segura y más defensiva de codificar. Además, el fragmento de código # 2 requiere más rendimiento para ejecutarse si no es un número entero.

El tío Bob da el siguiente ejemplo en su libro Clean Code . Siempre que esperemos que se produzca una excepción, podemos usar el Tryprefijo del nombre de un método:

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

Y luego (adaptado):

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

El tryToShutDownmétodo no realiza ningún manejo de errores, porque es responsabilidad del sendShutDownmétodo.

los TryParse patrón de Microsoft viola la directriz de código limpio que dice que debemos evitar los parámetros de salida.

Si no estamos desarrollando una nueva versión de C #, no tenemos que cumplir con todas las pautas de Microsoft. A veces no son los mejores.