Manipulating date and time values is a common programming problem in many applications. Have you ever wondered how we can calculate the number of weekdays between two dates? Knowing how to do this can be crucial in scheduling, project management, or resource allocation applications. In this article, we analyze some techniques we can use to determine the number of weekdays between two dates in C#.Â

## Determine the Number of Weekdays Between Two Dates in C#

We can leverage the DateTime class to calculate the number of weekdays between two dates in C#:

```public static int CalculateBusinessDays(DateTime startDate, DateTime endDate)
{
var weekdays = 0;

for (var currentDate = startDate; currentDate < endDate; currentDate = currentDate.AddDays(1))
{
if (IsWorkDay(currentDate))
{
weekdays++;
}
}

return weekdays;
}

private static bool IsWorkDay(DateTime date)
{
return date.DayOfWeek is not DayOfWeek.Saturday
and not DayOfWeek.Sunday;
}```

Here, we use the DayOfWeek property in the `DateTime` class to check which day of the week the `currentDate` value falls on. We add the weekdays value only when we encounter weekdays and ignore weekends. Our implementation has an O(N) time complexity, where N is the number of days between the start and end dates. Therefore, our implementation could have performance issues for large date ranges.Â

Also, we can verify that our solution returns accurate results:

```var startDate = new DateTime(2024, 1, 1);
var endDate = new DateTime(2024, 1, 15);
var expectedWeekdays = 10;

Assert.IsInstanceOfType(actualWeekdays, typeof(int));
Assert.AreEqual(expectedWeekdays, actualWeekdays);```

Here, we verify ten weekdays between the 1st and the 15th of January 2024. Besides that, we check whether our `CalculateBusinessDays()` method returns an integer.Â

## How to Add Weekdays to a Start Date

Sometimes, we may want to add business days to a start date to get an end date. Let’s implement a solution that helps us accomplish our goal:

```public static DateTime AddWorkDays(DateTime startDate, int workDays)
{
var endDate = startDate;

while (workDays > 0)
{

if (IsWorkDay(endDate))
{
workDays--;
}
}

return endDate;
}```

Here, we initialize `endDate` with the value in the `startDate` variable. Next, we iterate while checking whether the `endDate` value falls on a weekend and decreases the value of `workDays` if the condition is `true`. We repeat the process while invoking `endDate.AddDays(1)`Â to increment the value of `endDate` by one until `workDays` becomes zero.Â

Finally, we can verify the method returns accurate results:

```var startDate = new DateTime(2024, 1, 1);
var expectedDate = new DateTime(2024, 1, 15);

Assert.IsInstanceOfType(actualDate, typeof(DateTime));
Assert.AreEqual(expectedDate, actualDate);```

We invoke the `AddWorkDays()` method and add ten days to the start date to confirm that we get the 15th of January 2024 as the result.Â

## Determine the Number of Weekdays, Taking Holidays Into Account

Our previous examples assume that we are not considering public holidays that fall on weekdays. For example, Thanksgiving Day falls on Thursday every year. When implementing weekday calculations in HR systems, we may be required to accommodate public holidays in different countries. We can take advantage of .NET-based third-party date libraries such as Nager.Date to accomplish our goal.Â Â

First, let’s write a function that accepts a country code and year as parameters and returns an array of date strings that fall on public holidays:

```private static async Task<string[]> GetHolidaysAsync(int year, string countryCode)
{
HttpClient httpClient = new();
var url = \$"https://date.nager.at/api/v3/PublicHolidays/{year}/{countryCode}";
var response = await httpClient.GetStringAsync(url);
var holidays = JArray.Parse(response);
var holidayDates = new string[holidays.Count];

for (var i = 0; i < holidays.Count; i++)
{
holidayDates[i] = holidays[i]["date"].ToString();
}

return holidayDates;
}```

Here, we use `HttpClient` to make a GET request to the API while passing the `year` and `countryCode`. Once we get the HTTP response, we use the JArray.Parse() method to load the JSON string into a JArray object. Finally, we read the object’s values and add them to a string array containing holiday dates, which we return as an array of date strings.Â

Note that `HttpClient` is designed for reuse within an application, so declaring it, using it once in a method, and not disposing of it (or implementing a using statement) can be problematic in practice (i.e., lead to socket exhaustion if such a method was called repeatedly).

Therefore, we can modify our previous example to support public holidays:

```public static async Task<int> CalculateBusinessDaysExcludingHolidaysAsync(DateTime startDate, DateTime endDate,
string countryCode)
{
var weekDays = 0;
var holidaysArray = await GetHolidaysAsync(startDate.Year, countryCode);
var holidays = new HashSet<string>(holidaysArray);

for (var currentDate = startDate.Date; currentDate < endDate.Date;)
{
if (IsWorkDay(currentDate))
{
var currentDateStr = currentDate.ToString("yyyy-MM-dd");

if (!holidays.Contains(currentDateStr))
{
weekDays++;
}
}

currentDate = currentDate.AddDays(currentDate.DayOfWeek == DayOfWeek.Friday ? 3 : 1);
}

return weekDays;
}```

Here, we add a check to assess whether the `currentDate` is among the public holidays returned from our `GetHolidaysAsync()` implementation. Finally, we add three days if `currentDate` is on a Friday.

Likewise, we can also add workdays to a start date while considering public holidays:

```public static async Task<DateTime> AddWorkDaysExcludingHolidaysAsync(DateTime startDate, int workDays,
string countryCode)
{
var endDate = startDate;
var holidays = await GetHolidaysAsync(startDate.Year, countryCode);

while (workDays > 0)
{

if (IsWorkDay(endDate) && !holidays.Contains(endDate.ToString("yyyy-MM-dd")))
{
workDays--;
}
}

return endDate;
}```

Like our previous example,Â we iterate while checking whether the `endDate` value falls on a weekend and not a public holiday and decreases the value of `workDays` if the conditions are `true`.Â Â

## Conclusion

In this article, we’ve explored how to determine the number of weekdays between two dates in C#. Which technique or library do you prefer when extracting public holidays and why? Let us know in the comments below.Â