Est-il mauvais d'utiliser des blocs Try..Catch imbriqués comme celui-ci?

Question

Est-ce une mauvaise idée? Existe-t-il un meilleur moyen d'obtenir le même effet?

// assume that "name" is a string passed as a parameter to this code block
try
{
    MainsDataContext dx = new MainsDataContext();
    try
    {
        Main m = dx.Main.Single(s => s.Name == name);
        return m.ID;
    }
    catch (InvalidOperationException)
    {
        Guid g = Guid.NewGuid();

        Main s = new Main 
        {
            Name = name,
            ID = g
        };

        dx.Mains.InsertOnSubmit(s);
        dx.SubmitChanges();

        return g;
    }
}
catch (Exception ex)
{
    // handle this
}

L'objectif ici est d'obtenir l'ID d'un enregistrement s'il existe, sinon créez-le et renvoyez-le.

Answer 1

Vous devez utiliser SingleOrDefault. Ainsi, si un enregistrement n'existe pas, il retournera la valeur par défaut de la classe qui est null.

MainsDataContext dx = null;    
try
    {
         dx = new MainsDataContext();

        Main m = dx.Main.SingleOrDefault(s => s.Name == name);

        if ( m == null)
        { 
           Guid g = Guid.NewGuid();

           m = new Main 
          {
              Name = name,
              ID = g
          };

         dx.Mains.InsertOnSubmit(m);
         dx.SubmitChanges();

        }

        return m.ID;
    }
    catch (Exception ex)
    {
        // handle this
    }
    finally
    {
       if(dx != null)
          dx.Dispose();
    }

il est judicieux d'utiliser le mot clé à l'aide de lors de l'utilisation d'un DataContext

.

using ( MainsDataContext dx = new MainsDataContext())
{
        Main m = dx.Main.SingleOrDefault(s => s.Name == name);

        if ( m == null)
        { 
           Guid g = Guid.NewGuid();

           m = new Main 
          {
              Name = name,
              ID = g
          };

         dx.Mains.InsertOnSubmit(m);
         dx.SubmitChanges();

        }

        return m.ID;
}

Answer 2

Main m = dx.Main.SingleOrDefault(s => s.Name == name);

if (m == default(Main))
{
    // it does not exist
}
else
{
    // it does exist
}

Il ne ressort pas de la question si le type Main est une classe ou une structure (EDIT: je viens de me rendre compte qu'en réalité, il doit s'agir d'une classe), d'où J'ai utilisé default () au lieu de simplement comparer à null .

Answer 3

Ma question serait quel code vous avez l'intention de mettre ici:

// handle this

Avec le premier bloc catch, vous savez que Single () a émis une exception InvalidOperationException car la séquence contient plusieurs éléments ou est vide.

Dans le second cas, vous pourriez avoir toutes sortes d’erreurs. Référence nulle, accès aux données, etc. Comment allez-vous gérer cela?

Ne récupérez que ce que vous savez manipuler et soyez aussi précis que possible dans le type d'exception.

Answer 4

Quoi qu'il en soit, je pense que les blocs Try Catch imbriqués sont bons, tout comme les blocs Catch frères et soeurs détectant chacun un problème différent. C'est bien d'être précis sur les erreurs. La fourre-tout ne devrait être qu'un filet de sécurité pour la production.

Answer 5

Non, mais vous voudrez peut-être refecter le bloc interne dans une méthode externe.