AddBusinessDays और GetBusinessDays

Question

मुझे 2 सुरुचिपूर्ण पूर्ण कार्यान्वयन खोजने की आवश्यकता है

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

and 

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

ओ (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);
}

Comments

क्या सुरुचिपूर्ण समाधान हैं जब यह तारीखों के रूप में अतार्किक के रूप में आता है?

— व्याट बार्नेट

क्या आप छुट्टियों से प्रभावित हैं? - जेम्स कॉनिग्लिआरो। नहीं

— एड्रियन ज़ैनस्कु

ऐसे लोगों को वोट देना जो मदद करने की कोशिश कर रहे हैं, जीतना रणनीति नहीं है।

— जेमी इडे

AddBusinessDaysऊपर दिए गए प्रश्न में कार्यान्वयन के बारे में संक्षिप्त नोट (जो वास्तव में हटाए गए उत्तर को हटाना रद्द करने का प्रस्ताव था, एक मॉड की नकल की बजाय प्रश्न का उत्तर दिया गया): मेरी राय में यह समाधान अब तक के सभी उत्तरों से बेहतर है क्योंकि यह एकमात्र है एक जो नकारात्मक मूल्यों, शनिवार और रविवार को स्रोत के रूप में सही ढंग से व्यवहार करता है और उसे तीसरे पक्ष के परिवाद की आवश्यकता नहीं होती है। (मैंने यहां अलग-अलग समाधानों का परीक्षण करने के लिए एक छोटा सा कार्यक्रम बनाया है।) मैं केवल if (businessDays == 0) return startDate;इस किनारे के मामले के लिए सही परिणाम प्राप्त करने के लिए विधि की शुरुआत में जोड़ूंगा।

— सुलामा

@AZ: पहला विलोपन काफी पुराना था। आपके उत्तर को रद्द करने के मेरे अनुरोध के बाद एक मॉड ने आपके प्रश्न के नीचे की सामग्री की प्रतिलिपि बनाने के लिए उत्तर (30 सेकंड के लिए) को हटा दिया था और फिर उसने इसे फिर से हटा दिया। इसीलिए आपके उत्तर में हाल ही में हटाए गए समय की मुहर है। मैंने ऊपर टिप्पणी लिखी है क्योंकि मेरे उद्देश्य के लिए आपका AddBusinessDaysसबसे सामान्य समाधान यहां था जो मुझे उन सभी मामलों में काम करना था जिनकी मुझे आवश्यकता है। मैंने इसे अपनी वर्तमान परियोजनाओं में से एक में कॉपी किया है (थोड़ी सी संशोधन और सी ++ में अनुवाद के बाद), कोड के लिए धन्यवाद :) यह बहुत मदद मिली क्योंकि आश्चर्यजनक रूप से सभी किनारे के मामलों को ठीक से प्राप्त करना मुश्किल है।

— सुलामा

Answer 1

अपने पहले समारोह के लिए नवीनतम प्रयास:

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;
    }
}

Comments

दूसरे के लिए, एक समाधान तारीख और तारीख + दिनों के बीच अंतर लेना है। इसमें यह अच्छा है कि यह गारंटी देता है कि दोनों फ़ंक्शन ठीक से सिंक करेंगे, और यह अतिरेक को हटा देता है।

— ब्रायन

फ़ीड की वर्तमान तिथि, 0 से 10 व्यावसायिक दिनों तक चलती है, यह बुधवार को हमेशा विफल रहता है।

— एड्रियन गोडोंग

हां, हम अंत में वहां पहुंच गए। (मैं अपने छोटे योगदान के लिए 'हम' कहता हूं!) प्रयास के लिए मतदान किया।

— नोल्डोरिन

आपके इनपुट Noldorin के लिए धन्यवाद, मैं केवल आपकी टिप्पणियों को दुर्भाग्य से बढ़ा सकता हूं!

— पैट्रिक मैकडोनाल्ड

DateTime.AddDays नकारात्मक संख्याओं के साथ काम करता है। यह ठीक से एक ही पैटर्न का पालन नहीं करता है क्योंकि AddBusinessDays के साथ नकारात्मक संख्याओं का उपयोग करके गैर-व्यावसायिक दिनों को चुना जा सकता है।

— रिस्तोगोड

Answer 2

धाराप्रवाह 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);
    }

Comments

यह एकमात्र समाधान है जो वास्तव में मेरे लिए काम किया जब वीबी.नेट

— निकोलस

ओपी ने कोई लूप नहीं मांगा, जबकि यह स्पष्ट रूप से लूप है। कम से कम कुशल तरीके से कुछ करने के बारे में सुरुचिपूर्ण कुछ भी नहीं है।

— नियोलिस्क

Answer 3

मैंने एक एक्सटेंशन बनाया जो आपको व्यावसायिक दिनों को जोड़ने या घटाने की अनुमति देता है। घटाए जाने के लिए व्यवसायी की नकारात्मक संख्या का उपयोग करें। मुझे लगता है कि यह काफी सुरुचिपूर्ण समाधान है। यह सभी मामलों में काम करने लगता है।

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();
        }
    }
}

Comments

परिणाम संदिग्ध है यदि स्रोत तिथि शनिवार या रविवार है। उदाहरण के लिए: शनिवार + शनिवार को 1 व्यावसायिक दिन परिणाम, जहां मैं सोमवार की अपेक्षा करूंगा।

— सलुमा

@ सलूमा: यह कनाडा में सबसे अधिक कारोबार कैसे संचालित होता है। +1 व्यावसायिक दिन = "अगला व्यावसायिक दिन", जो कि शनिवार के मामले में है। सोमवार "समान व्यवसाय दिवस" ​​होगा।

— नियोलिस्क

@ सलूमा कार्यक्रम उद्देश्य के अनुसार काम करता है इसके बारे में तार्किक रूप से सोचें। यदि शनिवार को कुछ व्यवसाय संबंधित बंद हो जाता है, और आपको 1 कार्यदिवस को लोगों को उक्त व्यवसाय दिवस की अवधि के दौरान प्रतिक्रिया करने की अनुमति देनी है, तो क्या उन्हें यह बताने का कोई मतलब होगा कि यह सोमवार तक किया जाना चाहिए ?!

— रिगार्ड्ट स्टेन

Answer 4

मेरे लिए मेरे पास एक ऐसा समाधान था जो सप्ताहांत को छोड़ देगा और नकारात्मक या सकारात्मक में चला जाएगा। मेरा मानदंड था अगर यह आगे बढ़ा और एक सप्ताहांत पर उतरा, जिसे सोमवार को आगे बढ़ने की आवश्यकता होगी। यदि यह वापस जा रहा था और एक सप्ताहांत पर उतरा, तो इसे शुक्रवार को कूदना होगा।

उदाहरण के लिए:

• बुधवार - 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))है, तो साथif ((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 कारोबारी दिन सोमवार सोमवार

Comments

मैंने दूसरी विधि को एक विस्तार विधि के रूप में अच्छी तरह से बनाया: सार्वजनिक स्थैतिक मल IsBusinessDay (यह तारीख समय)

— एंडी बी

Answer 5

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);
}

Answer 6

मैं उत्तर के लिए देर से आ रहा हूं, लेकिन मैंने काम के दिनों में सरल संचालन करने के लिए आवश्यक सभी अनुकूलन के साथ एक छोटी सी लाइब्रेरी बनाई ... मैं इसे यहां छोड़ता हूं: वर्किंग डेज़ मैनेजमेंट

Comments

दुर्भाग्य से यह जीएनयू लाइसेंस है इसलिए किसी भी व्यावसायिक ऐप के लिए "कानूनी जहर" है। कोई भी मौका आप इसे "एमआईटी" या "अपाचे" पर आराम देंगे?

— टोनी ओ'हागन

कुछ स्थिर सूचियों को संभवतः सरणियाँ (लिंक की गई सूचियों के बजाय) होनी चाहिए।

— टोनी ओ'हागन

मैंने सिर्फ लाइसेंस को MIT में बदल दिया (मैं उस सरल चीज़ पर कुछ भी ब्लॉक नहीं करना चाहता)। मैं आपके दूसरे प्रस्ताव पर ध्यान दूंगा।

— नालायक

अच्छा है, देश द्वारा कार्य दिवस प्रबंधन देखना दिलचस्प होगा क्योंकि कुछ देशों में सोमवार से शुक्रवार तक अन्य कार्य दिवस हो सकते हैं।

— धारावाहिक

Answer 7

एकमात्र वास्तविक समाधान यह है कि उन कॉलों के लिए डेटाबेस तालिका का उपयोग किया जाए जो आपके व्यवसाय के लिए कैलेंडर को परिभाषित करता है। आप इसे सोमवार से शुक्रवार वर्कवे के लिए बहुत मुश्किल के बिना कोड कर सकते हैं लेकिन छुट्टियों को संभालना एक चुनौती होगी।

गैर-सुरुचिपूर्ण और गैर-परीक्षणित आंशिक समाधान जोड़ने के लिए संपादित:

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;
}

इसके अलावा मैंने नो लूप्स की आवश्यकता का उल्लंघन किया।

Comments

मुझे नहीं लगता कि शनिवार का मामला कभी हिट होगा।

— कोडरडेन

@ डेनिस - अगर यह तारीख बीत जाती है तो शनिवार है।

— जेमी इडे

मैंने इसे काम करने के लिए आपके कोड को संपादित करने की स्वतंत्रता ली। अगली बार पोस्ट करने से पहले कृपया कोड का परीक्षण करें, धन्यवाद।

— bytecode77

और मुझे लगा कि शून्य उत्थान खुद के लिए बोलते हैं। धन्यवाद!

— जेमी आइडे

Answer 8

मैं इस पद को पुनः प्राप्त कर रहा हूं क्योंकि आज मुझे न केवल शनिवार और रविवार सप्ताह में बल्कि छुट्टियों को भी बाहर करने का रास्ता खोजना पड़ा । विशेष रूप से, मुझे संभव छुट्टियों के विभिन्न सेटों को संभालने की आवश्यकता थी, जिनमें शामिल हैं:

• देश-आक्रमणकारी छुट्टियां (कम से कम पश्चिमी देशों के लिए - जैसे कि जनवरी, 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"));

उपरोक्त कार्यों और कोड उदाहरणों को मेरे ब्लॉग के इस पोस्ट में आगे बताया गया है ।

Answer 9

    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;
    }

Comments

भविष्य में उत्तर के लिए थोड़ा और संदर्भ जोड़ें और हो सकता है कि आपने जो कुछ भी रखा हो :)

— dax

Answer 10

मैं एक "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 लोकलडेट वर्ग द्वारा उजागर किया गया है और मैं जावा में काम कर रहा था। हालांकि अन्य सेटिंग्स के अनुकूल होना सरल होना चाहिए।

मौलिक गुणों कि कर रहे हैं addDaysहमेशा एक काम करने के दिन देता है, और सभी के लिए है कि dऔर n,daysBetween(d, addDays(d, n)) == n

ध्यान दें कि सैद्धांतिक रूप से 0 दिन जोड़ना और 0 दिनों को घटाना अलग-अलग ऑपरेशन होना चाहिए (यदि आपकी तारीख एक रविवार है, तो 0 दिनों को जोड़कर आपको सोमवार तक ले जाना चाहिए, और 0 दिनों को घटाकर आपको शुक्रवार तक ले जाना चाहिए)। चूंकि नकारात्मक 0 (फ़्लोटिंग पॉइंट के बाहर!) जैसी कोई चीज़ नहीं है, इसलिए मैंने एक तर्क n = 0 की व्याख्या करने के लिए चुना है जिसका अर्थ है शून्य दिन जोड़ें ।

Answer 11

मेरा मानना ​​है कि यह 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;
    }

Answer 12

यहाँ मेरे प्रस्थान की तारीख और ग्राहक की डिलीवरी तिथि दोनों के साथ मेरा कोड है।

            // 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;

खुश कोडिंग।

Answer 13

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;
}

Answer 14

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();
    
            }

Answer 15

आशा है कि यह किसी की मदद करता है।

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;
    }

Comments

यह गलत है। ज्यादातर मामलों में यह काम नहीं करेगा। किसी की भी मदद करने के लिए बेकरार।

— नियोलिस्क