Creative use of Delegates in .NET

I normally don't use delegates, since I don't do a lot of events programming where they are commonly used. But I was building a class library the other day and found a good use for them.

Here is the scenario: I have a series of methods that allow for merging of records in our main CRM. In order to connect to the CRM, there is a series of setup and tear down calls that have to be made such as connecting, logging in, etc.

So I found myself creating a dozen methods that all looked something like this:

public void mergeAddress(String masterID, String mergeID)
{
try
{
bunch of set up code
meat of the method
bunch of tear down code
}
catch (Exception e)
{
throw new MergeException("Unexpected error in method mergeAddress", e);
}
}

I found myself copying and pasting this chunk of code over and over again, which is always a good sign that some refactoring is required.

My solution was to use a delegate to represent the meat of the method in the middle. Therefore, instead of having a bunch of methods that repeat the same code over and over again, I can now rewrite the method to look something like this:

protected delegate void mergeDelegate(String MasterID, String MergeID);

public void mergeByDelegate(del method, String MasterID, String MergeID)
{
try
{
bunch of set up code
del.invoke();
bunch of tear down code
}
catch (Exception e)
{
throw new MergeException("Unexpected error in method mergeAddress", e);
}

}

Now the method becomes like a prototype - I can keep the set up and tear down in one place and simply sub in the method call in the middle.

(FYI, You could do the same thing by splitting the method into three chunks, moving them into a class and sub-classing the method in the middle, but I think using a simple delegate is easier.)

To implement the prototype now looks something like this:

public void mergeAddress(String MasterID, String MergeID)
{
mergeDelegate del = this.mergeAddress();
mergeByDelegate(del, MasterID, String MergeID);
}

public void mergeAddress(String MasterID, String MergeID)
{
meat of the method
}

All the set up and tear down code is now centralized into one method. The part that changes in the middle can now vary in a variety of ways.

Hope this helps everyone with another way of using delegates...I've always struggled to find a use for them.