AddBusinessDays и GetBusinessDays


93

Мне нужно найти 2 элегантные полные реализации

public static DateTime AddBusinessDays(this DateTime date, int days)
{
 // code here
}

and 

public static int GetBusinessDays(this DateTime start, DateTime end)
{
 // code here
}

O (1) предпочтительнее (без петель).

РЕДАКТИРОВАТЬ: Под рабочими днями я подразумеваю рабочие дни (понедельник, вторник, среда, четверг, пятница). Никаких праздников, исключая только выходные.

У меня уже есть некоторые уродливые решения, которые, кажется, работают, но мне интересно, есть ли изящные способы сделать это. Благодарность


Это то, что я написал до сих пор. Он работает во всех случаях, а также на негатив. Все еще нужна реализация GetBusinessDays

public static DateTime AddBusinessDays(this DateTime startDate,
                                         int businessDays)
{
    int direction = Math.Sign(businessDays);
    if(direction == 1)
    {
        if(startDate.DayOfWeek == DayOfWeek.Saturday)
        {
            startDate = startDate.AddDays(2);
            businessDays = businessDays - 1;
        }
        else if(startDate.DayOfWeek == DayOfWeek.Sunday)
        {
            startDate = startDate.AddDays(1);
            businessDays = businessDays - 1;
        }
    }
    else
    {
        if(startDate.DayOfWeek == DayOfWeek.Saturday)
        {
            startDate = startDate.AddDays(-1);
            businessDays = businessDays + 1;
        }
        else if(startDate.DayOfWeek == DayOfWeek.Sunday)
        {
            startDate = startDate.AddDays(-2);
            businessDays = businessDays + 1;
        }
    }

    int initialDayOfWeek = (int)startDate.DayOfWeek;

    int weeksBase = Math.Abs(businessDays / 5);
    int addDays = Math.Abs(businessDays % 5);

    if((direction == 1 && addDays + initialDayOfWeek > 5) ||
         (direction == -1 && addDays >= initialDayOfWeek))
    {
        addDays += 2;
    }

    int totalDays = (weeksBase * 7) + addDays;
    return startDate.AddDays(totalDays * direction);
}

14
Есть ли элегантные решения, когда дело касается такой нелогичной вещи, как финики?
— Wyatt Barnett

Вас интересуют праздники? - Джеймс Конильяро. Нет
— Адриан Занеску

9
Избегать людей, которые пытаются помочь, не является выигрышной стратегией.
— Jamie Ide

1
Краткое примечание о AddBusinessDaysреализации в вопросе выше (который на самом деле был удаленным ответом, который я предлагал восстановить; вместо этого мод скопировал этот ответ на вопрос): на мой взгляд, это решение пока лучше, чем все ответы, потому что это единственное тот, который правильно работает с отрицательными значениями, суббота и воскресенье в качестве источника и не требует сторонней библиотеки. (Я сделал небольшую программу для тестирования различных решений здесь.) Я бы добавил только if (businessDays == 0) return startDate;в начале метода, чтобы получить правильный результат и для этого пограничного случая.
— Slauma

1
@AZ .: Первое удаление было довольно старым. После моего запроса на восстановление вашего ответа мод восстановил ответ (на 30 секунд), чтобы скопировать содержимое под вашим вопросом, а затем снова удалил его. Вот почему в вашем ответе есть отметка времени недавнего удаления. Я написал комментарий выше, потому что для моей цели ваше AddBusinessDaysрешение здесь было наиболее общим, которое работало во всех необходимых мне случаях. Я скопировал его в один из моих текущих проектов (после небольшой модификации и перевода на C ++), спасибо за код :) Это очень помогло, так как на удивление сложно получить все граничные случаи правильно.
— Slauma

Ответы:


135

Последняя попытка вашей первой функции:

public static DateTime AddBusinessDays(DateTime date, int days)
{
    if (days < 0)
    {
        throw new ArgumentException("days cannot be negative", "days");
    }

    if (days == 0) return date;

    if (date.DayOfWeek == DayOfWeek.Saturday)
    {
        date = date.AddDays(2);
        days -= 1;
    }
    else if (date.DayOfWeek == DayOfWeek.Sunday)
    {
        date = date.AddDays(1);
        days -= 1;
    }

    date = date.AddDays(days / 5 * 7);
    int extraDays = days % 5;

    if ((int)date.DayOfWeek + extraDays > 5)
    {
        extraDays += 2;
    }

    return date.AddDays(extraDays);

}

Вторую функцию GetBusinessDays можно реализовать следующим образом:

public static int GetBusinessDays(DateTime start, DateTime end)
{
    if (start.DayOfWeek == DayOfWeek.Saturday)
    {
        start = start.AddDays(2);
    }
    else if (start.DayOfWeek == DayOfWeek.Sunday)
    {
        start = start.AddDays(1);
    }

    if (end.DayOfWeek == DayOfWeek.Saturday)
    {
        end = end.AddDays(-1);
    }
    else if (end.DayOfWeek == DayOfWeek.Sunday)
    {
        end = end.AddDays(-2);
    }

    int diff = (int)end.Subtract(start).TotalDays;

    int result = diff / 7 * 5 + diff % 7;

    if (end.DayOfWeek < start.DayOfWeek)
    {
        return result - 2;
    }
    else{
        return result;
    }
}

Для второго одно решение - взять разницу между датой и датой + дни. Это хорошо тем, что гарантирует правильную синхронизацию двух функций и устраняет избыточность.
— Брайан

Кормить текущую дату, запускать от 0 до 10 рабочих дней, всегда не удается в среду.
— Адриан Годонг,

1
Да, в конце концов мы добрались до цели. (Я говорю «мы» за мой крошечный вклад!) Проголосовал за усилия.
— Noldorin

Спасибо за ваш вклад, Нолдорин, к сожалению, я могу только проголосовать за ваши комментарии!
— Патрик Макдональд,

3
DateTime.AddDays работает с отрицательными числами. Это не соответствует тому же шаблону, что и использование отрицательных чисел с AddBusinessDays, позволяющее выбирать нерабочие дни.
— Ristogod

63

с использованием Fluent DateTime :

var now = DateTime.Now;
var dateTime1 = now.AddBusinessDays(3);
var dateTime2 = now.SubtractBusinessDays(5);

внутренний код выглядит следующим образом

    /// <summary>
    /// Adds the given number of business days to the <see cref="DateTime"/>.
    /// </summary>
    /// <param name="current">The date to be changed.</param>
    /// <param name="days">Number of business days to be added.</param>
    /// <returns>A <see cref="DateTime"/> increased by a given number of business days.</returns>
    public static DateTime AddBusinessDays(this DateTime current, int days)
    {
        var sign = Math.Sign(days);
        var unsignedDays = Math.Abs(days);
        for (var i = 0; i < unsignedDays; i++)
        {
            do
            {
                current = current.AddDays(sign);
            }
            while (current.DayOfWeek == DayOfWeek.Saturday ||
                current.DayOfWeek == DayOfWeek.Sunday);
        }
        return current;
    }

    /// <summary>
    /// Subtracts the given number of business days to the <see cref="DateTime"/>.
    /// </summary>
    /// <param name="current">The date to be changed.</param>
    /// <param name="days">Number of business days to be subtracted.</param>
    /// <returns>A <see cref="DateTime"/> increased by a given number of business days.</returns>
    public static DateTime SubtractBusinessDays(this DateTime current, int days)
    {
        return AddBusinessDays(current, -days);
    }

Это единственное решение, которое действительно сработало для меня при преобразовании в VB.Net
— Николас

1
OP не запрашивал циклов, а у этого явно есть циклы. Нет ничего элегантного в том, чтобы делать что-то наименее эффективным способом.
— Neolisk

13

Я создал расширение, которое позволяет добавлять или вычитать рабочие дни. Для вычитания используйте отрицательное число рабочих дней. Думаю, это довольно изящное решение. Вроде работает во всех случаях.

namespace Extensions.DateTime
{
    public static class BusinessDays
    {
        public static System.DateTime AddBusinessDays(this System.DateTime source, int businessDays)
        {
            var dayOfWeek = businessDays < 0
                                ? ((int)source.DayOfWeek - 12) % 7
                                : ((int)source.DayOfWeek + 6) % 7;

            switch (dayOfWeek)
            {
                case 6:
                    businessDays--;
                    break;
                case -6:
                    businessDays++;
                    break;
            }

            return source.AddDays(businessDays + ((businessDays + dayOfWeek) / 5) * 2);
        }
    }
}

Пример:

using System;
using System.Windows.Forms;
using Extensions.DateTime;

namespace AddBusinessDaysTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            label1.Text = DateTime.Now.AddBusinessDays(5).ToString();
            label2.Text = DateTime.Now.AddBusinessDays(-36).ToString();
        }
    }
}

Результат сомнительный, если исходная дата - суббота или воскресенье. Например: суббота + 1 рабочий день приводит к вторнику, тогда как я бы предпочел понедельник.
— Slauma

3
@Slauma: Так работает большинство предприятий в Канаде. +1 рабочий день = "следующий рабочий день", в случае субботы это вторник. Понедельник будет «тем же рабочим днем».
— Neolisk

3
Программа @Slauma работает по назначению. Подумайте об этом логически. Если что-то, связанное с бизнесом, начинается в субботу, и вы должны дать людям возможность отреагировать в течение одного рабочего дня в течение указанного рабочего дня, имеет ли смысл сказать им, что это должно быть сделано до понедельника ?!
— Riegardt Steyn 02

8

Мне нужно было найти решение, которое пропускало бы выходные и переходило либо в отрицательное, либо в положительное значение. Мои критерии заключались в том, что если он продвигается и приземляется в выходные, его нужно продвигать до понедельника. Если бы он возвращался и приземлился в выходные, ему пришлось бы перейти на пятницу.

Например:

  • Среда - 3 рабочих дня = Прошлая пятница
  • Среда + 3 рабочих дня = понедельник
  • Пятница - 7 рабочих дней = последняя среда
  • Вторник - 5 рабочих дней = последний вторник

Ну вы поняли;)

Я закончил писать этот класс расширения

public static partial class MyExtensions
{
    public static DateTime AddBusinessDays(this DateTime date, int addDays)
    {
        while (addDays != 0)
        {
            date = date.AddDays(Math.Sign(addDays));
            if (MyClass.IsBusinessDay(date))
            {
                addDays = addDays - Math.Sign(addDays);
            }
        }
        return date;
    }
}

Он использует этот метод, который, я подумал, было бы полезно использовать в другом месте ...

public class MyClass
{
    public static bool IsBusinessDay(DateTime date)
    {
        switch (date.DayOfWeek)
        {
            case DayOfWeek.Monday:
            case DayOfWeek.Tuesday:
            case DayOfWeek.Wednesday:
            case DayOfWeek.Thursday:
            case DayOfWeek.Friday:
                return true;
            default:
                return false;
        }
    }
}

Если вы не хотите возиться с этим, вы можете просто заменить его if (MyClass.IsBusinessDay(date))на ifif ((date.DayOfWeek != DayOfWeek.Saturday) && (date.DayOfWeek != DayOfWeek.Sunday))

Итак, теперь вы можете сделать

var myDate = DateTime.Now.AddBusinessDays(-3);

или

var myDate = DateTime.Now.AddBusinessDays(5);

Вот результаты некоторых тестов:

Ожидаемый результат теста
Среда -4 рабочих дня четверг четверг
Среда -3 рабочих дня Пятница Пятница
Среда +3 рабочих дня Понедельник Понедельник
Пятница -7 рабочих дней среда среда
Вторник -5 рабочих дней вторник вторник
Пятница +1 рабочие дни понедельник понедельник
Суббота +1 рабочий день понедельник понедельник
Воскресенье -1 рабочий день Пятница Пятница
Понедельник -1 рабочий день пятница пятница
Понедельник +1 рабочие дни вторник вторник
Понедельник +0 рабочих дней Понедельник Понедельник

Я также сделал второй метод методом расширения: public static bool IsBusinessDay (эта дата DateTime)
— Andy B

2
public static DateTime AddBusinessDays(this DateTime date, int days)
{
    date = date.AddDays((days / 5) * 7);

    int remainder = days % 5;

    switch (date.DayOfWeek)
    {
        case DayOfWeek.Tuesday:
            if (remainder > 3) date = date.AddDays(2);
            break;
        case DayOfWeek.Wednesday:
            if (remainder > 2) date = date.AddDays(2);
            break;
        case DayOfWeek.Thursday:
            if (remainder > 1) date = date.AddDays(2);
            break;
        case DayOfWeek.Friday:
            if (remainder > 0) date = date.AddDays(2);
            break;
        case DayOfWeek.Saturday:
            if (days > 0) date = date.AddDays((remainder == 0) ? 2 : 1);
            break;
        case DayOfWeek.Sunday:
            if (days > 0) date = date.AddDays((remainder == 0) ? 1 : 0);
            break;
        default:  // monday
            break;
    }

    return date.AddDays(remainder);
}

1

Я опаздываю за ответом, но я сделал небольшую библиотеку со всеми настройками, необходимыми для выполнения простых операций в рабочие дни ... Я оставляю ее здесь: Управление рабочими днями


2
К сожалению, это лицензировано GNU, поэтому это «юридический яд» для любого коммерческого приложения. Есть ли шанс, что вы смягчите это до «MIT» или «Apache»?
— Тони О'Хаган

Некоторые статические списки, вероятно, должны быть массивами (а не связанными списками).
— Тони О'Хаган

1
Я просто изменил лицензию на MIT (я не хочу ничего блокировать на столь простом). Я рассмотрю ваше другое предложение.
— Boneless

Приятно, было бы интересно увидеть управление рабочим днем ​​по странам, поскольку в некоторых странах могут быть другие рабочие дни, кроме понедельника по пятницу.
— сериализатор

1

Единственное реальное решение - предоставить этим вызовам доступ к таблице базы данных, которая определяет календарь для вашего бизнеса. Вы можете без труда запрограммировать его на рабочую неделю с понедельника по пятницу, но обработка праздников будет проблемой.

Отредактировано для добавления неэлегантного и непроверенного частичного решения:

public static DateTime AddBusinessDays(this DateTime date, int days)
{
    for (int index = 0; index < days; index++)
    {
        switch (date.DayOfWeek)
        {
            case DayOfWeek.Friday:
                date = date.AddDays(3);
                break;
            case DayOfWeek.Saturday:
                date = date.AddDays(2);
                break;
            default:
                date = date.AddDays(1);
                break;
         }
    }
    return date;
}

Также я нарушил требование об отсутствии петель.


Я не думаю, что субботнее дело когда-нибудь будет раскрыто.
— CoderDennis,

@Dennis - было бы, если бы дата была суббота.
— Jamie Ide

Я взял на себя смелость отредактировать ваш код, чтобы он работал. Пожалуйста, проверьте код, прежде чем размещать его в следующий раз, спасибо.
— bytecode77

И я думал, что нулевое количество голосов говорит само за себя. Благодарность!
— Джейми Иде

1

Я воскрешаю этот пост, потому что сегодня мне нужно было найти способ исключить не только субботу и воскресенье, но и праздничные дни. В частности, мне нужно было обработать различные наборы возможных праздников, в том числе:

  • загородные праздники (по крайней мере, для западных стран - например, 01 января).
  • рассчитанные праздники (например, Пасха и Пасхальный понедельник).
  • национальные праздники (например, День освобождения Италии или ID4 США).
  • городские праздники (например, День святого покровителя в Риме).
  • любой другой праздник по индивидуальному заказу (например, «завтра наш офис будет закрыт»).

В конце концов, я выпустил следующий набор классов помощников / расширений: хотя они не выглядят явно элегантными, поскольку в них широко используются неэффективные циклы, они достаточно приличны, чтобы решить мои проблемы навсегда. Я оставляю весь исходный код здесь, в этом посте, надеясь, что он будет полезен и кому-то еще.

Исходный код

/// <summary>
/// Helper/extension class for manipulating date and time values.
/// </summary>
public static class DateTimeExtensions
{
    /// <summary>
    /// Calculates the absolute year difference between two dates.
    /// </summary>
    /// <param name="dt1"></param>
    /// <param name="dt2"></param>
    /// <returns>A whole number representing the number of full years between the specified dates.</returns>
    public static int Years(DateTime dt1,DateTime dt2)
    {
        return Months(dt1,dt2)/12;
        //if (dt2<dt1)
        //{
        //    DateTime dt0=dt1;
        //    dt1=dt2;
        //    dt2=dt0;
        //}

        //int diff=dt2.Year-dt1.Year;
        //int m1=dt1.Month;
        //int m2=dt2.Month;
        //if (m2>m1) return diff;
        //if (m2==m1 && dt2.Day>=dt1.Day) return diff;
        //return (diff-1);
    }

    /// <summary>
    /// Calculates the absolute year difference between two dates.
    /// Alternative, stand-alone version (without other DateTimeUtil dependency nesting required)
    /// </summary>
    /// <param name="start"></param>
    /// <param name="end"></param>
    /// <returns></returns>
    public static int Years2(DateTime start, DateTime end)
    {
        return (end.Year - start.Year - 1) +
            (((end.Month > start.Month) ||
            ((end.Month == start.Month) && (end.Day >= start.Day))) ? 1 : 0);
    }

    /// <summary>
    /// Calculates the absolute month difference between two dates.
    /// </summary>
    /// <param name="dt1"></param>
    /// <param name="dt2"></param>
    /// <returns>A whole number representing the number of full months between the specified dates.</returns>
    public static int Months(DateTime dt1,DateTime dt2)
    {
        if (dt2<dt1)
        {
            DateTime dt0=dt1;
            dt1=dt2;
            dt2=dt0;
        }

        dt2=dt2.AddDays(-(dt1.Day-1));
        return (dt2.Year-dt1.Year)*12+(dt2.Month-dt1.Month);
    }

    /// <summary>
    /// Returns the higher of the two date time values.
    /// </summary>
    /// <param name="dt1">The first of the two <c>DateTime</c> values to compare.</param>
    /// <param name="dt2">The second of the two <c>DateTime</c> values to compare.</param>
    /// <returns><c>dt1</c> or <c>dt2</c>, whichever is higher.</returns>
    public static DateTime Max(DateTime dt1,DateTime dt2)
    {
        return (dt2>dt1?dt2:dt1);
    }

    /// <summary>
    /// Returns the lower of the two date time values.
    /// </summary>
    /// <param name="dt1">The first of the two <c>DateTime</c> values to compare.</param>
    /// <param name="dt2">The second of the two <c>DateTime</c> values to compare.</param>
    /// <returns><c>dt1</c> or <c>dt2</c>, whichever is lower.</returns>
    public static DateTime Min(DateTime dt1,DateTime dt2)
    {
        return (dt2<dt1?dt2:dt1);
    }

    /// <summary>
    /// Adds the given number of business days to the <see cref="DateTime"/>.
    /// </summary>
    /// <param name="current">The date to be changed.</param>
    /// <param name="days">Number of business days to be added.</param>
    /// <param name="holidays">An optional list of holiday (non-business) days to consider.</param>
    /// <returns>A <see cref="DateTime"/> increased by a given number of business days.</returns>
    public static DateTime AddBusinessDays(
        this DateTime current, 
        int days, 
        IEnumerable<DateTime> holidays = null)
    {
        var sign = Math.Sign(days);
        var unsignedDays = Math.Abs(days);
        for (var i = 0; i < unsignedDays; i++)
        {
            do
            {
                current = current.AddDays(sign);
            }
            while (current.DayOfWeek == DayOfWeek.Saturday
                || current.DayOfWeek == DayOfWeek.Sunday
                || (holidays != null && holidays.Contains(current.Date))
                );
        }
        return current;
    }

    /// <summary>
    /// Subtracts the given number of business days to the <see cref="DateTime"/>.
    /// </summary>
    /// <param name="current">The date to be changed.</param>
    /// <param name="days">Number of business days to be subtracted.</param>
    /// <param name="holidays">An optional list of holiday (non-business) days to consider.</param>
    /// <returns>A <see cref="DateTime"/> increased by a given number of business days.</returns>
    public static DateTime SubtractBusinessDays(
        this DateTime current, 
        int days,
        IEnumerable<DateTime> holidays)
    {
        return AddBusinessDays(current, -days, holidays);
    }

    /// <summary>
    /// Retrieves the number of business days from two dates
    /// </summary>
    /// <param name="startDate">The inclusive start date</param>
    /// <param name="endDate">The inclusive end date</param>
    /// <param name="holidays">An optional list of holiday (non-business) days to consider.</param>
    /// <returns></returns>
    public static int GetBusinessDays(
        this DateTime startDate, 
        DateTime endDate,
        IEnumerable<DateTime> holidays)
    {
        if (startDate > endDate)
            throw new NotSupportedException("ERROR: [startDate] cannot be greater than [endDate].");

        int cnt = 0;
        for (var current = startDate; current < endDate; current = current.AddDays(1))
        {
            if (current.DayOfWeek == DayOfWeek.Saturday
                || current.DayOfWeek == DayOfWeek.Sunday
                || (holidays != null && holidays.Contains(current.Date))
                )
            {
                // skip holiday
            }
            else cnt++;
        }
        return cnt;
    }

    /// <summary>
    /// Calculate Easter Sunday for any given year.
    /// src.: https://stackoverflow.com/a/2510411/1233379
    /// </summary>
    /// <param name="year">The year to calcolate Easter against.</param>
    /// <returns>a DateTime object containing the Easter month and day for the given year</returns>
    public static DateTime GetEasterSunday(int year)
    {
        int day = 0;
        int month = 0;

        int g = year % 19;
        int c = year / 100;
        int h = (c - (int)(c / 4) - (int)((8 * c + 13) / 25) + 19 * g + 15) % 30;
        int i = h - (int)(h / 28) * (1 - (int)(h / 28) * (int)(29 / (h + 1)) * (int)((21 - g) / 11));

        day = i - ((year + (int)(year / 4) + i + 2 - c + (int)(c / 4)) % 7) + 28;
        month = 3;

        if (day > 31)
        {
            month++;
            day -= 31;
        }

        return new DateTime(year, month, day);
    }

    /// <summary>
    /// Retrieve holidays for given years
    /// </summary>
    /// <param name="years">an array of years to retrieve the holidays</param>
    /// <param name="countryCode">a country two letter ISO (ex.: "IT") to add the holidays specific for that country</param>
    /// <param name="cityName">a city name to add the holidays specific for that city</param>
    /// <returns></returns>
    public static IEnumerable<DateTime> GetHolidays(IEnumerable<int> years, string countryCode = null, string cityName = null)
    {
        var lst = new List<DateTime>();

        foreach (var year in years.Distinct())
        {
            lst.AddRange(new[] {
                new DateTime(year, 1, 1),       // 1 gennaio (capodanno)
                new DateTime(year, 1, 6),       // 6 gennaio (epifania)
                new DateTime(year, 5, 1),       // 1 maggio (lavoro)
                new DateTime(year, 8, 15),      // 15 agosto (ferragosto)
                new DateTime(year, 11, 1),      // 1 novembre (ognissanti)
                new DateTime(year, 12, 8),      // 8 dicembre (immacolata concezione)
                new DateTime(year, 12, 25),     // 25 dicembre (natale)
                new DateTime(year, 12, 26)      // 26 dicembre (s. stefano)
            });

            // add easter sunday (pasqua) and monday (pasquetta)
            var easterDate = GetEasterSunday(year);
            lst.Add(easterDate);
            lst.Add(easterDate.AddDays(1));

            // country-specific holidays
            if (!String.IsNullOrEmpty(countryCode))
            {
                switch (countryCode.ToUpper())
                {
                    case "IT":
                        lst.Add(new DateTime(year, 4, 25));     // 25 aprile (liberazione)
                        break;
                    case "US":
                        lst.Add(new DateTime(year, 7, 4));     // 4 luglio (Independence Day)
                        break;

                    // todo: add other countries

                    case default:
                        // unsupported country: do nothing
                        break;
                }
            }

            // city-specific holidays
            if (!String.IsNullOrEmpty(cityName))
            {
                switch (cityName)
                {
                    case "Rome":
                    case "Roma":
                        lst.Add(new DateTime(year, 6, 29));  // 29 giugno (s. pietro e paolo)
                        break;
                    case "Milano":
                    case "Milan":
                        lst.Add(new DateTime(year, 12, 7));  // 7 dicembre (s. ambrogio)
                        break;

                    // todo: add other cities

                    default:
                        // unsupported city: do nothing
                        break;

                }
            }
        }
        return lst;
    }
}

Информация об использовании

Код не требует пояснений, однако вот пара примеров, объясняющих, как его можно использовать.

Добавьте 10 рабочих дней (пропуская только субботу и воскресенье будние дни)

var dtResult = DateTimeUtil.AddBusinessDays(srcDate, 10);

Добавьте 10 рабочих дней (пропуская субботу, воскресенье и все праздничные дни, не зависящие от страны в 2019 году)

var dtResult = DateTimeUtil.AddBusinessDays(srcDate, 10, GetHolidays(2019));

Добавьте 10 рабочих дней (без субботы, воскресенья и всех праздников Италии в 2019 году)

var dtResult = DateTimeUtil.AddBusinessDays(srcDate, 10, GetHolidays(2019, "IT"));

Добавьте 10 рабочих дней (пропуская субботу, воскресенье, все итальянские праздники и праздничные дни Рима на 2019 год)

var dtResult = DateTimeUtil.AddBusinessDays(srcDate, 10, GetHolidays(2019, "IT", "Rome"));

Вышеупомянутые функции и примеры кода более подробно описаны в этом посте моего блога.


0
    public static DateTime AddBusinessDays(DateTime date, int days)
    {
        if (days == 0) return date;
        int i = 0;
        while (i < days)
        {
            if (!(date.DayOfWeek == DayOfWeek.Saturday ||  date.DayOfWeek == DayOfWeek.Sunday)) i++;  
            date = date.AddDays(1);
        }
        return date;
    }

в будущем добавлю немного больше контекста для ответа и, возможно, зачем вы добавили то, что у вас есть :)
— dax

0

Мне нужен был AddBusinessDays, поддерживающий добавление отрицательного числа дней, и в итоге я получил следующее:

// 0 == Monday, 6 == Sunday
private static int epochDayToDayOfWeek0Based(long epochDay) {
    return (int)Math.floorMod(epochDay + 3, 7);
}

public static int daysBetween(long fromEpochDay, long toEpochDay) {
    // http://stackoverflow.com/questions/1617049/calculate-the-number-of-business-days-between-two-dates
    final int fromDOW = epochDayToDayOfWeek0Based(fromEpochDay);
    final int toDOW = epochDayToDayOfWeek0Based(toEpochDay);
    long calcBusinessDays = ((toEpochDay - fromEpochDay) * 5 + (toDOW - fromDOW) * 2) / 7;

    if (toDOW   == 6) calcBusinessDays -= 1;
    if (fromDOW == 6) calcBusinessDays += 1;
    return (int)calcBusinessDays;
}

public static long addDays(long epochDay, int n) {
    // https://alecpojidaev.wordpress.com/2009/10/29/work-days-calculation-with-c/
    // NB: in .NET, Sunday == 0, but in our code Monday == 0
    final int dow = (epochDayToDayOfWeek0Based(epochDay) + 1) % 7;
    final int wds = n + (dow == 0 ? 1 : dow); // Adjusted number of working days to add, given that we now start from the immediately preceding Sunday
    final int wends = n < 0 ? ((wds - 5) / 5) * 2
                            : (wds / 5) * 2 - (wds % 5 == 0 ? 2 : 0);
    return epochDay - dow + // Find the immediately preceding Sunday
           wds +            // Add computed working days
           wends;           // Add weekends that occur within each complete working week
}

Цикл не требуется, поэтому он должен быть достаточно быстрым даже для «больших» дополнений.

Он работает с днями, выраженными как количество календарных дней, прошедших с эпохи, поскольку это предоставляется новым классом JDK8 LocalDate, и я работал на Java. Однако должно быть легко адаптироваться к другим настройкам.

Фундаментальные свойства - это то, что addDaysвсегда возвращается будний день, и что для всех dи n,daysBetween(d, addDays(d, n)) == n

Обратите внимание, что теоретически добавление 0 дней и вычитание 0 дней должны быть разными операциями (если ваша дата - воскресенье, добавление 0 дней должно привести вас к понедельнику, а вычитание 0 дней должно привести вас к пятнице). Поскольку отрицательного 0 (кроме чисел с плавающей точкой!) Не существует, я решил интерпретировать аргумент n = 0 как означающий добавление нулевых дней.


0

Я считаю, что это может быть более простой способ провести GetBusinessDays:

    public int GetBusinessDays(DateTime start, DateTime end, params DateTime[] bankHolidays)
    {
        int tld = (int)((end - start).TotalDays) + 1; //including end day
        int not_buss_day = 2 * (tld / 7); //Saturday and Sunday
        int rest = tld % 7; //rest.

        if (rest > 0)
        {
            int tmp = (int)start.DayOfWeek - 1 + rest;
            if (tmp == 6 || start.DayOfWeek == DayOfWeek.Sunday) not_buss_day++; else if (tmp > 6) not_buss_day += 2;
        }

        foreach (DateTime bankHoliday in bankHolidays)
        {
            DateTime bh = bankHoliday.Date;
            if (!(bh.DayOfWeek == DayOfWeek.Saturday || bh.DayOfWeek == DayOfWeek.Sunday) && (start <= bh && bh <= end))
            {
                not_buss_day++;
            }
        }
        return tld - not_buss_day;
    }

0

Вот мой код с датой отправления и датой доставки клиенту.

            // Calculate departure date
            TimeSpan DeliveryTime = new TimeSpan(14, 30, 0); 
            TimeSpan now = DateTime.Now.TimeOfDay;
            DateTime dt = DateTime.Now;
            if (dt.TimeOfDay > DeliveryTime) dt = dt.AddDays(1);
            if (dt.DayOfWeek == DayOfWeek.Saturday) dt = dt.AddDays(1);
            if (dt.DayOfWeek == DayOfWeek.Sunday) dt = dt.AddDays(1);
            dt = dt.Date + DeliveryTime;
            string DepartureDay = "today at "+dt.ToString("HH:mm");
            if (dt.Day!=DateTime.Now.Day)
            {
                DepartureDay = dt.ToString("dddd at HH:mm", new CultureInfo(WebContextState.CurrentUICulture));
            }
            Return DepartureDay;

            // Caclulate delivery date
            dt = dt.AddDays(1);
            if (dt.DayOfWeek == DayOfWeek.Saturday) dt = dt.AddDays(1);
            if (dt.DayOfWeek == DayOfWeek.Sunday) dt = dt.AddDays(1);
            string DeliveryDay = dt.ToString("dddd", new CultureInfo(WebContextState.CurrentUICulture));
            return DeliveryDay;

Удачного кодирования.


0
public static DateTime AddWorkingDays(this DateTime date, int daysToAdd)
{
    while (daysToAdd > 0)
    {
        date = date.AddDays(1);

        if (date.DayOfWeek != DayOfWeek.Saturday && date.DayOfWeek != DayOfWeek.Sunday)
        {
            daysToAdd -= 1;
        }
    }

    return date;
}

0
public static int GetBusinessDays(this DateTime start, DateTime end)
            {
                return Enumerable.Range(0, (end- start).Days)
                                .Select(a => start.AddDays(a))
                                .Where(a => a.DayOfWeek != DayOfWeek.Sunday)
                                .Where(a => a.DayOfWeek != DayOfWeek.Saturday)
                                .Count();
    
            }

-1

Надеюсь, это кому-то поможет.

private DateTime AddWorkingDays(DateTime addToDate, int numberofDays)
    {
        addToDate= addToDate.AddDays(numberofDays);
        while (addToDate.DayOfWeek == DayOfWeek.Saturday || addToDate.DayOfWeek == DayOfWeek.Sunday)
        {
            addToDate= addToDate.AddDays(1);
        }
        return addToDate;
    }

2
Это неверно. В большинстве случаев это не сработает. Вряд ли кому-нибудь поможет.
— Neolisk
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.