Quando "Try" deveria ser usado nos nomes dos métodos C #?

Estávamos discutindo com nossos colegas de trabalho o que significa se o nome do método começa com "Try".

Havia as seguintes opiniões:

• Use "Try" quando o método puder retornar um valor nulo.
• Use "Try" quando o método não lançar uma exceção.

Qual é a definição oficial? O que "Try" diz no nome do método? Existe alguma diretriz oficial sobre isso?

Isso é conhecido como padrão TryParse e foi documentado pela Microsoft. A página oficial do Exceções e Desempenho do MSDN diz :

Considere o padrão TryParse para membros que podem lançar exceções em cenários comuns para evitar problemas de desempenho relacionados a exceções.

Portanto, se você tiver um código para o qual um caso de uso regular significaria que poderia gerar uma exceção (como analisar um int), o padrão TryParse faz sentido.

(Corrigido) Há diretrizes oficiais, como Erik sugeriu.

Quando vejo o TrySomethingmétodo, presumo que

• não joga
• retorna bool
• se eu espero valor, ele é retornado via parâmetro 'out'
• existe um Somethingmétodo que me permite lidar com qualquer exceção. (editar, sugerido por Jesse Webb)

Eu acho que você deve usar tryquando quiser prosseguir. Não importa que um método retorne algum valor ou não.

Caso 1: se retornar bem, você pode prosseguir de alguma maneira.

Caso 2: se não retornar: ainda está bom; você pode prosseguir de outra maneira.

E se você espera algum valor como saída desse método, use o outparâmetro

Exemplo

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

Você precisa usar "Try" no nome do método, quando quiser manifestar o fato de que a invocação do método pode produzir um resultado inválido. Seguindo o padrão .NET, a propósito, não é uma função que gera uma exceção, mas a função que retorna algum valor , VALIDou NON_VALIDdo ponto de vista do programa.

No final, trata-se de uma convenção de nomenclatura que você decide usar em seu grupo.

Certifique-se de incluir tryno seu nome do método se:

• você não lança nenhuma exceção
• seu método tem a seguinte assinatura: bool TrySomething(input, out yourReturn)

Então, basicamente, se usarmos try-methods, apenas obteremos um resultado booleano.

Portanto, o código a seguir não lançará nenhuma exceção:

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

Considerando que este código pode (e neste caso irá) lançar exceções:

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

Usar os métodos Try é uma maneira mais segura e defensiva de codificar. Além disso, o snippet de código nº 2 exige mais desempenho para ser executado se não for um número inteiro.

Tio Bob dá o exemplo abaixo em seu livro Clean Code . Sempre que esperamos que uma exceção seja lançada, podemos usar o Tryprefixo para o nome de um método:

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

E então (adaptado):

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

O tryToShutDownmétodo não faz nenhum tratamento de erros, porque essa é a responsabilidade do sendShutDownmétodo.

O TryParsepadrão da Microsoft viola a diretriz de código limpo que diz que devemos evitar os parâmetros de saída.

Se não estamos desenvolvendo uma nova versão do C #, não precisamos seguir todas as diretrizes da Microsoft. Às vezes eles não são os melhores.