One of the easiest ways to avoid writing and having to maintain duplicate code is to use an anonymous method or anonymous function. For example, I recently ran across some code that was validating dates in a UI application, and reporting errors if the dates were out of range. The code looked something like this:
void DoStuff(MyModel model)
{
if (model.StartDate < DateTime.UtcNow)
{
var dt = ConvertUtcToLocal(model.StartDate, model.TimeZone);
AddErrorMessage("Start Date " + dt.ToString("M/d/yy h:mm tt") + " is out of range.");
}
if (model.EndDate < DateTime.UtcNow)
{
var dt = ConvertUtcToLocal(model.EndDate, model.TimeZone);
AddErrorMessage("End Date " + dt.ToString("M/d/yy h:mm tt") + " is out of range.");
}
// six more similar date/time validations
}Our client asked that the format be changed. Which meant going through and changing the format in eight different places. In the process I found two bugs in the code, both obvious copy-paste errors.
With a little bit of thought, the programmer who wrote this (or the last programmer to modify it) could have simplified things quite a bit and in the process made errors much less likely to occur. How? By creating an anonymous method that does the validation and error message formatting:
void DoStuff(MyModel model)
{
var validateAndReport = new Action<string, DateTime>((fieldName, dt) =>
{
if (dt < DateTime.UtcNow)
{
var localDate = ConvertUtcToLocak(dt, model.TimeZone);
AddErrorMessage(fieldName + " " + localDate.ToString("M/d/yy h:mm tt") + " is out of range.");
}
});
validateAndReport("Start Date", model.StartDate);
validateAndReport("End Date", model.EndDate);
// etc.
} Programmers are often hesitant to add simple methods like this outside of their functions because they think it pollutes the namespace, and they often require passing a bunch of parameters for context. Anonymous methods solve both problems: they’re invisible outside of the containing method, and they have access to all of the context that the containing method has access to. With this technique I ensure that all of the dates are formatted correctly, and I can modify the formatting by changing just one line of code. In addition, there are many fewer lines of code and they’re much easier to understand.
The only drawback I see is that programmers have to learn something new: “We can’t use this Action thing! Other programmers won’t understand it!” (Yes, somebody did say that to me.) Tough. Things change. To me and most other programmers I know, the modified code is clearly superior to the old code in every way that matters. I realize that there are some performance implications and hidden memory allocations involved. A few small allocations and a few microseconds aren’t going to make a difference in this code, or any other code in the project.
C# 7.0 introduced local functions: the ability to create a function within a function. This is more than just syntactical sugar around the anonymous function shown above. The local function still can capture local variables, but it avoids the allocation and slight performance hit of the anonymous method. The code above, if written to use a local function, would look something like this:
void DoStuff(MyModel model)
{
void validateAndReport(string fieldName, DateTime dt)
{
if (dt < DateTime.UtcNow)
{
var localDate = ConvertUtcToLocak(dt, model.TimeZone);
AddErrorMessage(fieldName + " " + localDate.ToString("M/d/yy h:mm tt") + " is out of range.");
}
};
validateAndReport("Start Date", model.StartDate);
validateAndReport("End Date", model.EndDate);
// etc.
}Unfortunately, I’m not yet using C# 7.0, so I can’t take advantage of this new feature. I’m also unable to find the official language specification for version 7. However, the article Thoughts on C# 7 Local Functions gives some good information about how it works.