Repeating code pattern

Question

I have certain code pattern (which log performance and other variable for each function) which need to be present in every function, and I do not want to repeat the code over and over again. Here is what the code looks like:

public OutClass FUNC-X
{
 if (IsDebugEnabled)
    {
        Logger("Start DataLibrary: FUNC-X");
    }
try
{
    CheckInitSucceeded();

    GetAuthenticationTokens();

    var dm = new Manager();

    /**
    * THIS SINGLE LINE IS THE VARIABLE PART
    **/
    var output = dm.FUNC-X(...);

    if (IsDebugEnabled)
    {
        var data = Serialize(output);
        Logger(output);
    }
    return output;
}
catch (WebFaultException)
{
    throw;
}
catch (OtherException ex)
{
    if (Logger.IsErrorEnabled)
    {
        Logger.LogError("Exception in FUNC-X", ex);
    }
    throw new OtherException("Some Message");
}
catch (Exception ex)
{
    if (IsErrorEnabled)
    {
        Logger("Exception in FUNC-X", ex);
    }

    throw new Exception("Generic Exception");
}
finally
{
    if (IsDebugEnabled)
    {
        Logger("End FUNC-X");
    }
    }
}

Essentially, I just need to replace FUNC-X with FUNC-Y or FUNC-Z everywhere this name occurs, is there some kind of design pattern which I can follow?

I'm sorry if the question is vague, I shall be happy to provide any details you ask.

Answer 1

You can create a common function that accepts a Func delegate:

    static public TOutClass CommonFunc<TOutClass>(Func<Manager, TOutClass> func)
    {
        if (IsDebugEnabled)
        {
            Logger("Start DataLibrary: FUNC-X");
        }
        try
        {
            CheckInitSucceeded();

            GetAuthenticationTokens();

            var dm = new Manager();
            TOutClass output = func(dm);

            if (IsDebugEnabled)
            {
                var data = Serialize(output);
                Logger(output);
            }
            return output;
        }
        catch
            [...]
    }

Your would write your functions as:

public OutClass FUNC-X(...)
{

   return CommonFunc(dm=>dm.FUNC-X(...));
}

Answer 2

Yeah, there are many ways to provide nice log code.

1. Use aspect-oriented programming. There is PostSharp and Spring.NET. You can use log4net library. All of them after config supports writing of method name.

2. You can use T4 and generate code for all funcs before compile.

3. You can write one global logging method that accepts Func<object> method and string methodName. Suppose you named your logging method LogAndExecute. Then to call you must write smth like:

   LogAndExecute("func-x", () => dm.Func-X(/*your args*/))
   

   If you got problems with different different return types of your funcs, use generics

Answer 3

You can use simple delegate to accept the variable part as parameter (if no. of parameters to function call in single line are same)

    public void Function_X(Func<object,..> func)
    {
        if (IsDebugEnabled)
        {
                Logger("Start DataLibrary: FUNC-X");
        }
        try
        {
            CheckInitSucceeded();

            GetAuthenticationTokens();

            var dm = new Manager();

            /**
            * THIS SINGLE LINE IS THE VARIABLE PART
            **/
        //    var output = dm.FUNC-X(...);
            var output = func(...);

            if (IsDebugEnabled)
            {
                var data = Serialize(output);
                Logger(output);
            }
            return output;
        }
        catch (WebFaultException)
        {
            throw;
        }
        catch (OtherException ex)
        {
            if (Logger.IsErrorEnabled)
            {
                Logger.LogError("Exception in FUNC-X", ex);
            }
            throw new OtherException("Some Message");
        }
        catch (Exception ex)
        {
            if (IsErrorEnabled)
            {
                Logger("Exception in FUNC-X", ex);
            }

            throw new Exception("Generic Exception");
        }
        finally
        {
            if (IsDebugEnabled)
            {
                Logger("End FUNC-X");
            }
        }
    }