try / catch + using, sintaxe correta

Qual:

using (var myObject = new MyClass())
{
   try
   {
      // something here...
   }
   catch(Exception ex)
   {
      // Handle exception
   }
}

OU

try
{
   using (var myObject = new MyClass())
   {
      // something here...
   }
}
catch(Exception ex)
{
   // Handle exception
}

Eu prefiro o segundo. Também pode interceptar erros relacionados à criação do objeto.

Como um bloco using é apenas uma simplificação de sintaxe de uma tentativa / finalmente ( MSDN ), pessoalmente eu faria o seguinte, embora eu duvide que seja significativamente diferente da sua segunda opção:

MyClass myObject = null;
try {
  myObject = new MyClass();
  //important stuff
} catch (Exception ex) {
  //handle exception
} finally {
  if(myObject is IDisposable) myObject.Dispose();
}

Depende. Se você estiver usando o Windows Communication Foundation (WCF), using(...) { try... }não funcionará corretamente se o proxy na usinginstrução estiver no estado de exceção, ou seja, a eliminação deste proxy causará outra exceção.

Pessoalmente, acredito na abordagem de manipulação mínima, ou seja, lide apenas com a exceção que você conhece no ponto de execução. Em outras palavras, se você souber que a inicialização de uma variável usingpode gerar uma exceção específica, eu a envolvo try-catch. Da mesma forma, se usingalgo dentro do corpo pode acontecer, que não está diretamente relacionado à variável using, então envolvo-o com outro trypara essa exceção específica. Eu raramente uso Exceptionnas minhas catches.

Mas eu gosto IDisposablee, usingportanto, talvez seja tendenciosa.

Se sua instrução catch precisar acessar a variável declarada em uma instrução using, então inside é sua única opção.

Se a sua instrução catch precisar do objeto referenciado no uso antes de ser descartado, o interior é sua única opção.

Se a sua declaração de captura executar uma ação de duração desconhecida, como exibir uma mensagem para o usuário, e você desejar descartar seus recursos antes que isso aconteça, a parte externa é sua melhor opção.

Sempre que eu tenho um cenário semelhante a esse, o bloco try-catch geralmente está em um método diferente, além da pilha de chamadas do uso. Não é típico para um método saber como lidar com exceções que ocorrem dentro dele dessa maneira.

Portanto, minha recomendação geral é do lado de fora - do lado de fora.

private void saveButton_Click(object sender, EventArgs args)
{
    try
    {
        SaveFile(myFile); // The using statement will appear somewhere in here.
    }
    catch (IOException ex)
    {
        MessageBox.Show(ex.Message);
    }
}

Ambos são sintaxe válida. Na verdade, tudo se resume ao que você deseja fazer: se você deseja capturar erros relacionados à criação / descarte do objeto, use o segundo. Caso contrário, use o primeiro.

Há uma coisa importante que chamarei aqui: a primeira não capturará nenhuma exceção resultante de chamar o MyClassconstrutor.

No C # 8.0, eu prefiro usar o segundo igual a este

public class Person : IDisposable
{
    public Person()
    {
        int a = 0;
        int b = Id / a;
    }
    public int Id { get; set; }

    public void Dispose()
    {
    }
}

e depois

static void Main(string[] args)
    {

        try
        {
            using var person = new Person();
        }
        catch (Exception ex) when
        (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
        ex.TargetSite.MemberType == System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Constructor Person");
        }
        catch (Exception ex) when
       (ex.TargetSite.DeclaringType.Name == nameof(Person) &&
       ex.TargetSite.MemberType != System.Reflection.MemberTypes.Constructor)
        {
            Debug.Write("Error Person");
        }
        catch (Exception ex)
        {
            Debug.Write(ex.Message);
        }
        finally
        {
            Debug.Write("finally");
        }
    }

Se o objeto que você está inicializando no bloco Using () pode lançar qualquer exceção, você deve procurar a segunda sintaxe, caso contrário ambas são igualmente válidas.

No meu cenário, eu tive que abrir um arquivo e estava passando filePath no construtor do objeto que estava inicializando no bloco Using () e isso pode gerar uma exceção se o filePath estiver errado / vazio. Portanto, neste caso, a segunda sintaxe faz sentido.

Meu código de amostra: -

try
{
    using (var obj= new MyClass("fileName.extension"))
    {

    }
}
catch(Exception ex)
{
     //Take actions according to the exception.
}

A partir do C # 8.0 , você pode simplificar as usinginstruções sob algumas condições para se livrar do bloco aninhado e, em seguida, ele se aplica apenas ao bloco anexo.

Portanto, seus dois exemplos podem ser reduzidos a:

using var myObject = new MyClass();
try
{
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

E:

try
{
   using var myObject = new MyClass();
   // something here...
}
catch(Exception ex)
{
   // Handle exception
}

Ambos são bem claros; e isso reduz a escolha entre os dois a uma questão de como você deseja que o escopo do objeto esteja, onde você deseja lidar com erros de instanciação e quando deseja descartá-lo.