We Keep Coding

How to get next working day with the input of number of days? [duplicate]

This question already has answers here:
How to get the next working day, excluding weekends and holidays
(5 answers)
Closed 3 years ago.
I set up some methods to get holidays and used them to calculate next working day. This works fine but it only adds 1 day and gets the next non holiday weekday. I want to get the number of days by input and increment that date according to input and get the nex non holiday weekday. I tried some things but couldnt get exactly what i want.
Edit: I am using a method to get the next working day, excluding weekends and holidays. But my equation does that by incrementing the date only by 1 day. I want that number of days to be my input from user, and add that number to the date, exclude weekends and holidays and get the next working day. (My issue is on the adding that different number from my textbox)
public static DateTime GetWorkingDay(DateTime date, IList<Holiday> holidays, IList<DayOfWeek> weekendDays)
{
date = date.Date.AddDays(1);
var holidayDates = holidays.Select(x => x.GetDate(date.Year))
.Union(holidays.Select(x => x.GetDate(date.Year + 1)))
.Where(x => x != null)
.Select(x => x.Value)
.OrderBy(x => x).ToArray();
while (true)
{
if (weekendDays.Contains(date.DayOfWeek) || holidayDates.Contains(date))
date = date.AddDays(1);
else
return date;
}
}

You could change your while loop to (assuming numDays is your input):
while (numDays > 0)
{
date = date.AddDays(1);
if (!weekendDays.Contains(date.DayOfWeek) && !holidayDates.Contains(date))
numDays--; // Only decrement numDays if it's a working day.
}
Then return the date after the loop. You might want to assert that numDays isn't negative.

Here's an approach that might help. Or it might seem like total overkill. You decide.
Instead of trying to add one day at a time, figure out if it's a holiday, weekday, etc., just create a list of dates that you can query. That will make the logic much easier to understand, especially if you find yourself having to write more and more queries like this.
Ideally this is something you'd want to create once and keep around. It wouldn't make sense to keep creating this over and over.
Here's a stab at it:
public class Calendar
{
private readonly List<CalendarDate> _dates = new List<CalendarDate>();
public Calendar(
DateTime startDate,
int length,
ICollection<DateTime> holidays,
ICollection<DayOfWeek> weekDays)
{
if(length < 1)
throw new ArgumentOutOfRangeException(nameof(length), "The minimum length is one day.");
for (var x = 0; x < length; x++)
{
var addingDate = new CalendarDate
{
RepresentedDate = startDate.Date.AddDays(x),
};
addingDate.IsHoliday = holidays.Contains(addingDate.RepresentedDate);
addingDate.IsWeekday = weekDays.Contains(addingDate.RepresentedDate.DayOfWeek);
_dates.Add(addingDate);
}
FirstDay = startDate.Date;
LastDay = FirstDay.AddDays(length - 1);
}
public DateTime FirstDay { get; }
public DateTime LastDay { get; }
private class CalendarDate
{
internal DateTime RepresentedDate { get; set; }
internal bool IsHoliday { get; set; }
internal bool IsWeekday { get; set; }
internal bool IsWorkingDay => !(IsHoliday || IsWeekday);
}
public DateTime GetNextWorkingDay(DateTime date)
{
date = date.Date;
ValidateDateIsInRange(date);
var result = _dates.FirstOrDefault(d =>
d.RepresentedDate >= date && d.IsWorkingDay);
if (result != null) return result.RepresentedDate;
throw new InvalidOperationException("The result is outside the range of the calendar.");
}
private void ValidateDateIsInRange(DateTime date)
{
if(date < FirstDay || date > LastDay)
throw new InvalidOperationException("The specified date is outside the range of the calendar.");
}
}
It admittedly looks like more work and more code. But the result is that once the data is in place, the calculation you're trying to do becomes very easy. So do all sorts of other calculations and queries, because now such functions can be written to reflect the questions that you're asking, like "What is the first date that matches this criteria?"

Is this a good algorithm to find each week in a given month?

I need to take a month (defined as a start and end date) and return a set of date ranges for each week in that month. A week is defined as Sunday through Saturday. A good way to visualize it is if you double click on your Windows date in the start bar:
The month of October 2011 has 6 weeks: 10/1-10/1, 10/2-10/8, 10/9-10/15, 10/16-10/22, 10/23-10/29 and 10/30-10/31.
I can describe each week as a struct:
struct Range
{
public DateTime Start;
public DateTime End;
public Range(DateTime start, DateTime end)
{
Start = start;
End = end;
}
}
I need to write a function that takes a month and returns an array of ranges within it. Here's my first attempt, which appears to work and addresses the obvious edge cases:
public static IEnumerable<Range> GetRange(DateTime start, DateTime end)
{
DateTime curStart = start;
DateTime curPtr = start;
do
{
if (curPtr.DayOfWeek == DayOfWeek.Saturday)
{
yield return new Range(curStart, curPtr);
curStart = curPtr.AddDays(1);
}
curPtr = curPtr.AddDays(1);
} while (curPtr <= end);
if(curStart <= end)
yield return new Range(curStart, end);
}
I would like to know if there's a cleaner or more obvious approach to do the same. I'm not overly concerned about performance, but I'd like to improve code readability and make the algorithm a bit more concise. Perhaps there's a very creative solution involving a single LINQ expression or something. Thanks!

This is based on simply incrementing by 7, as suggested by Previti, ready for international use. If your C# is < 4.0, remove the default parameter = DayOfWeek.Sunday
public static IEnumerable<Range> GetRange(DateTime start, DateTime end, DayOfWeek startOfTheWeek = DayOfWeek.Sunday)
{
if (start > end)
{
throw new ArgumentException();
}
// We "round" the dates to the beginning of the day each
start = start.Date;
end = end.Date;
// The first week. It could be "shorter" than normal. We return it "manually" here
// The 6 + startOfWeek - start.DayOfWeek will give us the number of days that you
// have to add to complete the week. It's mod 7. It's based on the idea that
// the starting day of the week is a parameter.
DateTime curDay = new DateTime(Math.Min(start.AddDays((6 + (int)startOfTheWeek - (int)start.DayOfWeek) % 7).Ticks, end.Ticks), start.Kind);
yield return new Range(start, curDay);
curDay = curDay.AddDays(1);
while (curDay <= end)
{
// Each time we add 7 (SIX) days. This is because the difference between
// as considered by the problem, it's only 6 * 24 hours (because the week
// doesn't end at 23:59:59 of the last day, but at the beginning of that day)
DateTime nextDay = new DateTime(Math.Min(curDay.AddDays(6).Ticks, end.Ticks), start.Kind);
yield return new Range(curDay, nextDay);
// The start of the next week
curDay = nextDay.AddDays(1);
}
}
Some small notes: Math.Min isn't defined for DateTime, so I cheat a little by taking the Ticks of the DateTimes and comparing them. Then I rebuild the DateTime. I always use the DateTimeKind of the start date.
When you debug yield code, remember to "materialize" the result through the use of ToList or ToArray, otherwise the code won't be executed :-)

Calculate Monday-Sunday week from a DateTime object

I'm trying to write a method that will return a list of DateTimes representing a Monday-Sunday week. Its supposed to take the DateTime given to it and use it to calculate the surrounding dates
It calculates the starting date ok but the problem begins when it hits the last loop. With each run through the DateTime variable tmpDate should be incremented by 1 day, then added to the list. However, as it stands I'm getting back a List containing 7 starting dates.
Can anyone see where I'm going wrong (I have the feeling I may be made to look like a bit of a simpleton on this :) )?
Also, apologies if this is an often-asked question. Could see plenty of Start date/End Date and week number type questions, but none specifically dealing with this type of problem.
private List<DateTime> getWeek(DateTime enteredDate)
{
/* Create List to hold the dates */
List<DateTime> week = new List<DateTime>();
int enteredDatePosition = (int)enteredDate.DayOfWeek;
/* Determine first day of the week */
int difference = 0;
for (int i = 0; i < 7; i++)
{
difference++;
if (i == enteredDatePosition)
{
break;
}
}
// 2 subtracted from difference so first and enteredDatePostion elements will not be counted.
difference -= 2;
DateTime startDate = enteredDate.Subtract(new TimeSpan(difference, 0, 0, 0));
week.Add(startDate);
/* Loop through length of a week, incrementing date & adding to list with each iteration */
DateTime tmpDate = startDate;
for (int i = 1; i < 7; i++)
{
tmpDate.Add(new TimeSpan(1, 0, 0, 0));
week.Add(tmpDate);
}
return week;
}

DateTimes are immutable.
tmpDate.Add(...) returns a new DateTime, and does not modify tmpDate.
You should write tmpDate = tmpDate.AddDays(1) or tmpDate += TimeSpan.FromDays(1)

I believe this snippet is tailored towards Sunday trough Saturday, but you can try something like this:
DateTime ToDate = DateTime.Now.AddDays((6 - (int)DateTime.Now.DayOfWeek) - 7);
DateTime FromDate = ToDate.AddDays(-6);

You're making your algorithm more complex than it needs to be. Check out this working snippet:
using System;
using System.Collections.Generic;
public class MyClass
{
public static void Main()
{
// client code with semi-arbitrary DateTime suuplied
List<DateTime> week = GetWeek(DateTime.Today.AddDays(-2));
foreach (DateTime dt in week) Console.WriteLine(dt);
}
public static List<DateTime> GetWeek(DateTime initDt)
{
// walk back from supplied date until we get Monday and make
// that the initial day
while (initDt.DayOfWeek != DayOfWeek.Monday)
initDt = initDt.AddDays(-1.0);
List<DateTime> week = new List<DateTime>();
// now enter the initial day into the collection and increment
// and repeat seven total times to get the full week
for (int i=0; i<7; i++)
{
week.Add(initDt);
initDt = initDt.AddDays(1.0);
}
return week;
}
}

Calculate StartDate when End Date & back days given

I am developing c#.net solution where i have to calculate Start Date based on provided End date and Duration (back days) without weekends.
i.e. End Date: 05/5/2011
Back days: 5
Start Date = (05/5/2011) - 5 days (Excludes weekends)
Start Date = 29/04/2011
thanks you,

Something like this is probably what I'd do:
DateTime CalcStartDate(DateTime endTime, int daysBack)
{
DateTime startTime = endTime.Date;
while (daysBack > 0)
{
startTime = startTime.AddDays(-1);
if (startTime.DayOfWeek != DayOfWeek.Saturday && startTime.DayOfWeek != DayOfWeek.Sunday)
{
--daysBack;
}
}
return startTime;
}
Or even better, Bala's suggestion of using a library. Date and time is messy, a hardened/tested library is usually a good choice.

Bala R has the answer correctly. Here is a link to an article on how to use the AddBusinessDays() method:
http://www.codeproject.com/KB/cs/AddBusinessDay.aspx

I don't know how far back you are going to go. If it is a lot of days back then looping through the days might be a little CPU intensive. Well, probably not with modern processors...
I decided to implement a solution without a loop.
My code is a little more difficult to read, but it should be more efficient performance-wise.
public static class DateTimeExtensions
{
public static DateTime SubtractBusinessDays(this DateTime fromDateTime, int days)
{
var subtractDays = days % 5;
var dayNumber = fromDateTime.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)fromDateTime.DayOfWeek;
var addDays = Math.Max(dayNumber - 5, 0);
var result = fromDateTime.AddDays(addDays - subtractDays - (days / 5 * 7));
if ((addDays + dayNumber) % 7 <= subtractDays)
result = result.AddDays(-2);
return result;
}
}

A tricky DateTime algorithm problem

.NET gives me the current time in both local and UTC time zones (or any other) in the DateTime struct.
Given only hour/minute variables, find when the next occurrence of this time period (eg 6:30 PM/AM) will occur, with the ability to retrieve more future times at will.
It sounds easy but indeed friends this has been breaking my noodle for a good while.
Edit:
Example:
~-------|now|------??-----------|future known time|------------~
~-------2pm------??2-----------9am------------~
??2 = 19

If I understand correctly you want to know how much time has to pass in order to hit the next given hour:minute. You can use the TimeSpan struct for this.
//this is your target time from 1 to 12 h
var future = new TimeSpan(11, 30, 0);
//TimeOfDay gives you the time elapsed since midnight as a TimeSpan
var difference = future.Subtract(DateTime.Now.TimeOfDay);
//check for negative TimeSpan,
//it means the target time occurs on the next day, just add 24 hours
if (difference < TimeSpan.Zero)
difference = difference.Add(TimeSpan.FromDays(1));
Now you have a TimeSpan that represents what you need. You can use its properties to express it as you seem fit. For example:
difference.TotalHours; //(double) total time as a fractional hour
difference.Hours; //(int) just the hour component of the total time
As for retreiving more future times (am and pm), you can just add 12 more hours to difference to get the next occurence.

This was cooded in stackoverflow form, so it's probably there are some typos. Either way, you'll get the big picture.
public DateTime search(int hour, int min) {
if (hour >= 12)
return partialSearch(hour - 12, hour, min);
else
return partialSearch(hour, hour + 12, min);
}
public DateTime partialSearch(int morningHour, int afternoonHour, int min) {
DateTime now = DateTime.now;
if (now.hour == morningHour || now.hour == afternoonHour) {
if (now.minutes <= min) {
return now.AddMinutes(min - now.minutes);
}
now = now.AddHour(1);
}
now = now.AddMinutes(-now.Minutes); // set the minutes to 0
while(now.hour != morningHour || now.hour != afternoonHour) {
now = now.AddHour(1);
}
return now.addMinutes(min);
}

Not sure if I fully understood your requirements, but it seems you are looking for something like this?
public class TimeIterator
{
public DateTime CurrDateTime { get; set; }
public IEnumerable<DateTime> GetTimes(short count)
{
for (short i = 1; i <= count; i++)
yield return this.CurrDateTime.AddHours(i * 12);
}
public TimeIterator()
{
this.CurrDateTime = DateTime.Now;
}
}
This code can be easily adjusted to work with any time interval - not just 12 hour interval