Fuzzy Date Time Picker Control in C# .NET?

Question

I am implementing a Fuzzy Date control in C# for a winforms application. The Fuzzy Date should be able to take fuzzy values like

• Last June
• 2 Hours ago
• 2 Months ago
• Last week
• Yesterday
• Last year

and the like

Are there any sample implementations of "Fuzzy" Date Time Pickers?

Any ideas to implement such a control would be appreciated

PS: I am aware of the fuzzy date algorithm spoken about here and here, I am really looking for any ideas and inspirations for developing such a control

Answer 1

One of the systems our users use allows them to enter dates like so:

• T // Today
• T + 1 // Today plus/minus a number of days
• T + 1w // Today plus/minus a number of weeks
• T + 1m // Today plus/minus a number of months
• T + 1y // Today plus/minus a number of years

They seem to like it, and requested it in our app, so I came up with the following code. ParseDateToString will take a string of one of the forms above, plus a few others, calculate the date, and return it in "MM/DD/YYYY" format. It's easy enough to change it to return the actual DateTime object, as well as to add support for hours, minutes, seconds, or whatever you want.

using System;
using System.Text.RegularExpressions;

namespace Utils
{
    class DateParser
    {
        private static readonly DateTime sqlMinDate = DateTime.Parse("01/01/1753");
        private static readonly DateTime sqlMaxDate = DateTime.Parse("12/31/9999");
        private static readonly Regex todayPlusOrMinus = new Regex(@"^\s*t(\s*[\-\+]\s*\d{1,4}([dwmy])?)?\s*$", RegexOptions.Compiled | RegexOptions.IgnoreCase); // T +/- number of days
        private static readonly Regex dateWithoutSlashies = new Regex(@"^\s*(\d{6}|\d{8})\s*$", RegexOptions.Compiled); // Date in MMDDYY or MMDDYYYY format

        private const string DATE_FORMAT = "MM/dd/yyyy";

        private const string ERROR_INVALID_SQL_DATE_FORMAT = "Date must be between {0} and {1}!";
        private const string ERROR_DATE_ABOVE_MAX_FORMAT = "Date must be on or before {0}!";
        private const string ERROR_USAGE = @"Unable to determine date! Please enter a valid date as either:
    MMDDYY
    MMDDYYYY
    MM/DD/YY
    MM/DD/YYYY

You may also use the following:
    T (Today's date)
    T + 1 (Today plus/minus a number of days)
    T + 1w (Today plus/minus a number of weeks)
    T + 1m (Today plus/minus a number of months)
    T + 1y (Today plus/minus a number of years)";

        public static DateTime SqlMinDate
        {
            get { return sqlMinDate; }
        }

        public static DateTime SqlMaxDate
        {
            get { return sqlMaxDate; }
        }

        /// <summary>
        /// Determine if user input string can become a valid date, and if so, returns it as a short date (MM/dd/yyyy) string.
        /// </summary>
        /// <param name="dateString"></param>
        /// <returns></returns>
        public static string ParseDateToString(string dateString)
        {
            return ParseDateToString(dateString, sqlMaxDate);
        }

        /// <summary>
        /// Determine if user input string can become a valid date, and if so, returns it as a short date (MM/dd/yyyy) string. Date must be on or before maxDate.
        /// </summary>
        /// <param name="dateString"></param>
        /// <param name="maxDate"></param>
        /// <returns></returns>
        public static string ParseDateToString(string dateString, DateTime maxDate)
        {
            if (null == dateString || 0 == dateString.Trim().Length)
            {
                return null;
            }

            dateString = dateString.ToLower();

            DateTime dateToReturn;

            if (todayPlusOrMinus.IsMatch(dateString))
            {
                dateToReturn = DateTime.Today;

                int amountToAdd;
                string unitsToAdd;

                GetAmountAndUnitsToModifyDate(dateString, out amountToAdd, out unitsToAdd);

                switch (unitsToAdd)
                {
                    case "y":
                        {
                            dateToReturn = dateToReturn.AddYears(amountToAdd);
                            break;
                        }
                    case "m":
                        {
                            dateToReturn = dateToReturn.AddMonths(amountToAdd);
                            break;
                        }
                    case "w":
                        {
                            dateToReturn = dateToReturn.AddDays(7 * amountToAdd);
                            break;
                        }
                    default:
                        {
                            dateToReturn = dateToReturn.AddDays(amountToAdd);
                            break;
                        }
                }
            }
            else
            {
                if (dateWithoutSlashies.IsMatch(dateString))
                {
                    /*
                    * It was too hard to deal with 3, 4, 5, and 7 digit date strings without slashes,
                    * so I limited it to 6 (MMDDYY) or 8 (MMDDYYYY) to avoid ambiguity.
                    * For example, 12101 could be:
                    *       1/21/01 => Jan 21, 2001
                    *       12/1/01 => Dec 01, 2001
                    *       12/10/1 => Dec 10, 2001
                    * 
                    * Limiting it to 6 or 8 digits is much easier to deal with. Boo hoo if they have to
                    * enter leading zeroes.
                    */

                    // All should parse without problems, since we ensured it was a string of digits
                    dateString = dateString.Insert(4, "/").Insert(2, "/");
                }

                try
                {
                    dateToReturn = DateTime.Parse(dateString);
                }
                catch
                {
                    throw new FormatException(ERROR_USAGE);
                }
            }

            if (IsDateSQLValid(dateToReturn))
            {
                if (dateToReturn <= maxDate)
                {
                    return dateToReturn.ToString(DATE_FORMAT);
                }

                throw new ApplicationException(string.Format(ERROR_DATE_ABOVE_MAX_FORMAT, maxDate.ToString(DATE_FORMAT)));
            }

            throw new ApplicationException(String.Format(ERROR_INVALID_SQL_DATE_FORMAT, SqlMinDate.ToString(DATE_FORMAT), SqlMaxDate.ToString(DATE_FORMAT)));
        }

        /// <summary>
        /// Converts a string of the form:
        /// 
        /// "T [+-] \d{1,4}[dwmy]" (spaces optional, case insensitive)
        /// 
        /// to a number of days/weeks/months/years to add/subtract from the current date.
        /// </summary>
        /// <param name="dateString"></param>
        /// <param name="amountToAdd"></param>
        /// <param name="unitsToAdd"></param>
        private static void GetAmountAndUnitsToModifyDate(string dateString, out int amountToAdd, out string unitsToAdd)
        {
            GroupCollection groups = todayPlusOrMinus.Match(dateString).Groups;

            amountToAdd = 0;
            unitsToAdd = "d";

            string amountWithPossibleUnits = groups[1].Value;
            string possibleUnits = groups[2].Value;

            if (null == amountWithPossibleUnits ||
                0 == amountWithPossibleUnits.Trim().Length)
            {
                return;
            }

            // Strip out the whitespace
            string stripped = Regex.Replace(amountWithPossibleUnits, @"\s", "");

            if (null == possibleUnits ||
                0 == possibleUnits.Trim().Length)
            {
                amountToAdd = Int32.Parse(stripped);
                return;
            }

            // Should have a parseable integer followed by a units indicator (d/w/m/y)
            // Remove the units indicator from the end, so we have a parseable integer.
            stripped = stripped.Remove(stripped.LastIndexOf(possibleUnits));

            amountToAdd = Int32.Parse(stripped);
            unitsToAdd = possibleUnits;
        }

        public static bool IsDateSQLValid(string dt) { return IsDateSQLValid(DateTime.Parse(dt)); }

        /// <summary>
        /// Make sure the range of dates is valid for SQL Server
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static bool IsDateSQLValid(DateTime dt)
        {
            return (dt >= SqlMinDate && dt <= SqlMaxDate);
        }
    }
}

The only example in your list that might be difficult would be "Last June", but you could just calculate the string to pass in by figuring out how many months it's been since last June.

int monthDiff = (DateTime.Now.Month + 6) % 12;

if(monthDiff == 0) monthDiff = 12;
string lastJuneCode = string.Format("T - {0}m", monthDiff);

Of course, that'll depend on the accuracy of DateTime's AddMonths function, and I haven't really tested edge cases for that. It should give you a DateTime last June, and you could just use that to find the first and last of the month.

Everything else should be fairly easy to map or parse with regular expressions. For example:

• Last week => "t - 1w"
• Yesterday => "t - 1d"
• Last year => "t - 1y"
• Next week => "t + 1w"
• Tomorrow => "t + 1d"
• Next year => "t + 1y"

Answer 2

The parsing is quite easy. It can be implemented as bunch of regexps and some date calculations.

The sample below can be easily extended to suit your needs. I've roughly tested it and it works at least for the following strings:

• next month, next year,
• next 4 months, next 3 days
• 3 days ago, 5 hours ago
• tomorrow, yesterday
• last year, last month,
• last tue, next fri
• last june, next may,
• jan 2008, 01 january 2009,
• june 2019, 2009/01/01

The helper class:

class FuzzyDateTime
{

    static List<string> dayList = new List<string>() { "sun", "mon", "tue", "wed", "thu", "fri", "sat" };
    static List<IDateTimePattern> parsers = new List<IDateTimePattern>()
    {
       new RegexDateTimePattern (
            @"next +([2-9]\d*) +months",
            delegate (Match m) {
                var val = int.Parse(m.Groups[1].Value); 
                return DateTime.Now.AddMonths(val);
            }
       ),
       new RegexDateTimePattern (
            @"next +month",
            delegate (Match m) { 
                return DateTime.Now.AddMonths(1);
            }
       ),           
       new RegexDateTimePattern (
            @"next +([2-9]\d*) +days",
            delegate (Match m) {
                var val = int.Parse(m.Groups[1].Value); 
                return DateTime.Now.AddDays(val);
            }
       ),

       new RegexDateTimePattern (
            @"([2-9]\d*) +months +ago",
            delegate (Match m) {
                var val = int.Parse(m.Groups[1].Value); 
                return DateTime.Now.AddMonths(-val);
            }
       ),
       new RegexDateTimePattern (
            @"([2-9]\d*) days +ago",
            delegate (Match m) {
                var val = int.Parse(m.Groups[1].Value); 
                return DateTime.Now.AddDays(-val);
            }
       ),
       new RegexDateTimePattern (
            @"([2-9]\d*) *h(ours)? +ago",
            delegate (Match m) {
                var val = int.Parse(m.Groups[1].Value); 
                return DateTime.Now.AddMonths(-val);
            }
       ),
       new RegexDateTimePattern (
            @"tomorrow",
            delegate (Match m) {
                return DateTime.Now.AddDays(1);
            }
       ),
       new RegexDateTimePattern (
            @"today",
            delegate (Match m) {
                return DateTime.Now;
            }
       ),
       new RegexDateTimePattern (
            @"yesterday",
            delegate (Match m) {
                return DateTime.Now.AddDays(-1);
            }
       ),
       new RegexDateTimePattern (
            @"(last|next) *(year|month)",
            delegate (Match m) {
                int direction = (m.Groups[1].Value == "last")? -1 :1;
                switch(m.Groups[2].Value) 
                {
                    case "year":
                        return new DateTime(DateTime.Now.Year+direction, 1,1);
                    case "month":
                        return new DateTime(DateTime.Now.Year, DateTime.Now.Month+direction, 1);
                }
                return DateTime.MinValue;
            }
       ),
       new RegexDateTimePattern (
            String.Format(@"(last|next) *({0}).*", String.Join("|", dayList.ToArray())), //handle weekdays
            delegate (Match m) {
                var val = m.Groups[2].Value;
                var direction = (m.Groups[1].Value == "last")? -1 :1;
                var dayOfWeek = dayList.IndexOf(val.Substring(0,3));
                if (dayOfWeek >= 0) {
                    var diff = direction*(dayOfWeek - (int)DateTime.Today.DayOfWeek);
                    if (diff <= 0 ) { 
                        diff = 7 + diff;
                    }
                    return DateTime.Today.AddDays(direction * diff);
                }
                return DateTime.MinValue;
            }
       ),

       new RegexDateTimePattern (
            @"(last|next) *(.+)", // to parse months using DateTime.TryParse
            delegate (Match m) {
                DateTime dt;
                int direction = (m.Groups[1].Value == "last")? -1 :1;
                var s = String.Format("{0} {1}",m.Groups[2].Value, DateTime.Now.Year + direction);
                if (DateTime.TryParse(s, out dt)) {
                    return dt;
                } else {
                    return DateTime.MinValue;
                }
            }
       ),
       new RegexDateTimePattern (
            @".*", //as final resort parse using DateTime.TryParse
            delegate (Match m) {
                DateTime dt;
                var s = m.Groups[0].Value;
                if (DateTime.TryParse(s, out dt)) {
                    return dt;
                } else {
                    return DateTime.MinValue;
                }
            }
       ),
    };

    public static DateTime Parse(string text)
    {
        text = text.Trim().ToLower();
        var dt = DateTime.Now;
        foreach (var parser in parsers)
        {
            dt = parser.Parse(text);
            if (dt != DateTime.MinValue)
                break;
        }
        return dt;
    }
}
interface IDateTimePattern
{
    DateTime Parse(string text);
}

class RegexDateTimePattern : IDateTimePattern
{
    public delegate DateTime Interpreter(Match m);
    protected Regex regEx;
    protected Interpreter inter;
    public RegexDateTimePattern(string re, Interpreter inter)
    {
        this.regEx = new Regex(re);
        this.inter = inter;
    }
    public DateTime Parse(string text)
    {
        var m = regEx.Match(text);

        if (m.Success)
        {
            return inter(m);
        }
        return DateTime.MinValue;
    }
}

Usage example:

var val = FuzzyDateTime.Parse(textBox1.Text);
if (val != DateTime.MinValue)
   label1.Text = val.ToString();
else
   label1.Text = "unknown value";

Answer 3

We have a similar control. We just add a list of combo boxes - controls to pick your choice.

PeriodSelector:

• From [datepicker] Until [datepicker]
• [numericupdown] months ago
• [numericupdown] hours ago
• Last week
• Yesterday
• Week [datepicker]
• Day [datepicker]
• ...

And just take the choices that make sense for your purpose.

It's a lot easier to implement this then parsing the text. The calculations are rather straightforward.

It's important to see that you are picking a period. Last year means from january 2008 > december 2008. Two hours ago from now untill now - 2 hours. Etc.

Answer 4

There is a bug in Piotr Czapla's answer:

new RegexDateTimePattern (
            @"([2-9]\d*) *h(ours)? +ago",
            delegate (Match m) {
                var val = int.Parse(m.Groups[1].Value); 
                return DateTime.Now.AddMonths(-val);
            }
       ),

AddMonths is used instead of AddHours().

PS: I can't comment on his answer because of low forum points. I've already wasted time on debugging it of why it removes 5 days when I try with "5 hours ago".