Introduction

Counting working days in .NET usually means counting weekdays between two dates while excluding Saturday and Sunday, and sometimes also excluding holidays. The implementation is straightforward, but it helps to define the rules clearly first, especially whether the range is inclusive and whether time-of-day should be ignored.

Normalize to the Date Part First

If you are counting business days, the time portion usually does not matter. A common first step is to compare only the date component.

1DateTime start = new DateTime(2025, 1, 1, 14, 30, 0).Date;
2DateTime end = DateTime.Today;
3
4if (end < start)
5{
6    throw new ArgumentException("End date must be on or after the start date.");
7}

Using .Date avoids off-by-one confusion caused by partial days.

Count Weekdays with a Simple Loop

The clearest implementation is to walk day by day and count only Monday through Friday.

1using System;
2
3public static int CountWorkingDays(DateTime start, DateTime end)
4{
5    start = start.Date;
6    end = end.Date;
7
8    if (end < start)
9    {
10        throw new ArgumentException("End date must be on or after the start date.");
11    }
12
13    int count = 0;
14
15    for (DateTime day = start; day <= end; day = day.AddDays(1))
16    {
17        if (day.DayOfWeek != DayOfWeek.Saturday && day.DayOfWeek != DayOfWeek.Sunday)
18        {
19            count++;
20        }
21    }
22
23    return count;
24}

This version is inclusive of both start and end. If you want “since a date” to mean excluding the start day, move the loop to start.AddDays(1).

Excluding Holidays

Many business rules treat holidays as non-working days too. In that case, pass a set of holiday dates.

1using System;
2using System.Collections.Generic;
3
4public static int CountWorkingDays(DateTime start, DateTime end, HashSet<DateTime> holidays)
5{
6    start = start.Date;
7    end = end.Date;
8
9    if (end < start)
10    {
11        throw new ArgumentException("End date must be on or after the start date.");
12    }
13
14    int count = 0;
15
16    for (DateTime day = start; day <= end; day = day.AddDays(1))
17    {
18        bool isWeekend = day.DayOfWeek == DayOfWeek.Saturday || day.DayOfWeek == DayOfWeek.Sunday;
19        bool isHoliday = holidays.Contains(day);
20
21        if (!isWeekend && !isHoliday)
22        {
23            count++;
24        }
25    }
26
27    return count;
28}

A HashSet<DateTime> is a good choice because holiday lookups stay efficient.

A Practical Usage Example

1var holidays = new HashSet<DateTime>
2{
3    new DateTime(2025, 1, 1),
4    new DateTime(2025, 12, 25)
5};
6
7int workingDays = CountWorkingDays(
8    new DateTime(2025, 1, 1),
9    new DateTime(2025, 1, 10),
10    holidays
11);
12
13Console.WriteLine(workingDays);

This counts only weekdays in the range and subtracts any holidays that land on those weekdays.

When Performance Matters

For typical date ranges, the simple loop is perfectly acceptable and easier to trust. If you are computing across very large spans or doing this thousands of times, you can derive a faster arithmetic solution using full weeks plus leftover days.

But unless performance is proven to be a problem, the loop version is often the best tradeoff between correctness and readability.

DateOnly Can Be Cleaner in Modern .NET

If you are on a modern .NET version, DateOnly models this concept more directly because business-day logic is fundamentally date-only logic.

DateOnly start = new DateOnly(2025, 1, 1);
DateOnly end = new DateOnly(2025, 1, 10);

You can still implement the same weekday loop, but the type itself prevents time-of-day confusion.

Common Pitfalls

A common mistake is forgetting to strip the time portion and then wondering why comparisons behave strangely.

Another pitfall is not defining whether the start date counts. “Since a date” can mean inclusive or exclusive depending on the business rule.

Developers also sometimes forget that holidays should be compared as dates only. If one holiday value contains a time component, Contains checks may fail unexpectedly.

Finally, do not over-engineer the first implementation. A clear inclusive loop is easier to validate than a clever formula you do not trust.

Summary

• Normalize to the date part before counting working days.
• Count Monday through Friday and exclude Saturday and Sunday.
• Add a holiday set if business rules require it.
• Be explicit about whether the range is inclusive or exclusive.
• Prefer a simple readable loop unless performance data proves you need a more complex formula.