Encapsulating common Try-Catch code. Is this a known pattern? Is it good or bad? In an effort to reduce code duplication, I often use and have used this style to capture handling of exceptions on a boundary of an application:
Given the following extension methods:

public static class FuncExtenstion
{
    [DebuggerStepThrough]
    public static Action&lt;A&gt; AsAction&lt;A, T&gt;(this Func&lt;A, T&gt; f)
    {
        return (a) =&gt; f(a);
    }

    [DebuggerStepThrough]
    public static Func&lt;bool&gt; AsFunc(this Action a)
    {
        return () =&gt; { a(); return true; };
    }
}

public static class IlogExtensions
{
    public static TResult TryCatchLogThrow&lt;TResult&gt;(this ILog logger, Func&lt;TResult&gt; f)
    {
        try
        {
            return f();
        }
        catch (Exception ex)
        {
            logger.Error(ex.Message, ex);
            throw;
        }
    }

    public static void TryCatchLogThrow(this ILog logger, Action f)
    {
        logger.TryCatchLogThrow(f.AsFunc());
    }

    public static TResult TryCatchLog&lt;TResult&gt;(this ILog logger, Func&lt;TResult&gt; f)
    {
        try
        {
            return f();
        }
        catch (Exception ex)
        {
            logger.Error(ex.Message, ex);
            return default(TResult);
        }
    }

    public static void TryCatchLog(this ILog logger, Action f)
    {
        logger.TryCatchLog(f.AsFunc());
    }
}


In the code I will use these (e.g. in a Windows/WCF/Web Service) to either silently catch the error and let the code continue to run (used in a polling service) or to at least log the error locally on the server and then rethrow the full exception again. 
I have used several other variations where the exception gets wrapped in more 'user friendly' exceptions or in WCF FaultExceptions

So typically this code is used as follows:

    Response ISomeService.SomeOperation(Request request)
    {
        return _logger.TryCatchLogThrow(() =&gt; _domainImplementation.SomeOperation(request));
    }

    OtherResponse ISomeService.OtherOperation(OtherRequest request)
    {
        return _logger.TryCatchLogThrow(() =&gt; _domainImplementation.OtherOperation(request));
    }


I have not seen this style of code anywhere else. So I was wondering if there is an other pattern I should be using, or if this is ok to use.
This looks like the Execute Around pattern in its static syntax. A thunk is passed around, and then invoked at the appropriate moment.

The intent is however a bit different. In true execute around, the is something done before and something done after a certain action/function/block. Catching exceptions "feels" a bit different.