Question

I am relatively new to C#, maybe you could help me with this.

I got a couple of methods callServiceXY(param1, param2, ...) that call a certain service. For many reasons these service calls can go wrong (and I don’t really care for the reason in the end). So basically I need to always wrap them with something like this – to have them execute again if something goes wrong:

var i = 3;
while(i>0)
  try{
   call...()
  } catch{
   i--;
  }
  i=0;
}

I’d rather write this code only once. Could I somehow have a method like tryXtimes(int x, callService()) that allows me to execute an undefined or anonymous method? (I have Javascript in mind where this is possible…)?

Answer 1

Yes this is possible. C# 3.5 added support for Action and Func<T> types. An Action won’t return any value, a Func will always return a value.

You have several different versions that also accept a number of parameters. The following Console Applications describes how you could do this:

using System;

namespace Stackoverflow
{
    class Service
    {
        public int MyMethod() { return 42; }
        public void MyMethod(string param1, bool param2) { }

        public int MyMethod(object paramY) { return 42; }
    }

    class Program
    {
        static void ExecuteWithRetry(Action action)
        {
            try
            {
                action();
            }
            catch
            {
                action();
            }

        }

        static T ExecuteWithRetry<T>(Func<T> function)
        {
            try
            {
                return function();
            }
            catch
            {
                return function();
            }

        }

        static void Main(string[] args)
        { 
            Service s = new Service();
            ExecuteWithRetry(() => s.MyMethod("a", true));

            int a = ExecuteWithRetry(() => s.MyMethod(1));
            int b = ExecuteWithRetry(() => s.MyMethod(true));

        }
    }
}

As you can see, there are two overloads for ExecuteWithRetry. One returning void, one returning a type. You can call ExecuteWithRetry by passing an Action or a Func.

–> Edit: Awesome! Just a little extra code to complete the example:

With anonymous function/method:

ExecuteWithRetry(() =>
{
   logger.Debug("test");
});

And with more parameters (action, int)

Method header:

public static void ExecuteWithRetryX(Action a, int x)

Method call:

ExecuteWithRetryX(() => { logger.Debug("test"); }, 2);