In this article, we will learn how to calculate the number of days between two dates, a task commonly encountered in various applications. We will achieve this by utilizing the DateTime struct, TimeSpan struct, and DateTimeOffset.

Let’s start.

## Understanding Date Handling in C#

Whether it’s booking a hotel room, checking flight schedules, or managing project timelines, there’s often a need to determine the duration between selected dates.

Date handling in C# is important because it enables us to work with dates and times efficiently. It allows us to perform calculations, comparisons, and manipulations with dates, which is essential for a wide range of applications.

Now that we understand the importance of date handling, let’s note that in this article we will use the `Days` property of the `TimeSpan` struct. However, it’s beneficial to be aware of another property called `TotalDays`. The key difference is that `TotalDays` provides the entire duration of the time interval in days as a `double`, including both full and partial days, where `Days` only counts complete 24-hour periods and returns therefore an `int` value.

That said, let’s take a look at some practical examples.

## Calculate the Number of Days Between Dates

Most of us can relate to the excitement of summer vacation, with some of us even counting down the days until the vacation finally begins.

Drawing from this shared experience, let’s see how we can calculate the number of days from today until the start of summer vacation:

```var summerVacationStart = new DateTime(2024, 6, 1);
var currentDate = DateTime.Today;```

First, we define `summerVacationStart` as a `DateTime` struct, representing the start of summer vacation on June 1st, 2024. This is achieved by specifying the year, month, and day in the `DateTime` constructor.

After that, we create a `DateTime` struct named `currentDate` using `DateTime.Today`, which automatically sets it to the current date.

In C#, the `DateTime` struct is specifically designed to handle dates and times.

To learn more about `DateTime`, check out our other article DateTime Format In C#.

Now that we understand how the `DateTime` struct works, let’s continue by calculating the number of days:

```public static int CalculateDaysUntilVacation(DateTime summerVacationStart, DateTime currentDate)
{
TimeSpan daysUntilVacation = summerVacationStart - currentDate;

return daysUntilVacation.Days;
}```

Here, we create a `TimeSpan` struct named `daysUntilVacation`. `TimeSpan` is designed to represent time intervals. In this case, it represents the duration between two dates.

To learn more, take a look at our other article TimeSpan in C#.

By subtracting `currentDate` from `summerVacationStart`, we calculate the time interval between these two dates.Â The `Days` property of `daysUntilVacation` then gives us the total number of full days until summer vacation starts.

Now, let’s put our method into action:

```int daysUntilVacation = NumberOfDaysBetweenTwoDates.CalculateDaysUntilVacation(summerVacationStart, currentDate);
Console.WriteLine(\$"Days until summer vacation: {daysUntilVacation}");```

Here, we define `daysUntilVacation` which utilizes the `CalculateDaysUntilVacation()` method that we created earlier.

Given today’s date, which is January 13, 2024, let’s check the output:

`Days until summer vacation: 140`

This shows how many full days we have left until summer vacation starts.

Now we have successfully calculated the number of days between dates. But what if one of the dates was in a different time zone?Â

## Different Time Zone Calculation

Imagine we have an international online event scheduled for September 1, 2024, at 10 a.m. in New York City, and we want to calculate how many days remain until this event from today, taking into account our local time zone.

To accurately count the days until our event we can use `DateTimeOffset`:

```var eventDateTime = new DateTimeOffset(2024, 9, 1, 10, 0, 0, new TimeSpan(-5, 0, 0));
var currentDateTime = DateTimeOffset.Now;```

Here, we define `eventDateTime`, which is the event’s date and time in Eastern Standard Time. To do this, we use the `DateTimeOffset` struct which pairs a `DateTime` value with an offset calculating the time difference from Coordinated Universal Time (UTC). This allows us to handle dates and times in specific time zones accurately.

Then, we initialize `currentDateTime`, which represents the current date and time in our local time zone.

To learn more about `DateTimeOffset`, check out our great article DateTimeOffset vs DateTime in C#.

Now that `currentDateTime` is set, we can calculate the days remaining until the event:

```public static int CalculateDaysUntilEvent(DateTimeOffset eventDateTime, DateTimeOffset currentDateTime)
{
TimeSpan daysUntilEvent = eventDateTime - currentDateTime;

return daysUntilEvent.Days;
}```

Here, we calculate `daysUntilEvent`, which is the number of days between the two dates considering they are in different time zones. Then, similar to what we did before, we can access the total number of days by using the `Days` property.

Now, let’s apply our new method:

```int daysUntilEvent = NumberOfDaysBetweenTwoDates.CalculateDaysUntilEvent(eventDateTime, currentDateTime);
Console.WriteLine(\$"Days until the event: {daysUntilEvent}");```

Finally, we define `daysUntilEvent`, which uses the `CalculateDaysUntilEvent()` method we created earlier.Â

After running this code, let’s check the console:

`Days until the event: 231`

In this scenario, today’s date, January 13, 2024, leaves us with 231 days until our event.

## Conclusion

In this article, we have learned how to calculate the number of days between two dates in C#. We started with a simple yet familiar scenario: the anticipation of a summer vacation. By using the DateTime and TimeSpan structs, we were able to determine the number of days until school ends and we are free to enjoy our long break.Â

Additionally, we talked about handling dates in different time zones with DateTimeOffset, which can be helpful when planning international events. Understanding and applying these techniques is crucial for effective date and time management in C# applications.