Comment faire des méthodes automatiquement couverts dans les blocs catch try

Question

Disons que nous avons quelque chose comme:

public CustomType DoSomething1() { 
    CustomType ct = new CustomType(); 
    try { 
     // do something 
    } 
    catch(Exception e) { 
     ct.Passed = false; 
    } 
    return ct; 
} 

public CustomType DoSomething2() { 
    CustomType ct = new CustomType(); 
    try { 
     // do something 
    } 
    catch(Exception e) { 
     ct.Passed = false; 
    } 
    return ct; 
} 

public CustomType DoSomething3() { 
    CustomType ct = new CustomType(); 
    try { 
     // do something 
    } 
    catch(Exception e) { 
     ct.Passed = false; 
    } 
    return ct; 
} 

Ces méthodes sont exécutées par un autre programme utilisant la réflexion, et si la propriété CustomType Passed == false, arrêt du programme d'exécuter un autre . C'est dû aux aspects d'architecture.

Est-il possible de créer un attribut ou quelque chose comme ça pour éviter d'utiliser les prises d'essai, de sorte que si exception est levée dans la méthode, il fera Passed propriété comme faux et revenir à ce programme? Par exemple.

[CatchException('Passed', false)] 
public CustomType DoSomething1() { 
    CustomType ct = new CustomType(); 
    // do something 
    return ct; 
} 

Et si en train de « faire quelque chose » erreur serait ct.Passed sera égal à « faux »

Answer 1

Si je comprends bien votre question correcte, vous voulez éviter de répéter l'try-catch -bloc. Vous pouvez résoudre cela en créant une fonction que vous transmettez la logique que vous voulez traiter.

public static CustomType CatchException(Action a) 
{ 
    CustomType ct = new CustomType(); 
    try 
    { 
     a(); 
    } 
    catch 
    { 
     ct.Passed = false; 
    } 
    return ct; 
} 

Maintenant vous pouvez simplement appeler la fonction avec n'importe quelle logique dont vous avez besoin plusieurs fois de manière très confortable.

public CustomType DoSomething1() 
{ 
    return CatchException(() => 
    { 
     //Do something 
    }); 
} 
... 

Answer 2

Vous pouvez effectuer les opérations suivantes:

public static T SafeProcessing<T>(Action<T> action, Action<T> onFail) 
    where T: new() 
{ 
    var t = new T(); 

    try 
    { 
     a(t); 
    } 
    catch (Exception e) 
    { 
      //Log e 
      onFail(t); 
    } 

    return t; 
} 

Et ne vous utiliseriez comme ceci:

return SafeProcessing(c => DoSomething(c), c => c.Safe = false);