try / catch + using, sintaxis correcta

Cúal:

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

O

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

Prefiero el segundo. También puede atrapar errores relacionados con la creación del objeto.

Dado que un bloque de uso es solo una simplificación de sintaxis de un intento / finalmente ( MSDN ), personalmente iría con lo siguiente, aunque dudo que sea significativamente diferente a su segunda opción:

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

Depende. Si está utilizando Windows Communication Foundation (WCF), using(...) { try... }no funcionará correctamente si el proxy en la usingdeclaración está en estado de excepción, es decir, eliminar este proxy causará otra excepción.

Personalmente, creo en un enfoque de manejo mínimo, es decir, manejar solo una excepción que conozca en el punto de ejecución. En otras palabras, si sabe que la inicialización de una variable usingpuede generar una excepción en particular, la envolveré try-catch. Del mismo modo, si dentro del usingcuerpo puede suceder algo, que no está directamente relacionado con la variable using, entonces lo envuelvo con otro trypara esa excepción en particular. Raramente uso Exceptionen mi catches.

Pero sí me gusta IDisposabley, usingaunque quizás sea parcial.

Si su declaración catch necesita acceder a la variable declarada en una declaración using, entonces dentro es su única opción.

Si su declaración catch necesita el objeto al que se hace referencia antes de desecharlo, entonces su única opción es dentro.

Si su declaración catch toma una acción de duración desconocida, como mostrar un mensaje al usuario, y desea deshacerse de sus recursos antes de que eso suceda, entonces afuera es su mejor opción.

Cada vez que tengo un escenario similar a este, el bloque try-catch generalmente está en un método diferente más arriba de la pila de llamadas que el uso. No es típico que un método sepa cómo manejar excepciones que ocurren dentro de él de esta manera.

Así que mi recomendación general es afuera, muy afuera.

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 son sintaxis válida. Realmente se reduce a lo que desea hacer: si desea detectar errores relacionados con la creación / eliminación del objeto, use el segundo. Si no, usa el primero.

Hay una cosa importante que llamaré aquí: la primera no detectará ninguna excepción derivada de llamar al MyClassconstructor.

Desde C # 8.0, prefiero usar el segundo igual así

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

    public void Dispose()
    {
    }
}

y entonces

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");
        }
    }

Si el objeto que está inicializando en el bloque Using () podría arrojar alguna excepción, entonces debería optar por la segunda sintaxis, de lo contrario, ambas serían igualmente válidas.

En mi escenario, tuve que abrir un archivo y estaba pasando filePath en el constructor del objeto que estaba inicializando en el bloque Using () y podría arrojar una excepción si filePath está incorrecto / vacío. Entonces, en este caso, la segunda sintaxis tiene sentido.

Mi código de muestra: -

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

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

A partir de C # 8.0 , puede simplificar las usingdeclaraciones en algunas condiciones para deshacerse del bloque anidado, y luego solo se aplica al bloque que lo encierra.

Entonces sus dos ejemplos se pueden reducir a:

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

Y:

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

Ambos son bastante claros; y luego eso reduce la elección entre los dos a una cuestión de lo que quiere que sea el alcance del objeto, dónde desea manejar los errores de instanciación y cuándo desea deshacerse de él.