Compare DateTime in C#

Updated on August 10, 2026

To compare two DateTime values in C#, we use the comparison operators (<, >, ==) for readability or DateTime.Compare() / CompareTo() when we need sort-style results. They all compare the underlying ticks and give identical answers.

The two real traps are elsewhere: none of these methods consider DateTimeKind, so we must convert to UTC before comparing values from different time zones, and sub-second precision means “equal-looking” values often aren’t.

However, before we jump right into the different ways of comparing DateTime, let’s first get an overview of what DateTime struct is.

What Is the DateTime Struct in C#?

In C#, the DateTime struct is a crucial component for handling date and time values.

It stores precise date and time information using a 64-bit integer value (ticks). It also provides us the ability to manipulate, format, and perform arithmetic operations on DateTime objects.

We have methods such as ToString() to present DateTime values in specific string representations, and methods like Add and Subtract, to manipulate the DateTime objects.

Two more properties worth knowing before we compare anything are DateTime.Now vs DateTime.UtcNow, since which one we pick upstream determines whether the comparisons below even make sense.

How Do We Compare DateTime in C#?

Comparing DateTime values are essential for a wide range of applications. C# provides several methods and operators for comparing DateTime values, including the Equals() method, the Compare() method, the CompareTo() method, and the various comparison operators.

The Equals method checks if two DateTime values are equal. Meanwhile, Compare() and CompareTo() methods return an integer indicating the relative values of two DateTime objects. The comparison operators <, >, <=, and >= provide a quick and easy way to compare two DateTime values.

Every built-in comparison (the relational operators, Equals(), Compare(), and CompareTo()) compares the same thing: the Ticks value, a count of 100-nanosecond intervals since 0001-01-01. That means they always agree with each other; we choose between them for ergonomics, not correctness.

Operators read best in conditions (if (start < end)). DateTime.Compare(a, b) and a.CompareTo(b) return −1, 0, or +1, which is what sorting and IComparer<T> implementations need. Equals() is simply == in method form.

What none of them do is interpret DateTimeKind: a local time and a UTC time are compared tick-for-tick as if they were in the same zone, so mixed-kind comparisons silently produce wrong answers. Microsoft Learn states it for DateTime.Compare() in one line: it “compares the Ticks property of t1 and t2 but ignores their Kind property.” The rule that keeps us safe: normalize both values with ToUniversalTime(), or store UTC everywhere and compare freely. For date-only logic, we compare the Date property or convert to DateOnly.

Compare(DateTime, DateTime)

The Compare(DateTime, DateTime) method in the DateTime struct returns an integer value that represents the relative values of two DateTime objects.

This method returns the integer values based on these conditions:

• The first DateTime object is earlier than the second, it returns a negative value
• The first DateTime object is later than the second, it returns a positive value
• The two DateTime objects are equal, it returns zero

Let’s understand it with an example:

var firstDate = new DateTime(2023, 5, 1);
var secondDate = new DateTime(2023, 5, 2);

var result = DateTime.Compare(firstDate, secondDate);

CompareTo(DateTime)

Similar to the Compare() method, the CompareTo(DateTime) method also returns an integer value that represents the relative values of two DateTime objects.

The criteria on which this method returns the integer value is the same as the Compare() method:

var firstDate = new DateTime(2023, 5, 1);
var secondDate = new DateTime(2023, 5, 2);

var result = firstDate.CompareTo(secondDate);

CompareTo(Object)

The CompareTo(Object) method takes an object as a parameter and returns an integer value that represents the relative values of the DateTime object and the other object.

The criteria on which this method returns the integer value is the same as the Compare() and CompareTo() methods:

var firstDate = new DateTime(2023, 5, 1);
object objectDateTime = new DateTime(2023, 5, 3);

var result = firstDate.CompareTo(objectDateTime);

This method will attempt to convert the other object to a DateTime object and then compare its value to the value of the original DateTime object. If the other object is not a DateTime object, the method will throw an ArgumentException.

This method is useful in situations where it is necessary to compare a DateTime object to another object that may not be a DateTime object, such as when comparing dates stored in different formats.

Equals(DateTime)

The Equals(DateTime) method in C# is used to determine whether two DateTime objects are equal.

DateTime.Equals(DateTime) compares the same Ticks value that == compares — the two are equivalent. Switching from == to Equals() does not solve precision mismatches on its own; it changes nothing about whether two values that print identically will compare equal.

This method returns true when both objects represent the same date and time, and false otherwise:

private static void DateTimeComparisonWithEquals(DateTime firstDate, DateTime secondDate)
{
    if (firstDate.Equals(secondDate))
    {
        Console.WriteLine($"{firstDate} is the same as {secondDate}");
    }
    else
    {
        Console.WriteLine($"{firstDate} is not the same as {secondDate}");
    }
}

DateTime Comparison Using Relational Operators

In C#, DateTime objects can be compared using relational operators like <, <=, >, and >=. These operators compare the date and time components of two DateTime objects and return a Boolean value indicating whether the comparison is true or false:

private static void DateTimeComparisonWithRelationalOperator(DateTime firstDate, DateTime secondDate)
{
    if (firstDate < secondDate)
    {
        Console.WriteLine($"{firstDate} is earlier than {secondDate}");
    }
    else if (firstDate > secondDate)
    {
        Console.WriteLine($"{firstDate} is later than {secondDate}");
    }
    else
    {
        Console.WriteLine($"{firstDate} is the same as {secondDate}");
    }
}

Relational operators can also be combined with the DateTime.Equals() method to check if a DateTime object falls within a certain range of dates. For the complete set of DateTime operators beyond comparison, we cover them in a dedicated article.

Why Are Two Equal-Looking DateTime Values Not Equal?

Because equality compares ticks exactly, two values that print identically can still differ. The usual culprits: one value carries milliseconds the other lost (databases and JSON serializers commonly truncate or round sub-second precision), one came from DateTime.Now and the other was reconstructed from its formatted string, or the two values have different DateTimeKind and were never normalized.

Our example makes the first case concrete: new DateTime(2021, 05, 06, 12, 0, 0) and new DateTime(2021, 05, 06, 12, 0, 0, 500) differ by 500 milliseconds, so == correctly returns false even though both display as 12:00:00.

The fix is to compare with the precision we actually mean. For date-only meaning, compare .Date or DateOnly. For round-trip-through-storage values, compare within a tolerance: (first - second).Duration() <= TimeSpan.FromMilliseconds(1). And when times cross zones, we compare DateTimeOffset values instead. Unlike DateTime, its operators account for the offset.

public static bool IsDatePrecisionSame()
{
    var firstDate = new DateTime(2021, 05, 06, 12, 0, 0);
    var secondDate = new DateTime(2021, 05, 06, 12, 0, 0, 500);

    return firstDate == secondDate;
}

Comparing with a tolerance, or by date only, gives us the other two answers the section above promises:

var tolerance = TimeSpan.FromMilliseconds(1);
var areClose = (firstDate - secondDate).Duration() <= tolerance;

var sameDay = firstDate.Date == secondDate.Date;
var sameDayViaDateOnly = DateOnly.FromDateTime(firstDate) == DateOnly.FromDateTime(secondDate);

Notice that areClose still returns a bool, so it drops into an if exactly like the equality operators earlier in the article; sameDay and sameDayViaDateOnly are two different routes to the same date-only answer.

Best Practices To Compare DateTime

Technique	Returns	Considers Kind?	Best for
a == b, a < b, a >= b ...	bool	No	Everyday checks, most readable
a.Equals(b)	bool	No	Same result as ==
DateTime.Compare(a, b)	int (-1/0/+1)	No	Sort semantics, IComparer
a.CompareTo(b)	int (-1/0/+1)	No	Sorting, range logic
a.Date == b.Date / DateOnly	bool	No	Date-only comparison
(a - b).Duration() <= tolerance	bool	No	Approximate equality after storage/serialization

Every row compares ticks and ignores Kind; converting both sides with ToUniversalTime() first is on us.

Store and compare in UTC. Microsoft’s guidance is the same sentence we would write ourselves: “When saving or sharing DateTime data, use UTC and set the DateTime value’s Kind property to DateTimeKind.Utc” (Compare types related to date and time, Microsoft Learn, read 2026-08-09).

public static bool IsDateInSameTimeZone()
{
    var firstDate = new DateTime(2021, 05, 06, 12, 0, 0, DateTimeKind.Local);
    var secondDate = new DateTime(2021, 05, 06, 12, 0, 0, DateTimeKind.Utc);
    var firstDateAsUtc = firstDate.ToUniversalTime();

    return firstDateAsUtc.Equals(secondDate);
}

The conversion, firstDate.ToUniversalTime(), is what makes this comparison correct; the Equals() call at the end does no more work than == would. Skip the conversion, and comparing a local time to a UTC time silently compares the wrong ticks.

Pick precision deliberately. For date-only meaning, compare .Date, or lean on DateOnly and TimeOnly in C# when the time component doesn’t matter at all; for values that round-tripped through storage or serialization, compare within a small tolerance instead of expecting an exact match.

Prefer DateTimeOffset vs DateTime for anything that crosses time zones. Its comparison operators account for the offset directly, so we don’t have to normalize to UTC by hand the way DateTime requires.

Conclusion

In this article, we learned about DateTime struct, different ways to compare DateTime with some examples and best practices for DateTime comparison in C#.

Tested with .NET 10.0.10.