try / catch + utilisation, syntaxe correcte

Laquelle:

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
}

Je préfère le second. Peut également piéger les erreurs liées à la création de l'objet.

Étant donné qu'un bloc d'utilisation n'est qu'une simplification de la syntaxe d'un essai / enfin ( MSDN ), personnellement, j'irais avec ce qui suit, même si je doute que ce soit significativement différent de votre deuxième option:

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

Ça dépend. Si vous utilisez Windows Communication Foundation (WCF), using(...) { try... }ne fonctionnera pas correctement si le proxy dans l' usinginstruction est à l'état d'exception, c'est-à-dire que la suppression de ce proxy provoquera une autre exception.

Personnellement, je crois en une approche de manipulation minimale, c'est-à-dire ne gérez que l'exception dont vous avez connaissance au moment de l'exécution. En d'autres termes, si vous savez que l'initialisation d'une variable dans usingpeut lever une exception particulière, je l'enveloppe avec try-catch. De même, si usingquelque chose peut se produire dans le corps, qui n'est pas directement lié à la variable in using, alors je l'enveloppe avec un autre trypour cette exception particulière. J'utilise rarement Exceptiondans mes catches.

Mais j'aime bien IDisposableet usingdonc je suis peut-être partial.

Si votre instruction catch a besoin d'accéder à la variable déclarée dans une instruction using, alors inside est votre seule option.

Si votre instruction catch a besoin de l'objet référencé dans using avant qu'il ne soit supprimé, alors inside est votre seule option.

Si votre instruction catch prend une action de durée inconnue, comme afficher un message à l'utilisateur, et que vous souhaitez disposer de vos ressources avant que cela ne se produise, alors l'extérieur est votre meilleure option.

Chaque fois que j'ai un scénario similaire à celui-ci, le bloc try-catch est généralement dans une méthode différente plus haut dans la pile d'appels de l'utilisation. Il n'est pas courant pour une méthode de savoir comment gérer les exceptions qui s'y produisent de cette manière.

Ma recommandation générale est donc à l'extérieur - bien à l'extérieur.

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

Les deux sont une syntaxe valide. Cela dépend vraiment de ce que vous voulez faire: si vous voulez attraper des erreurs liées à la création / suppression de l'objet, utilisez le second. Sinon, utilisez le premier.

Il y a une chose importante que j'appellerai ici: la première ne détectera aucune exception découlant de l'appel du MyClassconstructeur.

À partir de C # 8.0, je préfère utiliser le second comme celui-ci

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

    public void Dispose()
    {
    }
}

puis

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 l'objet que vous initialisez dans le bloc Using () peut lever une exception, vous devriez opter pour la deuxième syntaxe sinon les deux sont également valides.

Dans mon scénario, je devais ouvrir un fichier et je passais filePath dans le constructeur de l'objet que j'étais en train d'initialiser dans le bloc Using () et cela pouvait lever une exception si le filePath est faux / vide. Donc, dans ce cas, la deuxième syntaxe a du sens.

Mon exemple de code: -

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

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

À partir de C # 8.0 , vous pouvez simplifier les usinginstructions sous certaines conditions pour vous débarrasser du bloc imbriqué, puis cela s'applique uniquement au bloc englobant.

Ainsi, vos deux exemples peuvent être réduits à:

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

Et:

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

Les deux sont assez clairs; et puis cela réduit le choix entre les deux à une question de ce que vous voulez que la portée de l'objet soit, où vous voulez gérer les erreurs d'instanciation, et quand vous voulez en disposer.