Using Func<T> instead of helper methods in a class

Question

I really like functional programming in C#, it gives you a lot of flexibility. I am wondering if it is the right idea to use functions instead of helper methods, and to make the code more readable.

So here is what I want, I have a method that needs to find Saturday and do something with it:

public void SomeMethod()
{
    var saturday = DateTime.Today;
    while (saturday.DayOfWeek != DayOfWeek.Saturday)
            saturday = saturday.AddDays(-1);

    //rest of the code
}

The problem I am having with this code is readability. I have to scan through 3 lines of code to understand that it needs to find Saturday. Plus seeing var saturday = DateTime.Today;, it really bugs my eyes.

Of course I can write a helper method

private DateTime GetSaturday()
{
    var saturday = DateTime.Today;
    while (saturday.DayOfWeek != DayOfWeek.Saturday)
            saturday = saturday.AddDays(-1);
    return saturday;
}

Now I know exactly what the method does but my problem now is that I know that I won't be calling this method anywhere in the class so it kind of pollutes my class.

So here we are at my favorite:

public void SomeMethod()
{
    Func<DateTime> GetSaturdayFunc = () =>
        {
            var date = DateTime.Today;
            while (date.DayOfWeek != DayOfWeek.Saturday)
                date = date.AddDays(-1);
            return date;
        };

   var saturday = GetSaturdayFunc();
   //rest of the code
}

Although it's a bit more code now my class is not polluted with a lot of utility methods and it is more readable.

What do you think? Is this a good way, are there any better ways?

EDIT

I could also create an extension method which in this case would be appropriate, something like

DateTime.Saturday() 

but that's not what I am referring to in my question. I am asking if it is a good practice to wrap a portion of the code as a function inside that method (since that peace of the code will only be used inside that method and might not apply anywhere else), just for readability purposes.

Answer 1

I actually think I slightly disagree with the other answers in this situation. As you, others have mentioned I see three possible solutions (although there may be others)

1. Create a local Func()
2. Create a method on some sort of utilitly class or on a specific class for dealing with Date manipulation i.e Calendar
3. Create a private method to the class (as it won't be used anywhere else anyway)
4. Create an extension method

Now from your question you state that you do not intend to use the method anywhere else. Your example tends one to think it would be beneficial in other situations as it is fairly generic. In that situation I would be leaning towards an extension method as others have pointed out.

However I often find myself in the situation where a block of code will be repeated in a function and only the variables passed in will vary dependant on local switches etc In this situation I think it's perfectly reasonable to create a local delegate and use that in the function only.

So, to summarize. Yes I think it's acceptable. In your example, probably not, but in situations where the block of code is local only to that method and you know that is the case, then yes. You can always refactor later!

Answer 2

This is a perfect use case for an extension method. It gives maximum readability to your business code, and makes the method available on any DateTime object.

//Test
class Program
{
    static void Main(string[] args)
    {
        Console.Write(DateTime.Today.MostRecent(DayOfWeek.Saturday));
        Console.Read();
    }
}
//Extensions
public static class DateTimeExtensions
{
    public static DateTime MostRecent(this DateTime date, DayOfWeek dayOfWeek)
    {
        var day = date.Date;
        while (day.DayOfWeek != dayOfWeek)
            day = day.AddDays(-1);
        return day;

    }
}

Answer 3

You could try create a utility function elsewhere in your solution ...

public static class DateUtils
{
    public static DateTime MostRecent(DayOfWeek weekDay)
    {
        var date = DateTime.Today;
        while (date.DayOfWeek != weekDay)
            date = date.AddDays(-1);
        return date;
    }
}

... and then use it later in your code ...

public void SomeMethod()
{
    var saturday = DateUtils.MostRecent(DayOfWeek.Saturday);
    // rest of code
}

... which has the benefits of being reusable and in an appropriate object structure.

Answer 4

I would use an extension method over an utility function.

namespace DateTime.Extensions
{
    public static class DateTimeExtensions
    {
        public static DateTime Previous(this DateTime now, DayOfWeek day)
        {
           do {
              now = now.AddDays(-1);
           } while (now.DayOfWeek != day)

           return now;
        }
    }
}

and its use:

public void SomeMethod()
{
    var saturday = DateTime.Today.Previous(DayofWeek.Saturday);

    //rest of the code
}