在C＃中制作可重用的try / catch块的建议？

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.

Answer 2

there are ways in which you can do it easily - firstly for me I have started using AOP in order to catch my exceptions

this would effectively turn your code

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);
        }

into something like

[HandleException( Exception , FaultException<CustomException>, 
                      "Error Getting Details" )]
    public MYType GetDetails( string parameter )
    {
        //.... call to service
    }

using Postsharp - details here

alternatively there is a blog post by Mark Rendle on how to catch exceptions in a Functional Programming way - i have not tried this one though

Answer 3

You've identified a cross-cutting concern . You could employ an aspect-oriented programming (AOP) approach to this problem. This can either be performed at runtime by using a proxy that sits in front of your class or during compilation by using an AOP tool that modifies the compiled code.

In the past I've made use of Castle Dynamic Proxy to do this (at runtime). Alternatively you could use one of the other AOP frameworks such as PostSharp .

Answer 4

If the parameters are same or close to the same you can always pass in a delegate. If they are not your could call the code by reflection and take a parameter of 'object[]' to pass to invoke.

Answer 5

What you can do is write the above code in a method that takes a Action or a Func as a parameter which determines the method that should be called in the throw block, along with its parameters.

So that if you would call M(1, "string") in your throw block, it becomes DoStuff(M, 1, "string")

DoStuff would look like

void DoStuff<T1, T2, TResult>(Func<T1, T2, TResult> myMethod, T1 arg1, T2 arg2)
{
        try
        {
            myMethod(arg1, arg2)
        }
        catch (FaultException<CustomException> cfex)
        {
            // common stuff
        }
        catch (CustomException cfex)
        {
            // common stuff
        }
        catch (Exception ex)
        {
            // common stuff
        }
        finally
        {
            FinalizeServiceCall(wsBus, wsMessage, response, logProps);
        }
}