Question

I have a class that has about 20-some methods in it. Each one does some web service message processing. I just had to make a change to it, and realized that every one of these methods has the exact same try/catch around it:

try
{
    /* *** actual processing specific to each method goes here *** */
}
catch (FaultException<CustomException> cfex)
{
    // common stuff
}
catch (CustomException cfex)
{
    // common stuff
}
catch (Exception ex)
{
    // common stuff
}
finally
{
    FinalizeServiceCall(wsBus, wsMessage, response, logProps);
}

My question is; instead of having this exact same try/catch block in every method, is there a way to make it common? My thoughts were that .NET has stuff like TransactionScope that somehow detects if an exception occurs when leaving that block. Is there I was I can leverage something like that to make a common try/catch block? Any other ideas?

Answer 1

I would do it like this:

Create a method that contains the try/catch and pass an Action into it and execute that action inside the try part:

public void Method1()
{
    Action action = () =>
    {
        // actual processing of Method 1
    };
    SafeExecutor(action);
}

public void Method1b()
{
    SafeExecutor(() =>
    {
        // actual processing of Method 1
    });
}

public void Method2(int someParameter)
{
    Action action = () =>
    {
        // actual processing of Method 2 with supplied parameter
        if(someParameter == 1)
        ...
    };
    SafeExecutor(action);
}

public int Method3(int someParameter)
{
    Func<int> action = () =>
    {
        // actual processing of Method 3 with supplied parameter
        if(someParameter == 1)
            return 10;
        return 0;
    };
    return SafeExecutor(action);
}

private void SafeExecutor(Action action)
{
    SafeExecutor(() => { action(); return 0; });
}

private T SafeExecutor<T>(Func<T> action)
{
    try
    {
        return action();
    }
    catch (FaultException<CustomException> cfex)
    {
        // common stuff
    }
    catch (CustomException cfex)
    {
        // common stuff
    }
    catch (Exception ex)
    {
        // common stuff
    }
    finally
    {
        FinalizeServiceCall(wsBus, wsMessage, response, logProps);
    }

    return default(T);
}

The two versions of SafeExecutor give you the possibility to handle methods with and without return types.
Method1b shows that you don’t need the variable action in your methods, you can inline it, if you think that’s more readable.