Simplify Repeated Code with Delegates and Generic Methods

Posted on December 31, 2014 Updated on December 31, 2014

Scenario: Repeated Code in All my Web Methods

• I’m writing a bunch of WCF web methods
• They all have chunks of nearly identical code
  • (For example: code for logging, authentication, validation, error handling, etc.)
• But each method has a certain number of lines of code that are unique
• The upshot is that every time I add a new web method, I add a huge amount of code that is the same as before
• And every time we change our general procedure (i.e different logging, different validation, etc.), I need to modify that repeated code, a task that is error prone and boring

What You will Learn

If you read this post, you will see a practical sample of how to:

• Use delegates to execute code that is unique for each of your individual web service methods
• Use a generic method to handle process all your web methods, using any request or response data types
• Use interfaces to add power to you generic methods!

See below for a simplified description of these powerful techniques. The code sample download link is at the end.

Important Principal: Do Not Repeat Yourself!

I have a deadline, and I would like to meet it by avoiding repeated code. I’ll bet you also have a deadline, and maybe you would like to keep your job by meeting that deadline!

Also, my client deserves easy-to-maintain code, so I will write my code to give them the power to easily make changes in one place and have it affect all my web methods. Testing is also easier when you avoid repeating yourself, because you have fewer lines to test.

What I’m talking about is the “best practice” called “DRY”, or Do not Repeat Yourself. In my experience, sophisticated/productive programmers all use DRY, whereas most corporate drones have no frigging clue. Which is why most of their code sucks, IMHO!

The “UniversalMessageProcessor” I describe in this post will show you how to avoid repeating yourself by using delegates, generic methods, and a few other things, thus helping you meet your deadline and give your clients the easy-to-maintain code they deserve.

Sample Code – Shows the Essence of my Repeated Code

Read my simplified sample immediately below to get an idea of the repeated code that I wish to improve a la DRY:

public ResponseType1 GetData1(RequestType1 request){
	try {
		//Simplified representation of the repeated authentication code
		//(Use your imagination to envision longer code)
		CheckAuthentication(request.Credentials);
                //Also repeated in every web method, yada yada yada
		ValidateRequest(request);
                //Another chunk of repeated code that is actually more like 15 lines:
		LogRequest(request);
		//Simplified representation of the lengthy code to copy the result from BLL into 
		//the response we send to service partner, again, imagine 30 lines instead of 2)
                bllResult = Bll.GetReponseType1(request);
		ReponseType1 myResponse = CopyBllResultToResponse(bllResult);
		LogResponse(myResponse);
		return myResponse
	} catch (Exception ex) {
		LogError(ex, request);
	}
}

In other words, I have a bunch of web methods that follow the simplified pattern above, except they use ‘ResponseType2’, ‘ResponseType3’, etc. Only the portion in yellow is unique to each web method; otherwise they are (mostly) similar. I would like to avoid all this repeated code! But first, let’s make sure we understand a couple of techniques I will use, delegates and generic methods:

Nutshell Definitions for ‘Delegate’ and ‘Generic Method’

Delegates: a Variable to Hold Your Code

In a nutshell, a delegate (sometimes called a function pointer) is how you represent your code as a variable (i.e. as a First Class Object) which you can pass to other methods. Like this (over simplified) sample:

Func<int, string> GetSign = (i) => {
	if (i < 0)
		return "-";
	else if (i > 0)
		return ("+");
	else
		return "";
};

//Usage:
string s1 = GetSign(5);
Console.WriteLine(s1);
//Output will be "+"

‘GetSign‘ is a delegate, and I can pass it to another method, because it is a variable. You may also see folks declare delegates using the ‘Action‘ keyword, instead of the ‘Func‘ keyword I used above.

For another example of passing delegates as parameters, take a look at how I used them to solve a puzzle: https://actualrandy.wordpress.com/2014/09/18/calculator-letters-puzzle-solved/

Generic Methods – Work on Any Data Type!

In another nutshell, a generic method is a method which does the same work regardless of parameter type. Here’s a quick sample from the MSDN site:

static void Swap<T>(ref T lhs, ref T rhs)
{
    T temp;
    temp = lhs;
    lhs = rhs;
    rhs = temp;
}
//Usage:
string s1 = "A", s2 = "B";
Swap<string>(s1, s2);
int i1 = 1, i2 = 2;
Swap<int>(i1, i2);

In this sample, ‘T‘ could be int, string, DateTime, or any other data type you need!

Enough Background, Here’s the Code!

The code for this post is available for download at the bottom of the article. I will discuss the important portions here. The download code has two web methods (but my production code has a lot more, I simplified my sample for your sake). Let’s look at my first web method, which returns a list of locations associated with the caller’s service center:

public GetLocationServiceCenterResponse GetLocationByServiceCenter(GetLocationServiceCenterRequest request) {
    //The delegate performs the work which only applies to this 
    //web method; the common work is performed by ProcessMessage
    Func<IRequestWithCredential, IReturnMessageResponse, BllResult> getBllResult = (req, response) => {
        //cast to the type we need:
        GetLocationServiceCenterRequest getLocRequest = (GetLocationServiceCenterRequest)req;

        //Invoke the Business-Logic-Layer method that does the database work:
        BllResult theBllResult = BllMain.GetLocationServiceCenter(getLocRequest);

        //Here we will copy the result from the ReturnTable into the response
        //Note that the ReturnTable is a weakly-typed DataTable that varies according to the method
        GetLocationServiceCenterResponse getLocResponse = (GetLocationServiceCenterResponse)response;
        getLocResponse.Locations = new List<LocationInfo>();
        if (theBllResult.ReturnCode == BllConstants.SUCCESS) {
            //Copy the weakly-typed data from the BllResult into our response:
            foreach (DataRow dr in theBllResult.ReturnTable.Rows) {
                LocationInfo curLoc = new LocationInfo();
                curLoc.Location = (string)dr["LocationID"];
                curLoc.Description = (string)dr["Description"];
                curLoc.LocationType = (string)dr["LocationType"];
                getLocResponse.Locations.Add(curLoc);
            }
        }

        return theBllResult;
    };
    //End of delegate body

    //Now, do all the work, using the delegate we built above:
    GetLocationServiceCenterResponse result = ProcessMessage<GetLocationServiceCenterRequest, GetLocationServiceCenterResponse>
                        (request, "getLocationServiceCenter", getBllResult);
    return result;
}

As you can see above, the main thing I do is declare my delegate, ‘getBllResult’, and then pass it to a medhod called ‘ProcessMessage’. The delegate begins in the highlighted code. Just to refresh your memory, this delegate handles the work that is unique to finding locations by service center.

Also, take a look at how I invoke ‘ProcessMessage’ – I tell it the input and output types (GetLocationServiceCenterRequest, GetLocationServiceCenterResponse) in between the angle brackets:

result = ProcessMessage<GetLocationServiceCenterRequest, GetLocationServiceCenterResponse> ...

If you download my code, you will see that I do almost the exact same thing with my second web method. The only difference is that my second method declares the delegate to handle different types of data. This means that all the web methods are greatly shortened, because all they do is define a delegate and call ProcessMessage!

Now Look at My ‘Universal’ ProcessMessage Method

The following is a simplified sample – I cut-out approximately 50 lines of logging/authentication, etc., just so you can read it easier!

public TResult ProcessMessage<TRequest, TResult>
1		(TRequest request, 
2		 string methodName, 
3		 Func<IRequestWithCredential, IReturnMessageResponse, BllResult> getBllResult
		)
4	where TResult : IReturnMessageResponse, new()
5	where TRequest : IRequestWithCredential 
{
6   TResult result = new TResult();
    _Logger.Log(LogLevel.Info, methodName + " started...");
    result.ReturnMessage.ReturnMessageDetails = new List<ReturnMessageDetail>();
    try {
        if (AuthenticateApp(request.credential)) {
            _Logger.Log(LogLevel.Info, methodName + " validating request");
            List<ValidationResult> lstValidationResults = new List<ValidationResult>();
            //The GeneralValidator uses reflection to validate any class and its child members
7           if (_Validator.ValidateComplexObject<TRequest>(request, lstValidationResults)) {
                //Execute the function passed to us
8               BllResult bllResult = getBllResult(request, result);

                if (bllResult != null && bllResult.ReturnCode == BllConstants.FAIL) {
                    result.ReturnMessage.ReturnCode = BllConstants.FAIL;
                    result.ReturnMessage.ReturnText = ERR_MESSAGE;
                } else if (bllResult != null) {
                    //We got the result we wanted, set the appropriate values in our result
                    result.ReturnMessage.ReturnCode = bllResult.ReturnCode;
                    result.ReturnMessage.ReturnText = bllResult.ErrorMessage;
                }
            } else {
                //Validation failed
                CopyValidationResultsToResponse(result, lstValidationResults);
                }
            }
        } else {
            //Invalid authentication
            result.ReturnMessage = new ReturnMessage{ ReturnCode = BllConstants.FAIL, 
                  ReturnText = "Your credentials suck --> no data for you, ya filthy hacker!"};
        }
    } catch (Exception ex) {
        while (ex != null) {
            result.ReturnMessage = new ReturnMessage{ ReturnText =  ex.Message };
            _Logger.Log(LogLevel.Error, ex.Message);
            ex = ex.InnerException;
        }
    }
9    return result;
}

 Explanation!

I injected some line numbers into my sample above, and they are linked to the numbered bullet points below:

1. TRequest request – My method takes a generic input type ‘TRequest’, which could be, for example, ‘GetServiceCenterRequest’
2. string methodName – The method uses your method name for logging
3. Func<…, …, …> getBllResult – Third parameter is my delegate, which I will execute on line 8 (highlighted). Remember, the delegate is the code which is unique to each web method. Also remember, the point of using a delegate is that I can pass delegates like parameters!
4. where TResult : IReturnMessageResponse, new() Generic methods allow you to use the ‘Where’ clause to restrict what types of data they will process. In this case, I require that the result/ouput type (‘TResult’) implement a simple interface called ‘IReturnMessageResponse’. That allows me to write code like this: ‘result.ReturnMessage = new ReturnMessage’, because the interface declares that every implementor has such an object. (Sample code below.)
   • “new()” here, my ‘where-clause’ also requires that TRequest expose a constructor, which allows me to write the code on line 6
5. where TRequest : IRequestWithCredential – Here, I require that the input paramter (‘TRequest’) implement a different interface, ‘IRequestWithCredential’. In a nutshell, every class that implements this interface has a Credential object.
6. TResult result = new TResult() – because of my where-clause on line 4, the compiler knows my input parameter has a constructor it can call! Also, the class of my result is TResult, which can be any class, (subject to my where clause)
7. ValidateComplexObject – Refer to my previous post on writing a universal validator using DataAnnotations and Reflection.
8. BllResult bllResult = getBllResult(request, result) – here is where I invoke the delegate!. This is the whole point of my post, i.e. use the delegate inside a generic method to perform work that is unique to each web method. Note that my teammates wrote the BLL (Business Logic Layer) to always return a class called bllResult, each result has a table with different data).
9. return result; – Since I declared this method to return TResult, my generic method will return whatever class type you need, such as a response object for GetLocationsByServiceCenter.

My Two Interfaces

OK, I promised above that I would list my interfaces, as you can see, they are really simple. Just to refresh your memory,

• All my request classes implement IRequestWithCredential
• And all my response classes implement IReturnMessageResponse
• By doing so, the compiler is not confused when I execute code like ‘request.Credential = null’, or similar actions
• I.e., any time I refer to something defined the the interface, the compiler is happy!

//First interface:
public interface IReturnMessageResponse
{
    ReturnMessage ReturnMessage { get; set; }
}

//Second interface
public interface IRequestWithCredential
{
    Credential credential { get; set; }
}

 Summary

1. When you write your code, you should avoid repeating yourself, because it will help you meet your deadline and shrink your code.
2. If you are writing a web interface, you can find lots of repeated code to optimize, depending on how much logging, authentication, validation, etc. you are required to do. (But the same principle applies to other code!)
3. You can create a generic method that will work for any of your response classes and request classes, that is step one to saving a ton of code!
4. Your generic method can accept a delegate input parameter; you method will execute that method to handle code that is unique to each web method.
5. You can constrain your generic method using the ‘where-clause’; one use is that it tells the compiler that your types implement an interface

By applying these techniques, you should be able to reduce your web method code by 20%-50%, depending on how much repeated code you have. That’s a big savings, and should really speed things up.

Link download to the Code