Comment refactoriser ce code en utilisant l'action <t> ou Func <t> délégués

Question

J'ai un exemple de programme, qui doit exécuter 3 méthodes dans un ordre particulier. Et après l'exécution de chaque méthode, devrait faire la gestion des erreurs. Maintenant, je l'ai fait d'une manière normale, sans utiliser des délégués comme celui-ci.

classe programme { public static void Main() {

 MyTest(); 
    } 

    private static bool MyTest() 
    { 

     bool result = true; 
     int m = 2; 
     int temp = 0; 

     try 
     { 
      temp = Function1(m); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine("Caught exception for function1" + e.Message); 
      result = false; 
     } 

     try 
     { 
      Function2(temp); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine("Caught exception for function2" + e.Message); 
      result = false; 
     } 

     try 
     { 
      Function3(temp); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine("Caught exception for function3" + e.Message); 
      result = false; 
     } 

     return result; 
    } 

    public static int Function1(int x) 
    { 
     Console.WriteLine("Sum is calculated"); 
     return x + x; 
    } 

    public static int Function2(int x) 
    { 
     Console.WriteLine("Difference is calculated "); 
     return (x - x); 
    } 

    public static int Function3(int x) 
    { 
     return x * x; 
    } 
} 

Comme vous pouvez le voir, ce code semble laid w/tant de boucles de prises d'essai, qui sont tous font la même chose .. J'ai donc décidé que je pouvais utiliser des délégués pour refactoriser ce code afin que Try Catch puisse être tout en une méthode pour que ça soit bien. Je regardais quelques exemples en ligne et ne pouvais pas figurer notre si j'utilise les délégués d'action ou de Func pour ceci. Les deux se ressemblent, mais je suis incapable d'avoir une idée claire de la façon de l'implémenter. Toute aide est grandement appréciée. J'utilise .NET 4.0, donc im autorisé à utiliser des méthodes anonymes n expressions lambda aussi pour cette

Merci

Answer 1

Merci pour la réponse ... J'ai pu pour arriver à cette solution

@joel .... thnx pour la soln ... comme vous pouvez le voir, l'excpetion jeté ne peut pas terminer le programme .... il shud continuer après la journalisation de l'exception .. ici est mon code Je pense que cela peut encore être refondu. Je viens de Donno comment :(

des suggestions pour simplifier davantage ce ..

Note: Si une fonction particulière lancer une exception, le résultat global shud est faux ... mais shud continuer d'exécuter d'autres func de voir si tout autre func échoue ...

en outre, les func est mentionné ici sont juste pour illustration, les méthodes réelles sont plus CMPLX

class Program 
{ 
    public static void Main() 
    { 
     ExecuteTask task1 = Function1; 
     ExecuteTask task2 = Function2; 
     ExecuteTask task3 = Function3; 
     bool result = true; 
     int param1 = 2, param2 = 3, param3 = 4; 

     MyTest(task1, ref result, ref param1); 
     MyTest(task2, ref result, ref param2); 
     MyTest(task3, ref result, ref param3); 

     Console.WriteLine("final result is " + result.ToString()); 
     Console.ReadLine(); 
    } 

    private delegate void ExecuteTask(ref int x); 

    private static void MyTest(ExecuteTask task, ref bool result1, ref int param1) 
    { 

     try 
     { 
      task(ref param1); 
     } 
     catch (Exception e) 
     { 
      Console.WriteLine("Caught exception for " + e.Message); 
      result1 = false; 
     } 

     return result1; 
    } 

    public static void Function1(ref int x) 
    { 
     Console.WriteLine("Sum is calculated"); 
     x = x + x; 
    } 

    public static void Function2(ref int x) 
    { 
     Console.WriteLine("Difference is calculated "); 
     x = (2 * x - x); 
    } 

    public static void Function3(ref int x) 
    { 
     //Console.WriteLine("Product is calculated "); 
     //x = x * x; 
     throw new ArgumentOutOfRangeException(); 
    } 
} 

Answer 2

bool result = true; 
int m = 2; 
int temp = 0; 

var funcs = new Func<int, int>[]{ 
          x => 
           { 
            Console.WriteLine("Sum is calculated"); 
            return x + x; 
           }, 
          x => 
           { 
            Console.WriteLine("Difference is calculated"); 
            return x - x; 
           }, 
          x => x * x 
         }; 

temp = m; 
foreach (var func in funcs) 
{ 
    try 
    { 
     temp = func(m); 
    } 
    catch (Exception e) 
    { 
     Console.WriteLine("Caught exception:" + e.Message); 
     result = false; 
    }     
} 

Comme une autre réponse dit, cela peut être surpuissant pour cet exemple simple. Cependant, il peut toujours être utile dans certains cas, par exemple si vous voulez implémenter une logique de réessayage à chaque étape (en supposant que vous faites quelque chose de plus complexe que de calculer des valeurs)