How to know if a DateTime is between a DateRange in C#

Question

I need to know if a Date is between a DateRange. I have three dates:

// The date range
DateTime startDate;
DateTime endDate;

DateTime dateToCheck;

The easy solution is doing a comparison, but is there a smarter way to do this?

Avogadro

A smarter way then just checking if the date is between those dates? – Ralleigh

So what is smarter than an easy solution? – Eileen

Answer 1

Nope, doing a simple comparison looks good to me:

return dateToCheck >= startDate && dateToCheck < endDate;

Things to think about though:

• DateTime is a somewhat odd type in terms of time zones. It could be UTC, it could be "local", it could be ambiguous. Make sure you're comparing apples with apples, as it were.
• Consider whether your start and end points should be inclusive or exclusive. I've made the code above treat it as an inclusive lower bound and an exclusive upper bound.

Caban

Yes. Making sure that the DateTimes you compare are of the same kind(UTC/Local) is important. With different kinds the raw time will be compared instead of converting both to a common kind. – Spellbinder

return startDate <= dateToCheck && dateToCheck < endDate seems slightly more readable. – Myeshamyhre

@MauricioMorales: It depends; some people find it easier to read "the bit that's varying" (the date to check) being on the left hand side consistently. That's what I tend to do. I can see the advantages of the "in chronological order" approach too, but I think I'd personally prefer the way I've got it. – Caban

@MauricioMorales when deciding which side of a comparison to write first, I always pick the object being checked, instead of the value it is being compared to. That seems most logical to me. So in this case, where dateToCheck is the object being checked, I would write it first (on both sides of the &&) like @JonSkeet did. – Gambado

Answer 2

Usually I create Fowler's Range implementation for such things.

public interface IRange<T>
{
    T Start { get; }
    T End { get; }
    bool Includes(T value);
    bool Includes(IRange<T> range);
}

public class DateRange : IRange<DateTime>         
{
    public DateRange(DateTime start, DateTime end)
    {
        Start = start;
        End = end;
    }

    public DateTime Start { get; private set; }
    public DateTime End { get; private set; }

    public bool Includes(DateTime value)
    {
        return (Start <= value) && (value <= End);
    }

    public bool Includes(IRange<DateTime> range)
    {
        return (Start <= range.Start) && (range.End <= End);
    }
}

Usage is pretty simple:

DateRange range = new DateRange(startDate, endDate);
range.Includes(date)

Uninterested

Just a silly observation, doesn't the constructor need to ensure that start is less than end, if it doesn't, it would break the logic ... especially on the Includes(IRange<DateTime> range) – Bootee

Man this is such an good solution it even work with LINQ. Like so: var valueFromVacationsList =vacationBookingsForThisMonth.FirstOrDefault(s => (s.Id == currentUser.Id)&&new DateRange(s.StartDateTime, s.EndDateTime).Includes(itemDate)); – Schizogenesis

Be cautions using the above. An inclusive range-end value can cause edge condition bugs when dealing with continuous ranges like datetime. – Mimosaceous

Can you explain what you mean @TN? What type of bug could this introduce? – Petrol

@Petrol - The problem is that closed intervals (where both end conditions are inclusive) work well for discrete data types like integer or date-only, but are not well-suited for continuous-value types like float or date/time. Let say you needed to define a range that includes all date/times for May 2024. If you set the end-datetime to 2024-05-31, you include 00:00:00` on that date, but exclude all other times on that last day of the month. If you set it to 2024-06-01, you include the entire month, but also include 2024-06-01 00:00:00. (Continued...) – Mimosaceous

(...Continued) You could try 2024-05-31 23:59:59, but that still omits most of the last second. You could try ... 23:59:59.999 ... 23:59:59.999999 or ... 23:59:59.997, but that is data-type dependent and your application may have a different end value from the database. The solution is to define the range as a half-open interval with an inclusive start date/time 2024-05-01 00:00 and an exclusive end-date/time 2024-06-01 00:00. The test for inclusion is then `start-date/time <= value and value < end-date/time. Duration, adjacency, and overlap calculations are also simplified. – Mimosaceous

Answer 3

You could use extension methods to make it a little more readable:

public static class DateTimeExtensions
{
    public static bool InRange(this DateTime dateToCheck, DateTime startDate, DateTime endDate)
    {
        return dateToCheck >= startDate && dateToCheck < endDate;
    }
}

Now you can write:

dateToCheck.InRange(startDate, endDate)

Stipulate

nice approach, though I'd use IsInRange() as the function name – Bronez

Answer 4

You can use:

return (dateTocheck >= startDate && dateToCheck <= endDate);

Churchyard

Answer 5

I’ve found the following library to be the most helpful when doing any kind of date math. I’m still amazed nothing like this is part of the .Net framework.

http://www.codeproject.com/Articles/168662/Time-Period-Library-for-NET

Schizoid

I agree. I cannot believe .NET has no native date math assemblies. Thanks for sharing the library – Monoclinous

I used the Time Period library for a project that created schedules for when electronic signs were supposed to display images and it was a real time-saver. Heck, I can't imagine having completed that project w/o the Time Period library. – Chiou

Answer 6

Following on from Sergey's answer, I think this more generic version is more in line with Fowler's Range idea, and resolves some of the issues with that answer such as being able to have the Includes methods within a generic class by constraining T as IComparable<T>. It's also immutable like what you would expect with types that extend the functionality of other value types like DateTime.

public struct Range<T> where T : IComparable<T>
{
    public Range(T start, T end)
    {
        Start = start;
        End = end;
    }

    public T Start { get; }

    public T End { get; }

    public bool Includes(T value) => Start.CompareTo(value) <= 0 && End.CompareTo(value) >= 0;

    public bool Includes(Range<T> range) => Start.CompareTo(range.Start) <= 0 && End.CompareTo(range.End) >= 0;
}

Gladiator

Answer 7

In case anyone wants it as a Validator

using System;
using System.ComponentModel.DataAnnotations;

namespace GROOT.Data.Validation;

internal class DateRangeAttribute : ValidationAttribute
{
    public string EndDate;
    public string StartDate;

    public override bool IsValid(object value)
    {
        return (DateTime)value >= DateTime.Parse(StartDate) && (DateTime)value <= DateTime.Parse(EndDate);
    }
}

Usage

[DateRange(
    StartDate = "01/01/2020",
    EndDate = "01/01/9999",
    ErrorMessage = "Property is outside of range")
    ]

Mandragora