দুটি তারিখের মধ্যে ব্যবসায়িক দিনের সংখ্যা গণনা করবেন?


99

সি # তে, আমি কীভাবে দুটি তারিখের মধ্যে ব্যবসায়ের সংখ্যা (বা সপ্তাহের দিনগুলি) গণনা করতে পারি ?


4
এখানে সি # তে একটি উদাহরণ রয়েছে যা ঘন্টার পাশাপাশি পাওয়ার ক্ষেত্রেও প্রসারিত। কোডেপ্রজেক্ট
কেবি /

4
কটাক্ষপাত infopathdev.com/forums/t/7156.aspx
adatapost

4
আপনি কি ছুটি বাদ না?
pxl

উত্তর:


123

আমি এর আগে এমন একটি কাজ করেছি এবং এর সমাধান পেয়েছি। আমি যখন এটি এড়ানো যায় তখন এর মধ্যে সমস্ত দিন গণনা এড়াতে পারি, যা এখানে ঘটনা। আমি উপরের উত্তরগুলির মধ্যে একটি হিসাবে দেখেছি, ডেটটাইম উদাহরণগুলির একটি গুচ্ছ তৈরির কথাও উল্লেখ করি না। এটি সত্যই প্রক্রিয়াজাতকরণের অপব্যয়। বিশেষত বাস্তব বিশ্বের পরিস্থিতিতে যখন আপনাকে বেশ কয়েক মাসের সময়ের ব্যবধান পরীক্ষা করতে হয়। নীচে মন্তব্য সহ আমার কোড দেখুন।

    /// <summary>
    /// Calculates number of business days, taking into account:
    ///  - weekends (Saturdays and Sundays)
    ///  - bank holidays in the middle of the week
    /// </summary>
    /// <param name="firstDay">First day in the time interval</param>
    /// <param name="lastDay">Last day in the time interval</param>
    /// <param name="bankHolidays">List of bank holidays excluding weekends</param>
    /// <returns>Number of business days during the 'span'</returns>
    public static int BusinessDaysUntil(this DateTime firstDay, DateTime lastDay, params DateTime[] bankHolidays)
    {
        firstDay = firstDay.Date;
        lastDay = lastDay.Date;
        if (firstDay > lastDay)
            throw new ArgumentException("Incorrect last day " + lastDay);

        TimeSpan span = lastDay - firstDay;
        int businessDays = span.Days + 1;
        int fullWeekCount = businessDays / 7;
        // find out if there are weekends during the time exceedng the full weeks
        if (businessDays > fullWeekCount*7)
        {
            // we are here to find out if there is a 1-day or 2-days weekend
            // in the time interval remaining after subtracting the complete weeks
            int firstDayOfWeek = (int) firstDay.DayOfWeek;
            int lastDayOfWeek = (int) lastDay.DayOfWeek;
            if (lastDayOfWeek < firstDayOfWeek)
                lastDayOfWeek += 7;
            if (firstDayOfWeek <= 6)
            {
                if (lastDayOfWeek >= 7)// Both Saturday and Sunday are in the remaining time interval
                    businessDays -= 2;
                else if (lastDayOfWeek >= 6)// Only Saturday is in the remaining time interval
                    businessDays -= 1;
            }
            else if (firstDayOfWeek <= 7 && lastDayOfWeek >= 7)// Only Sunday is in the remaining time interval
                businessDays -= 1;
        }

        // subtract the weekends during the full weeks in the interval
        businessDays -= fullWeekCount + fullWeekCount;

        // subtract the number of bank holidays during the time interval
        foreach (DateTime bankHoliday in bankHolidays)
        {
            DateTime bh = bankHoliday.Date;
            if (firstDay <= bh && bh <= lastDay)
                --businessDays;
        }

        return businessDays;
    }

স্লুমা, আগস্ট 2011-এ সম্পাদনা করুন

দুর্দান্ত উত্তর! যদিও সামান্য বাগ আছে। আমি উত্তরটি সম্পাদনা করার স্বাধীনতা গ্রহণ করি কারণ ২০০৯ সাল থেকে উত্তরদাতা অনুপস্থিত।

উপরের কোডটি ধরে নিয়েছে যে DayOfWeek.Sundayমান রয়েছে 7যা ক্ষেত্রে নয়। মান আসলে 0। উদাহরণস্বরূপ firstDayএবং lastDayএটি একই রবিবার উভয়ই হলে এটি একটি ভুল গণনার দিকে নিয়ে যায় । 1এই ক্ষেত্রে পদ্ধতিটি ফিরে আসে তবে তা হওয়া উচিত 0

এই বাগ জন্য সহজ ফিক্স: লাইন যেখানে উপরের কোড প্রতিস্থাপন firstDayOfWeekএবং lastDayOfWeekনিম্নলিখিত ঘোষণা করা হয়:

int firstDayOfWeek = firstDay.DayOfWeek == DayOfWeek.Sunday 
    ? 7 : (int)firstDay.DayOfWeek;
int lastDayOfWeek = lastDay.DayOfWeek == DayOfWeek.Sunday
    ? 7 : (int)lastDay.DayOfWeek;

এখন ফলাফল:

  • শুক্রবার থেকে শুক্রবার -> ১
  • শনিবার থেকে শনিবার -> ০
  • রবিবার থেকে রবিবার -> ০
  • শুক্রবার থেকে শনিবার -> ১
  • শুক্রবার থেকে রবিবার -> ১
  • শুক্রবার থেকে সোমবার -> 2
  • শনিবার থেকে সোমবার -> ১
  • রবিবার থেকে সোমবার -> ১
  • সোমবার থেকে সোমবার -> ১

4
+1 এটি করার সম্ভবত সবচেয়ে সহজ এবং সর্বাধিক কার্যকর উপায় (আমার সমাধান সি ++ থেকে আসা টাইমস্প্যানের সমর্থন ব্যবহার করে না, সি # কিছু কাজকে এত সহজ করে তোলে)। ব্যাঙ্কহিডেডসও একটি দুর্দান্ত স্পর্শ!
রেডগ্লাইফ

4
এছাড়াও নিশ্চিত করুন যে ব্যাংক ছুটির দিন হিসাবে অনুসরণ করে: যদি (firstDay <= BH && BH <= lastDay && bh.IsWorkingDay ())
Tawani

4
পদ্ধতির জন্য ধন্যবাদ। যদিও, আমাকে ব্যাংক ছুটির বিস্তৃতি / পুনরাবৃত্তির if-বিবৃতিতে নিম্নলিখিতটি যুক্ত করতে হয়েছিল: && !(bh.DayOfWeek == DayOfWeek.Sunday || bh.DayOfWeek == DayOfWeek.Saturday)অন্যথায়, ছুটির সপ্তাহান্তে পড়লে তা একই দিনে দু'বার করে ফেলবে।
ক্রিস্টিয়ানবি

আমি লিনক স্টেটমেন্টের জন্য শেষ লুপটি পরিবর্তন করেছি: বিজনেসডেস - = ব্যাঙ্কহেলিডস। নির্বাচন করুন (ব্যাংকহ্যালিড => ব্যাংকহিডেশন.ডেট)। অ্যাকাউন্ট (বিএইচ => ফার্স্টডে <= বিএইচ এবং & বিএইচ = = সর্বশেষ);
জোয়ানকোমাসএফডিজেড

4
এছাড়াও তারা এমন দেশ যার শনিবার, রবিবারের সাপ্তাহিক ছুটি নেই। : আরও তথ্যের জন্য এই লিঙ্কটি দেখুন en.wikipedia.org/wiki/Workweek_and_weekend
Gatej Alexandru

106

ঠিক আছে. আমি মনে করি সঠিক উত্তর পোস্ট করার সময় এসেছে:

public static double GetBusinessDays(DateTime startD, DateTime endD)
{
    double calcBusinessDays =
        1 + ((endD - startD).TotalDays * 5 -
        (startD.DayOfWeek - endD.DayOfWeek) * 2) / 7;

    if (endD.DayOfWeek == DayOfWeek.Saturday) calcBusinessDays--;
    if (startD.DayOfWeek == DayOfWeek.Sunday) calcBusinessDays--;

    return calcBusinessDays;
}

মূল উৎস:

http://alecpojidaev.wordpress.com/2009/10/29/work-days-calculation-with-c/

উপরের পোস্ট পিএস সলিউশনগুলি কোনও কারণে আমাকে জটিল করে তুলছে।


10
ভাল কাজ, তবে সম্ভবত ডে-অফউইক এনামগুলিকে কীভাবে ছাঁটাইয়ের পরিবর্তে তারা ব্যবহার করবেন?
নিও

4
সিরিয়াসলি, সেখানে সেরা সমাধান। চিয়ার্স অ্যালেক
মিজমোর

6
মনে রাখবেন যে এই ফাংশনটি দ্বিগুণ ফেরত আসার পরেও কেবল এটি পুরো ব্যবসায়িক দিন দেওয়ার জন্য বিশ্বাস করা উচিত । সময় জড়িত থাকার সময় ভগ্নাংশের জন্য এটি সঠিক উত্তর দেয় না।
পাকম্যান

4
শুধু মন্তব্য করার জন্য, সঙ্গে '1+ এটা অনুমান শুরু না হওয়া পর্যন্ত প্রথম দিনের শেষ শেষ দিনে এর ছাড়া' 1+ এটা অনুমান শেষ পর্যন্ত প্রথম দিনের শেষ শেষ দিনে হয়। আমার চিত্র কিছুটা সময় লেগেছিল যে, যেহেতু আমি অভিমানী ছিল শুরু না হওয়া পর্যন্ত প্রথম দিনের সূচনা শেষ দিনে, যা আমার আরো ইন্দ্রিয় তৈরি।
জেফরি ভ্যান ডি ভার্স্ট

11
এই না সঠিক উত্তর। দিনগুলি 4 অবধি বাইরে চলে যেতে পারে প্রায় সঠিক, উইকএন্ডের শুরুতে এবং শেষের দিনটি মোড়ানো কখন হয় তা বিবেচনা করে না, যা সবচেয়ে জটিল কৌশল। শুরু - শেষটি কোনও প্রথম বন্ধনীগুলির মধ্যে থাকা উচিত নয়। সমস্যাটির সাথে কিছুই করার নেই। 60% সময় এই সমাধানটি ভুল
পেঁচা

47

আমি জানি এই প্রশ্নটি ইতিমধ্যে সমাধান হয়ে গেছে, তবে আমি ভেবেছিলাম যে আমি আরও সহজবোধ্য উত্তর প্রদান করতে পারি যা ভবিষ্যতে অন্যান্য দর্শনার্থীদের সহায়তা করতে পারে।

এটি আমার গ্রহণ এখানে:

public int GetWorkingDays(DateTime from, DateTime to)
{
    var dayDifference = (int)to.Subtract(from).TotalDays;
    return Enumerable
        .Range(1, dayDifference)
        .Select(x => from.AddDays(x))
        .Count(x => x.DayOfWeek != DayOfWeek.Saturday && x.DayOfWeek != DayOfWeek.Sunday);
}

এটি আমার আসল জমা ছিল:

public int GetWorkingDays(DateTime from, DateTime to)
{
    var totalDays = 0;
    for (var date = from; date < to; date = date.AddDays(1))
    {
        if (date.DayOfWeek != DayOfWeek.Saturday
            && date.DayOfWeek != DayOfWeek.Sunday)
            totalDays++;
    }

    return totalDays;
}

এটি সংক্ষিপ্ত করার জন্য "যেখানে" "গণনা" হতে পারে
উপগ্রহ করুন

4
অনেক পরিষ্কার, এবং গণিত সমাধানগুলি ব্যাঙ্কের ছুটিগুলি অপসারণে leণ দেয়। যদিও তারা প্রচুর পরিমাণে ধীর হয়; লিনকিপ্যাডে 1 মিলিয়ন পুনরাবৃত্তি লুপে 90 দিনের ব্যবধানের জন্য কার্যদিবসের গণনা করতে 10 সেকেন্ড সময় লাগে এই সমাধানটি ব্যবহার করে, এবং কেবলমাত্র গৃহীত উত্তর বা অ্যালেক পজিদায়েভের খুব সুন্দর একটি ব্যবহার করে 0.2% ব্যবহার করে।
ওয়েলকাহোলিজম

সমেত হওয়ার উদ্দেশ্যে কোড হওয়া উচিত: প্রত্যাবর্তন গণনীয় .Range (0, dayDifference +1) ...
Edza

অতীতে দিন ফিরে না। -18 কার্যদিবসের মতো।
ইন্দু

@ iwtu এটি ধরে নেয় to > from। এটাই কি সমস্যা?
আলফা

22

ডেটটাইমে এমনভাবে কোনও এক্সটেনশন পদ্ধতিটি সংজ্ঞায়িত করুন:

public static class DateTimeExtensions
{
    public static bool IsWorkingDay(this DateTime date)
    {
        return date.DayOfWeek != DayOfWeek.Saturday
            && date.DayOfWeek != DayOfWeek.Sunday;
    }
}

তারপরে, তারিখগুলির বিস্তৃত তালিকা ফিল্টার করার জন্য হ'ল ক্লজের মধ্যে ব্যবহার রয়েছে:

var allDates = GetDates(); // method which returns a list of dates

// filter dates by working day's  
var countOfWorkDays = allDates
     .Where(day => day.IsWorkingDay())
     .Count() ;

আপনি কি কেবল এগিয়ে গিয়ে টাইমস্প্যানটি প্রসারিত করবেন না যাতে আপনি এটি ব্যবহার করতে পারেন - যেহেতু তিনি বলেছিলেন যে তিনি দুটি তারিখের মধ্যে দূরত্বটি ব্যবহার করতে চান, তারিখের তালিকা নয়?
ওয়েসলি জনসন 9

দুটি তারিখের মধ্যে দূরত্বের মধ্যে দিনের সংখ্যা, সুতরাং গণনা () যথেষ্ট।
কার্লস কোম্পানী

4
আমি নিশ্চিত না কেন এটি উপযুক্ত উত্তর ... তার ব্যক্তিগত দিনের কোনও তালিকা নেই, তার দুটি তারিখ রয়েছে এবং তিনি তাদের মধ্যে ব্যবসায়িক দিনের সংখ্যাটি সন্ধান করতে চান। এই সমাধানটি ব্যবহার করার জন্য আপনাকে আরেকটি ক্রিয়াকলাপ সরবরাহ করতে হবে যা দ্বীপের মধ্যে প্রতিটি তারিখের একটি তালিকা তৈরি করে।
অ্যাডাম রবিনসন

4
অ্যাডাম, এটি কোনও ধারণার প্রদর্শনের জন্য প্রয়োজনীয় ন্যূনতম পরিমাণের কোড সহ একটি সাধারণ উদাহরণ। আমার আসল উত্তরে আমি এমন একটি লুপও অন্তর্ভুক্ত করেছি যা সর্বশেষ তারিখের তালিকাটিকে জনপ্রিয় করে তুলেছে যা থেকে আমি "গেটডেটস" ফাংশনটিতে বিমূর্ত হয়েছি। ইসওয়ার্কিংডে পরীক্ষাটি সহজেই লিনকিউ বিবৃতি থেকে এবং সেই লুপে সরানো যেতে পারে। আমি ব্যক্তিগতভাবে পছন্দ করি এখন এটি কীভাবে ঘটছে কারণ এটি খুব মানব পাঠযোগ্য যা ঘটছে।
কিউরটি

10
পরিবর্তন কোথায় গণনা, এবং দূর কাউন্ট দ্বারা shorted করা যায়নি
রিকার্সিভ

12

আমি ব্যাঙ্কের ছুটির দিনেও নিম্নলিখিত কোডগুলি ব্যবহার করেছি:

public class WorkingDays
{
    public List<DateTime> GetHolidays()
    {
        var client = new WebClient();
        var json = client.DownloadString("https://www.gov.uk/bank-holidays.json");
        var js = new JavaScriptSerializer();
        var holidays = js.Deserialize <Dictionary<string, Holidays>>(json);
        return holidays["england-and-wales"].events.Select(d => d.date).ToList();
    }

    public int GetWorkingDays(DateTime from, DateTime to)
    {
        var totalDays = 0;
        var holidays = GetHolidays();
        for (var date = from.AddDays(1); date <= to; date = date.AddDays(1))
        {
            if (date.DayOfWeek != DayOfWeek.Saturday
                && date.DayOfWeek != DayOfWeek.Sunday
                && !holidays.Contains(date))
                totalDays++;
        }

        return totalDays;
    }
}

public class Holidays
{
    public string division { get; set; }
    public List<Event> events { get; set; }
}

public class Event
{
    public DateTime date { get; set; }
    public string notes { get; set; }
    public string title { get; set; }
}

এবং ইউনিট পরীক্ষা:

[TestClass]
public class WorkingDays
{
    [TestMethod]
    public void SameDayIsZero()
    {
        var service = new WorkingDays();

        var from = new DateTime(2013, 8, 12);

        Assert.AreEqual(0, service.GetWorkingDays(from, from));

    }

    [TestMethod]
    public void CalculateDaysInWorkingWeek()
    {
        var service = new WorkingDays();

        var from = new DateTime(2013, 8, 12);
        var to = new DateTime(2013, 8, 16);

        Assert.AreEqual(4, service.GetWorkingDays(from, to), "Mon - Fri = 4");

        Assert.AreEqual(1, service.GetWorkingDays(from, new DateTime(2013, 8, 13)), "Mon - Tues = 1");
    }

    [TestMethod]
    public void NotIncludeWeekends()
    {
        var service = new WorkingDays();

        var from = new DateTime(2013, 8, 9);
        var to = new DateTime(2013, 8, 16);

        Assert.AreEqual(5, service.GetWorkingDays(from, to), "Fri - Fri = 5");

        Assert.AreEqual(2, service.GetWorkingDays(from, new DateTime(2013, 8, 13)), "Fri - Tues = 2");
        Assert.AreEqual(1, service.GetWorkingDays(from, new DateTime(2013, 8, 12)), "Fri - Mon = 1");
    }

    [TestMethod]
    public void AccountForHolidays()
    {
        var service = new WorkingDays();

        var from = new DateTime(2013, 8, 23);

        Assert.AreEqual(0, service.GetWorkingDays(from, new DateTime(2013, 8, 26)), "Fri - Mon = 0");

        Assert.AreEqual(1, service.GetWorkingDays(from, new DateTime(2013, 8, 27)), "Fri - Tues = 1");
    }
}

আপনি কেন "ভের তারিখ = থেকে। অ্যাডডয়েস (1); তারিখ <= থেকে; তারিখ = তারিখ.এডডয়েস (1)) এর জন্য" থেকে "1 দিন যোগ করে গণনা শুরু করেন?
ওয়ানল উমুত তুর

6

আচ্ছা এই মারধর করা হয়েছে। :) তবে আমি এখনও অন্য উত্তর সরবরাহ করতে যাচ্ছি কারণ আমার কিছুটা আলাদা প্রয়োজন। এই সমাধানটি আলাদা যে এটি কোনও ব্যবসায়িক টাইমস্প্যান দেয় শুরু এবং শেষের মধ্যে দেয় এবং আপনি দিনের ব্যবসায়ের সময় নির্ধারণ করতে পারেন এবং ছুটির দিন যোগ করতে পারেন। সুতরাং আপনি যদি এটি একটি দিনের মধ্যে, দিন জুড়ে, সাপ্তাহিক ছুটির দিনে এমনকি ছুটির দিনেও ঘটে থাকে তা গণনা করতে ব্যবহার করতে পারেন। এবং আপনি ফিরে আসা টাইমস্প্যান অবজেক্ট থেকে কেবল আপনার প্রয়োজনীয় জিনিস পেয়ে কেবল ব্যবসায়ের দিনগুলি পেতে পারেন। এবং এটি যেভাবে দিনের তালিকাগুলি ব্যবহার করে, আপনি দেখতে পারবেন যে অ-কাজের দিনগুলির তালিকাটি যদি এটি সাধারণ শনি এবং সূর্যের না হয় তবে এটি যুক্ত করা কত সহজ হবে see এবং আমি এক বছরের জন্য পরীক্ষা করেছি এবং এটি খুব দ্রুত বলে মনে হচ্ছে।

আমি কেবল আশা করি কোডটি আটকানো সঠিক। তবে আমি জানি এটি কাজ করে।

public static TimeSpan GetBusinessTimespanBetween(
    DateTime start, DateTime end,
    TimeSpan workdayStartTime, TimeSpan workdayEndTime,
    List<DateTime> holidays = null)
{
    if (end < start)
        throw new ArgumentException("start datetime must be before end datetime.");

    // Just create an empty list for easier coding.
    if (holidays == null) holidays = new List<DateTime>();

    if (holidays.Where(x => x.TimeOfDay.Ticks > 0).Any())
        throw new ArgumentException("holidays can not have a TimeOfDay, only the Date.");

    var nonWorkDays = new List<DayOfWeek>() { DayOfWeek.Saturday, DayOfWeek.Sunday };

    var startTime = start.TimeOfDay;

    // If the start time is before the starting hours, set it to the starting hour.
    if (startTime < workdayStartTime) startTime = workdayStartTime;

    var timeBeforeEndOfWorkDay = workdayEndTime - startTime;

    // If it's after the end of the day, then this time lapse doesn't count.
    if (timeBeforeEndOfWorkDay.TotalSeconds < 0) timeBeforeEndOfWorkDay = new TimeSpan();
    // If start is during a non work day, it doesn't count.
    if (nonWorkDays.Contains(start.DayOfWeek)) timeBeforeEndOfWorkDay = new TimeSpan();
    else if (holidays.Contains(start.Date)) timeBeforeEndOfWorkDay = new TimeSpan();

    var endTime = end.TimeOfDay;

    // If the end time is after the ending hours, set it to the ending hour.
    if (endTime > workdayEndTime) endTime = workdayEndTime;

    var timeAfterStartOfWorkDay = endTime - workdayStartTime;

    // If it's before the start of the day, then this time lapse doesn't count.
    if (timeAfterStartOfWorkDay.TotalSeconds < 0) timeAfterStartOfWorkDay = new TimeSpan();
    // If end is during a non work day, it doesn't count.
    if (nonWorkDays.Contains(end.DayOfWeek)) timeAfterStartOfWorkDay = new TimeSpan();
    else if (holidays.Contains(end.Date)) timeAfterStartOfWorkDay = new TimeSpan();

    // Easy scenario if the times are during the day day.
    if (start.Date.CompareTo(end.Date) == 0)
    {
        if (nonWorkDays.Contains(start.DayOfWeek)) return new TimeSpan();
        else if (holidays.Contains(start.Date)) return new TimeSpan();
        return endTime - startTime;
    }
    else
    {
        var timeBetween = end - start;
        var daysBetween = (int)Math.Floor(timeBetween.TotalDays);
        var dailyWorkSeconds = (int)Math.Floor((workdayEndTime - workdayStartTime).TotalSeconds);

        var businessDaysBetween = 0;

        // Now the fun begins with calculating the actual Business days.
        if (daysBetween > 0)
        {
            var nextStartDay = start.AddDays(1).Date;
            var dayBeforeEnd = end.AddDays(-1).Date;
            for (DateTime d = nextStartDay; d <= dayBeforeEnd; d = d.AddDays(1))
            {
                if (nonWorkDays.Contains(d.DayOfWeek)) continue;
                else if (holidays.Contains(d.Date)) continue;
                businessDaysBetween++;
            }
        }

        var dailyWorkSecondsToAdd = dailyWorkSeconds * businessDaysBetween;

        var output = timeBeforeEndOfWorkDay + timeAfterStartOfWorkDay;
        output = output + new TimeSpan(0, 0, dailyWorkSecondsToAdd);

        return output;
    }
}

এবং এখানে টেস্ট কোডটি রয়েছে: নোট করুন যে পরীক্ষার কোডটি কাজ করার জন্য আপনাকে এই ফাংশনটি ডেটহেল্পার নামে একটি শ্রেণিতে স্থাপন করতে হবে।

[TestMethod]
public void TestGetBusinessTimespanBetween()
{
    var workdayStart = new TimeSpan(8, 0, 0);
    var workdayEnd = new TimeSpan(17, 0, 0);

    var holidays = new List<DateTime>()
    {
        new DateTime(2018, 1, 15), // a Monday
        new DateTime(2018, 2, 15) // a Thursday
    };

    var testdata = new[]
    {
        new
        {
            expectedMinutes = 0,
            start = new DateTime(2016, 10, 19, 9, 50, 0),
            end = new DateTime(2016, 10, 19, 9, 50, 0)
        },
        new
        {
            expectedMinutes = 10,
            start = new DateTime(2016, 10, 19, 9, 50, 0),
            end = new DateTime(2016, 10, 19, 10, 0, 0)
        },
        new
        {
            expectedMinutes = 5,
            start = new DateTime(2016, 10, 19, 7, 50, 0),
            end = new DateTime(2016, 10, 19, 8, 5, 0)
        },
        new
        {
            expectedMinutes = 5,
            start = new DateTime(2016, 10, 19, 16, 55, 0),
            end = new DateTime(2016, 10, 19, 17, 5, 0)
        },
        new
        {
            expectedMinutes = 15,
            start = new DateTime(2016, 10, 19, 16, 50, 0),
            end = new DateTime(2016, 10, 20, 8, 5, 0)
        },
        new
        {
            expectedMinutes = 10,
            start = new DateTime(2016, 10, 19, 16, 50, 0),
            end = new DateTime(2016, 10, 20, 7, 55, 0)
        },
        new
        {
            expectedMinutes = 5,
            start = new DateTime(2016, 10, 19, 17, 10, 0),
            end = new DateTime(2016, 10, 20, 8, 5, 0)
        },
        new
        {
            expectedMinutes = 0,
            start = new DateTime(2016, 10, 19, 17, 10, 0),
            end = new DateTime(2016, 10, 20, 7, 5, 0)
        },
        new
        {
            expectedMinutes = 545,
            start = new DateTime(2016, 10, 19, 12, 10, 0),
            end = new DateTime(2016, 10, 20, 12, 15, 0)
        },
        // Spanning multiple weekdays
        new
        {
            expectedMinutes = 835,
            start = new DateTime(2016, 10, 19, 12, 10, 0),
            end = new DateTime(2016, 10, 21, 8, 5, 0)
        },
        // Spanning multiple weekdays
        new
        {
            expectedMinutes = 1375,
            start = new DateTime(2016, 10, 18, 12, 10, 0),
            end = new DateTime(2016, 10, 21, 8, 5, 0)
        },
        // Spanning from a Thursday to a Tuesday, 5 mins short of complete day.
        new
        {
            expectedMinutes = 1615,
            start = new DateTime(2016, 10, 20, 12, 10, 0),
            end = new DateTime(2016, 10, 25, 12, 5, 0)
        },
        // Spanning from a Thursday to a Tuesday, 5 mins beyond complete day.
        new
        {
            expectedMinutes = 1625,
            start = new DateTime(2016, 10, 20, 12, 10, 0),
            end = new DateTime(2016, 10, 25, 12, 15, 0)
        },
        // Spanning from a Friday to a Monday, 5 mins beyond complete day.
        new
        {
            expectedMinutes = 545,
            start = new DateTime(2016, 10, 21, 12, 10, 0),
            end = new DateTime(2016, 10, 24, 12, 15, 0)
        },
        // Spanning from a Friday to a Monday, 5 mins short complete day.
        new
        {
            expectedMinutes = 535,
            start = new DateTime(2016, 10, 21, 12, 10, 0),
            end = new DateTime(2016, 10, 24, 12, 5, 0)
        },
        // Spanning from a Saturday to a Monday, 5 mins short complete day.
        new
        {
            expectedMinutes = 245,
            start = new DateTime(2016, 10, 22, 12, 10, 0),
            end = new DateTime(2016, 10, 24, 12, 5, 0)
        },
        // Spanning from a Saturday to a Sunday, 5 mins beyond complete day.
        new
        {
            expectedMinutes = 0,
            start = new DateTime(2016, 10, 22, 12, 10, 0),
            end = new DateTime(2016, 10, 23, 12, 15, 0)
        },
        // Times within the same Saturday.
        new
        {
            expectedMinutes = 0,
            start = new DateTime(2016, 10, 22, 12, 10, 0),
            end = new DateTime(2016, 10, 23, 12, 15, 0)
        },
        // Spanning from a Saturday to the Sunday next week.
        new
        {
            expectedMinutes = 2700,
            start = new DateTime(2016, 10, 22, 12, 10, 0),
            end = new DateTime(2016, 10, 30, 12, 15, 0)
        },
        // Spanning a year.
        new
        {
            expectedMinutes = 143355,
            start = new DateTime(2016, 10, 22, 12, 10, 0),
            end = new DateTime(2017, 10, 30, 12, 15, 0)
        },
        // Spanning a year with 2 holidays.
        new
        {
            expectedMinutes = 142815,
            start = new DateTime(2017, 10, 22, 12, 10, 0),
            end = new DateTime(2018, 10, 30, 12, 15, 0)
        },
    };

    foreach (var item in testdata)
    {
        Assert.AreEqual(item.expectedMinutes,
            DateHelper.GetBusinessTimespanBetween(
                item.start, item.end,
                workdayStart, workdayEnd,
                holidays)
                .TotalMinutes);
    }
}

5

এই সমাধানটি পুনরাবৃত্তি এড়ায়, সপ্তাহের দিন গণনা করার ধীর পদ্ধতির বিরুদ্ধে প্রতিরোধের জন্য ইউনিট টেস্ট স্যুট অন্তর্ভুক্ত করে এবং সপ্তাহের দিন পার্থক্য উভয়ের জন্যই কাজ করে। আমি সপ্তাহের দিনগুলি একই অ-পুনরাবৃত্ত পদ্ধতিতে কাজ করার জন্য একটি সংক্ষিপ্ত পদ্ধতিও অন্তর্ভুক্ত করেছি।

ইউনিট পরীক্ষাগুলি কয়েক হাজার তারিখ সংমিশ্রণগুলিকে কভার করে যাতে ছোট এবং বড় উভয় তারিখের ব্যাপ্তির সাথে সমস্ত শুরু / শেষ সপ্তাহের দিন সংমিশ্রণগুলি পরীক্ষা করতে পারে।

গুরুত্বপূর্ণ : আমরা অনুমান করি যে আমরা শুরুর তারিখ বাদ দিয়ে এবং শেষের তারিখটি বাদ দিয়ে দিন গণনা করছি। আপনার অন্তর্ভুক্ত / বাদ দেওয়া নির্দিষ্ট নির্দিষ্ট দিন / শেষ দিন হিসাবে সপ্তাহের দিন গণনা করার সময় এটি গুরুত্বপূর্ণ। এটিও নিশ্চিত করে যে দুটি সমান দিনের পার্থক্য সর্বদা শূন্য এবং আমরা কেবলমাত্র পুরো কার্যদিবসের দিন অন্তর্ভুক্ত করি সাধারণত আপনি বর্তমান সূচনার তারিখে (প্রায়শই আজ) যে কোনও সময় উত্তর সঠিক রাখতে চান এবং সম্পূর্ণ সমাপ্তির তারিখ অন্তর্ভুক্ত করেন (উদাহরণস্বরূপ) একটি নির্ধারিত তারিখ)।

দ্রষ্টব্য: এই কোডটির ছুটির জন্য অতিরিক্ত সমন্বয় প্রয়োজন তবে উপরের অনুমানের সাথে তাল মিলিয়ে এই কোডটি অবশ্যই শুরুর তারিখে ছুটি বাদ দিতে হবে।

সপ্তাহের দিন যুক্ত করুন:

private static readonly int[,] _addOffset = 
{
  // 0  1  2  3  4
    {0, 1, 2, 3, 4}, // Su  0
    {0, 1, 2, 3, 4}, // M   1
    {0, 1, 2, 3, 6}, // Tu  2
    {0, 1, 4, 5, 6}, // W   3
    {0, 1, 4, 5, 6}, // Th  4
    {0, 3, 4, 5, 6}, // F   5
    {0, 2, 3, 4, 5}, // Sa  6
};

public static DateTime AddWeekdays(this DateTime date, int weekdays)
{
    int extraDays = weekdays % 5;
    int addDays = weekdays >= 0
        ? (weekdays / 5) * 7 + _addOffset[(int)date.DayOfWeek, extraDays]
        : (weekdays / 5) * 7 - _addOffset[6 - (int)date.DayOfWeek, -extraDays];
    return date.AddDays(addDays);
}

গণনার সপ্তাহের পার্থক্য:

static readonly int[,] _diffOffset = 
{
  // Su M  Tu W  Th F  Sa
    {0, 1, 2, 3, 4, 5, 5}, // Su
    {4, 0, 1, 2, 3, 4, 4}, // M 
    {3, 4, 0, 1, 2, 3, 3}, // Tu
    {2, 3, 4, 0, 1, 2, 2}, // W 
    {1, 2, 3, 4, 0, 1, 1}, // Th
    {0, 1, 2, 3, 4, 0, 0}, // F 
    {0, 1, 2, 3, 4, 5, 0}, // Sa
};

public static int GetWeekdaysDiff(this DateTime dtStart, DateTime dtEnd)
{
    int daysDiff = (int)(dtEnd - dtStart).TotalDays;
    return daysDiff >= 0
        ? 5 * (daysDiff / 7) + _diffOffset[(int) dtStart.DayOfWeek, (int) dtEnd.DayOfWeek]
        : 5 * (daysDiff / 7) - _diffOffset[6 - (int) dtStart.DayOfWeek, 6 - (int) dtEnd.DayOfWeek];
}

আমি দেখতে পেয়েছি যে স্ট্যাকের ওভারফ্লোতে অন্যান্য বেশিরভাগ সমাধান হ'ল ধীর (পুনরাবৃত্তিমূলক) বা অত্যধিক জটিল এবং অনেকগুলি কেবল সাধারণ ভুল ছিল। গল্পটির নৈতিক হ'ল ... এটির উপর নির্ভর করবেন না যতক্ষণ না আপনি এটি পরিচ্ছন্নভাবে পরীক্ষা করেন না !!

ইউনিট পরীক্ষাগুলি NUnit সম্মিলন পরীক্ষা এবং shouldBe NUnit এক্সটেনশনের উপর ভিত্তি করে ।

[TestFixture]
public class DateTimeExtensionsTests
{
    /// <summary>
    /// Exclude start date, Include end date
    /// </summary>
    /// <param name="dtStart"></param>
    /// <param name="dtEnd"></param>
    /// <returns></returns>
    private IEnumerable<DateTime> GetDateRange(DateTime dtStart, DateTime dtEnd)
    {
        Console.WriteLine(@"dtStart={0:yy-MMM-dd ddd}, dtEnd={1:yy-MMM-dd ddd}", dtStart, dtEnd);

        TimeSpan diff = dtEnd - dtStart;
        Console.WriteLine(diff);

        if (dtStart <= dtEnd)
        {
            for (DateTime dt = dtStart.AddDays(1); dt <= dtEnd; dt = dt.AddDays(1))
            {
                Console.WriteLine(@"dt={0:yy-MMM-dd ddd}", dt);
                yield return dt;
            }
        }
        else
        {
            for (DateTime dt = dtStart.AddDays(-1); dt >= dtEnd; dt = dt.AddDays(-1))
            {
                Console.WriteLine(@"dt={0:yy-MMM-dd ddd}", dt);
                yield return dt;
            }
        }
    }

    [Test, Combinatorial]
    public void TestGetWeekdaysDiff(
        [Values(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 20, 30)]
        int startDay,
        [Values(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 20, 30)]
        int endDay,
        [Values(7)]
        int startMonth,
        [Values(7)]
        int endMonth)
    {
        // Arrange
        DateTime dtStart = new DateTime(2016, startMonth, startDay);
        DateTime dtEnd = new DateTime(2016, endMonth, endDay);

        int nDays = GetDateRange(dtStart, dtEnd)
            .Count(dt => dt.DayOfWeek != DayOfWeek.Saturday && dt.DayOfWeek != DayOfWeek.Sunday);

        if (dtEnd < dtStart) nDays = -nDays;

        Console.WriteLine(@"countBusDays={0}", nDays);

        // Act / Assert
        dtStart.GetWeekdaysDiff(dtEnd).ShouldBe(nDays);
    }

    [Test, Combinatorial]
    public void TestAddWeekdays(
        [Values(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 20, 30)]
        int startDay,
        [Values(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 20, 30)]
        int weekdays)
    {
        DateTime dtStart = new DateTime(2016, 7, startDay);
        DateTime dtEnd1 = dtStart.AddWeekdays(weekdays);     // ADD
        dtStart.GetWeekdaysDiff(dtEnd1).ShouldBe(weekdays);  

        DateTime dtEnd2 = dtStart.AddWeekdays(-weekdays);    // SUBTRACT
        dtStart.GetWeekdaysDiff(dtEnd2).ShouldBe(-weekdays);
    }
}

এর জন্য ধারণাটি একটি এসকিউএল সমাধান থেকে এসেছিল যা আমি স্ট্যাক ওভারফ্লোতে পেয়েছি। তাদের ধারণাটি শক্ত ছিল তবে দুঃখের বিষয় এটির একটি বাগও ছিল। এটি + ভ্যালুতে কাজ করেছে তবে তাদের সন্ধানের টেবিল ম্যাপিং-মানগুলির জন্য ভুল ছিল।
টনি ও'হাগান

4

এই কাজের জন্য এখানে কিছু কোড কোডের তালিকা রয়েছে, যা হলিডে ছুটির দিনগুলির সাথে তবে আপনি কী ছুটি গণনা করতে পারবেন তা খাপ খাইয়ে নিতে পারেন। নোট করুন যে আমি সীমাবদ্ধ করেছিলাম যা আপনি মুছে ফেলতে চাইতে পারেন, তবে এটি একটি ওয়েব-ভিত্তিক সিস্টেমের জন্য ছিল এবং আমি চাইনি যে কেউ এই প্রক্রিয়াটি হোগাতে কোনও বিশাল তারিখ প্রবেশ করুক to

  public static int GetWorkdays(DateTime from ,DateTime to)
    {
        int limit = 9999;
        int counter = 0;
        DateTime current = from;
        int result = 0;

        if (from > to)
        {
            DateTime temp = from;
            from = to;
            to = temp;
        }

        if (from >= to)
        {
            return 0;
        }


        while (current <= to && counter < limit)
        {
            if (IsSwedishWorkday(current))
            {
                result++;
            }
            current = current.AddDays(1);
            counter++;

        }
        return result;
    }


    public static bool IsSwedishWorkday(DateTime date)
    {
        return (!IsSwedishHoliday(date) && date.DayOfWeek != DayOfWeek.Saturday && date.DayOfWeek != DayOfWeek.Sunday);
    }

    public static bool IsSwedishHoliday(DateTime date)
    {
        return (
        IsSameDay(GetEpiphanyDay(date.Year), date) ||
        IsSameDay(GetMayDay(date.Year), date) ||
        IsSameDay(GetSwedishNationalDay(date.Year), date) ||
        IsSameDay(GetChristmasDay(date.Year), date) ||
        IsSameDay(GetBoxingDay(date.Year), date) ||
        IsSameDay(GetGoodFriday(date.Year), date) ||
        IsSameDay(GetAscensionDay(date.Year), date) ||
        IsSameDay(GetAllSaintsDay(date.Year), date) ||
        IsSameDay(GetMidsummersDay(date.Year), date) ||
        IsSameDay(GetPentecostDay(date.Year), date) ||
        IsSameDay(GetEasterMonday(date.Year), date) ||
        IsSameDay(GetNewYearsDay(date.Year), date) ||
        IsSameDay(GetEasterDay(date.Year), date)
        );
    }

    // Trettondagen
    public static DateTime GetEpiphanyDay(int year)
    {
        return new DateTime(year, 1, 6);
    }

    // Första maj
    public static DateTime GetMayDay(int year)
    {
        return new DateTime(year,5,1);
    }

    // Juldagen
    public static DateTime GetSwedishNationalDay(int year)
    {
        return new DateTime(year, 6, 6);
    }


    // Juldagen
    public static DateTime GetNewYearsDay(int year)
    {
        return new DateTime(year,1,1);
    }

    // Juldagen
    public static DateTime GetChristmasDay(int year)
    {
        return new DateTime(year,12,25);
    }

    // Annandag jul
    public static DateTime GetBoxingDay(int year)
    {
        return new DateTime(year, 12, 26);
    }


    // Långfredagen
    public static DateTime GetGoodFriday(int year)
    {
        return GetEasterDay(year).AddDays(-3);
    }

    // Kristi himmelsfärdsdag
    public static DateTime GetAscensionDay(int year)
    {
        return GetEasterDay(year).AddDays(5*7+4);
    }

    // Midsommar
    public static DateTime GetAllSaintsDay(int year)
    {
        DateTime result = new DateTime(year,10,31);
        while (result.DayOfWeek != DayOfWeek.Saturday)
        {
            result = result.AddDays(1);
        }
        return result;
    }

    // Midsommar
    public static DateTime GetMidsummersDay(int year)
    {
        DateTime result = new DateTime(year, 6, 20);
        while (result.DayOfWeek != DayOfWeek.Saturday)
        {
            result = result.AddDays(1);
        }
        return result;
    }

    // Pingstdagen
    public static DateTime GetPentecostDay(int year)
    {
        return GetEasterDay(year).AddDays(7 * 7);
    }

    // Annandag påsk
    public static DateTime GetEasterMonday(int year)
    {
        return GetEasterDay(year).AddDays(1);
    }
    public static DateTime GetEasterDay(int y)
    {
        double c;
        double n;
        double k;
        double i;
        double j;
        double l;
        double m;
        double d;
        c = System.Math.Floor(y / 100.0);
        n = y - 19 * System.Math.Floor(y / 19.0);
        k = System.Math.Floor((c - 17) / 25.0);
        i = c - System.Math.Floor(c / 4) - System.Math.Floor((c - k) / 3) + 19 * n + 15;
        i = i - 30 * System.Math.Floor(i / 30);
        i = i - System.Math.Floor(i / 28) * (1 - System.Math.Floor(i / 28) * System.Math.Floor(29 / (i + 1)) * System.Math.Floor((21 - n) / 11));
        j = y + System.Math.Floor(y / 4.0) + i + 2 - c + System.Math.Floor(c / 4);
        j = j - 7 * System.Math.Floor(j / 7);
        l = i - j;
        m = 3 + System.Math.Floor((l + 40) / 44);// month
        d = l + 28 - 31 * System.Math.Floor(m / 4);// day

        double days = ((m == 3) ? d : d + 31);

        DateTime result = new DateTime(y, 3, 1).AddDays(days-1);

        return result;
    }

ফাংশন ইস্যুমেটটি অনুপস্থিত তবে এটি কেবলমাত্র সরকারী স্থির বুল ইসসেমডে (তারিখের তারিখ 1, তারিখটাইম তারিখ 2) {ফেরতের তারিখ 1. তারিখ == তারিখ 2. তারিখ; }
চকো স্মিথ

আপনি নতুন তারিখের অবজেক্টগুলি ইনস্ট্যান্ট করার পরিবর্তে কোনও int অ্যারে লুক টেবিল ব্যবহার করতে পারেন।
TheRealChx101

3

এখানে একটি দ্রুত নমুনা কোড। এটি একটি শ্রেণিবদ্ধ পদ্ধতি, সুতরাং কেবল আপনার শ্রেণীর অভ্যন্তরে কাজ করবে। আপনি যদি এটি হতে চান staticতবে স্বাক্ষরটি private static(বা public static) এ পরিবর্তন করুন ।

    private IEnumerable<DateTime> GetWorkingDays(DateTime sd, DateTime ed)
    {
        for (var d = sd; d <= ed; d = d.AddDays(1))
            if (d.DayOfWeek != DayOfWeek.Saturday && d.DayOfWeek != DayOfWeek.Sunday)
                yield return d;
    }

এই পদ্ধতিটি একটি লুপ ভেরিয়েবল তৈরি করে d, এটি প্রথম দিন শুরু করে এবং sdতারপরে প্রতিটি পুনরাবৃত্তি ( d = d.AddDays(1)) একদিন বাড়িয়ে দেয় ।

এটি ব্যবহার করে কাঙ্ক্ষিত মানগুলি প্রদান করে yieldযা একটি তৈরি করে iterator। পুনরাবৃত্তকারীদের সম্পর্কে দুর্দান্ত জিনিস হ'ল তারা IEnumerableমেমরির সমস্ত মান ধরে না , কেবল প্রতিটিকে ক্রমানুসারে কল করে। এর অর্থ হ'ল আপনি স্মৃতিশক্তি ফুরিয়ে যাওয়ার চিন্তা না করেই সকাল সকাল থেকে এখন পর্যন্ত এই পদ্ধতিটি কল করতে পারেন।


4
এই পদ্ধতিটি দুটি তারিখের মধ্যে ব্যবসায়িক দিনের সংখ্যা ফেরায় না, এটি দুটি তারিখের মধ্যে ব্যবসায়ের তারিখগুলি প্রদান করে। আপনি যে কোডটির প্রস্তাব দিচ্ছেন তা খুব পরিষ্কার এবং ফলনের ব্যবহারটি আমি পছন্দ করি তবে এটি প্রশ্নের উত্তর দেয় না।
মার্টিন

3

আমি 2 তারিখের মধ্যে কার্যদিবসের দিন গণনা করতে এবং জাতীয় ছুটির দিনগুলি বাদ দেওয়ার জন্য, হজম করতে সহজ, অ্যালগরিদমের জন্য অনেক অনুসন্ধান করেছি এবং অবশেষে আমি এই পদ্ধতির সাথে যাওয়ার সিদ্ধান্ত নিয়েছি:

public static int NumberOfWorkingDaysBetween2Dates(DateTime start,DateTime due,IEnumerable<DateTime> holidays)
        {
            var dic = new Dictionary<DateTime, DayOfWeek>();
            var totalDays = (due - start).Days;
            for (int i = 0; i < totalDays + 1; i++)
            {
                if (!holidays.Any(x => x == start.AddDays(i)))
                    dic.Add(start.AddDays(i), start.AddDays(i).DayOfWeek);
            }

            return dic.Where(x => x.Value != DayOfWeek.Saturday && x.Value != DayOfWeek.Sunday).Count();
        } 

মূলত আমি প্রতিটি তারিখের সাথে যেতে এবং আমার শর্তগুলি মূল্যায়ন করতে চেয়েছিলাম:

  1. শনিবার নয়
  2. রবিবার নয়
  3. জাতীয় ছুটি নয়

তবে আমি বারবার তারিখগুলি এড়াতে চেয়েছিলাম।

দৌড়াতে এবং সময়টি পরিমাপ করে 1 টি পূর্ণ বছরের মূল্যায়ন করার প্রয়োজন হয়, আমি নিম্নলিখিত ফলাফলটিতে চলে যাই:

static void Main(string[] args)
        {
            var start = new DateTime(2017, 1, 1);
            var due = new DateTime(2017, 12, 31);

            var sw = Stopwatch.StartNew();
            var days = NumberOfWorkingDaysBetween2Dates(start, due,NationalHolidays());
            sw.Stop();

            Console.WriteLine($"Total working days = {days} --- time: {sw.Elapsed}");
            Console.ReadLine();

            // result is:
           // Total working days = 249-- - time: 00:00:00.0269087
        }

সম্পাদনা করুন: একটি নতুন পদ্ধতি আরও সহজ:

public static int ToBusinessWorkingDays(this DateTime start, DateTime due, DateTime[] holidays)
        {
            return Enumerable.Range(0, (due - start).Days)
                            .Select(a => start.AddDays(a))
                            .Where(a => a.DayOfWeek != DayOfWeek.Sunday)
                            .Where(a => a.DayOfWeek != DayOfWeek.Saturday)
                            .Count(a => !holidays.Any(x => x == a));

        }

1

আমি মনে করি উপরোক্ত উত্তরগুলির কোনটিই আসলে সঠিক নয়। এগুলির মধ্যে কোনওটিই বিশেষ বিশেষ কেস সমাধান করে না যেমন তারিখগুলি শুরু হয় এবং সপ্তাহান্তের মাঝামাঝি সময়ে শেষ হয়, যখন তারিখটি শুক্রবার থেকে শুরু হয় এবং পরবর্তী সোমবারে শেষ হয়, ইত্যাদি top শীর্ষে, তারা সমস্ত গণনা সম্পূর্ণ করে দেয় দিন, সুতরাং যদি শুরুর তারিখ উদাহরণস্বরূপ কোনও শনিবারের মাঝামাঝি হয়, তবে এটি কার্যকরী দিনগুলি থেকে পুরো দিনটিকে বিয়োগ করবে, ভুল ফলাফল দেয় ...

যাইহোক, আমার সমাধানটি এখানে বেশ দক্ষ এবং সহজ এবং এটি সকল ক্ষেত্রে কার্যকর। কৌশলটি শুরু এবং শেষ তারিখগুলির জন্য কেবল পূর্বের সোমবারটি সন্ধান করা এবং তারপরে উইকএন্ডে শুরু এবং শেষ হওয়ার পরে একটি সামান্য ক্ষতিপূরণ করুন:

public double WorkDays(DateTime startDate, DateTime endDate){
        double weekendDays;

        double days = endDate.Subtract(startDate).TotalDays;

        if(days<0) return 0;

        DateTime startMonday = startDate.AddDays(DayOfWeek.Monday - startDate.DayOfWeek).Date;
        DateTime endMonday = endDate.AddDays(DayOfWeek.Monday - endDate.DayOfWeek).Date;

        weekendDays = ((endMonday.Subtract(startMonday).TotalDays) / 7) * 2;

        // compute fractionary part of weekend days
        double diffStart = startDate.Subtract(startMonday).TotalDays - 5;
        double diffEnd = endDate.Subtract(endMonday).TotalDays - 5;

        // compensate weekenddays
        if(diffStart>0) weekendDays -= diffStart;
        if(diffEnd>0) weekendDays += diffEnd;

        return days - weekendDays;
    }

4
এটি শনিবার এবং রবিবারের সাথে ডাকা হলে -1 প্রত্যাবর্তন করে।
ওয়েলকাহোলিজম

1
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime start = new DateTime(2014, 1, 1);
            DateTime stop = new DateTime(2014, 12, 31);

            int totalWorkingDays = GetNumberOfWorkingDays(start, stop);

            Console.WriteLine("There are {0} working days.", totalWorkingDays);
        }

        private static int GetNumberOfWorkingDays(DateTime start, DateTime stop)
        {
            TimeSpan interval = stop - start;

            int totalWeek = interval.Days / 7;
            int totalWorkingDays = 5 * totalWeek;

            int remainingDays = interval.Days % 7;


            for (int i = 0; i <= remainingDays; i++)
            {
                DayOfWeek test = (DayOfWeek)(((int)start.DayOfWeek + i) % 7);
                if (test >= DayOfWeek.Monday && test <= DayOfWeek.Friday)
                    totalWorkingDays++;
            }

            return totalWorkingDays;
        }
    }
}

1

কাজ করে এবং লুপ ছাড়াই

এই পদ্ধতিটি কোনও লুপ ব্যবহার করে না এবং এটি আসলে বেশ সহজ। এটি তারিখের পরিধিটি পুরো সপ্তাহগুলিতে প্রসারিত করে যেহেতু আমরা জানি যে প্রতি সপ্তাহে 5 টি ব্যবসায়িক দিন রয়েছে। এরপরে এটি সঠিক ফলাফল পেতে শুরু এবং শেষ থেকে বিয়োগ করতে ব্যবসায়িক দিনের সংখ্যা সন্ধান করতে একটি সারণী ব্যবহার করে। কী চলছে তা দেখানোর জন্য আমি গণনাটি প্রসারিত করেছি, তবে প্রয়োজনে পুরো জিনিসটি একটি একক লাইনে ঘনীভূত করা যেতে পারে।

যাইহোক, এটি আমার পক্ষে কাজ করে এবং তাই আমি ভেবেছিলাম যে এটি অন্যকে সহায়তা করতে পারে যদি আমি এটি এখানে পোস্ট করি। শুভ কোডিং।

গণনা

  • টি: তারিখের মধ্যে দিনের মোট সংখ্যা (1 যদি নূন্যতম = সর্বোচ্চ)
  • a + b: পুরো সপ্তাহে প্রসারিত করতে অতিরিক্ত দিন প্রয়োজন
  • কে: 1.4 হ'ল প্রতি সপ্তাহে দিবস সংখ্যা, অর্থাৎ (টি / 7) * 5
  • সি: মোট থেকে বিয়োগের সাপ্তাহিক দিনের সংখ্যা
  • মি: সপ্তাহের প্রতিটি দিনের জন্য "গ" এর মান সন্ধান করতে ব্যবহৃত একটি সারণী

সংস্কৃতি

কোড সোমবার থেকে শুক্রবারের কাজের সপ্তাহ ধরে। রবিবার থেকে বৃহস্পতিবারের মতো অন্যান্য সংস্কৃতির জন্য আপনাকে গণনার আগে তারিখগুলি অফসেট করতে হবে।

পদ্ধতি

public int Weekdays(DateTime min, DateTime max) 
{       
        if (min.Date > max.Date) throw new Exception("Invalid date span");
        var t = (max.AddDays(1).Date - min.Date).TotalDays;
        var a = (int) min.DayOfWeek;
        var b = 6 - (int) max.DayOfWeek;
        var k = 1.4;
        var m = new int[]{0, 0, 1, 2, 3, 4, 5}; 
        var c = m[a] + m[b];
        return (int)((t + a + b) / k) - c;
}

4
আপনি 1.4 মান সহ কে পেতে পারেন?
তোহা

0

আমি আমার সমাধানটি ভাগ করে নেব। এটি আমার পক্ষে কাজ করেছে, সম্ভবত আমি লক্ষ্য করছি না / জানি না যে একটি বাগ রয়েছে। আমি যদি প্রথম থাকে তবে প্রথম অসম্পূর্ণ সপ্তাহটি পেয়ে শুরু করেছি। পুরো সপ্তাহটি শনিবার রবিবার থেকে ছিল, সুতরাং যদি (অন্তঃ) _ এখন.ডাইঅফউইক 0 (রবিবার) না হয় তবে প্রথম সপ্তাহটি অসম্পূর্ণ ছিল।

আমি প্রথম সপ্তাহের শনিবারের জন্য কেবল 1 থেকে প্রথম সপ্তাহের গণনাটি বিয়োগ করি তারপরে এটি নতুন গণনায় যুক্ত করব;

তারপরে আমি সর্বশেষ অসম্পূর্ণ সপ্তাহটি পেয়েছি, তারপরে রবিবার এর জন্য 1 টি বিয়োগ করে নতুন গণনায় যুক্ত করুন।

তারপরে অবশেষে, পূর্ণ সপ্তাহের সংখ্যা 5 (সপ্তাহের দিনগুলি) কে নতুন গণনায় যুক্ত করা হয়েছিল।

public int RemoveNonWorkingDays(int numberOfDays){

            int workingDays = 0;

            int firstWeek = 7 - (int)_now.DayOfWeek;

            if(firstWeek < 7){

                if(firstWeek > numberOfDays)
                    return numberOfDays;

                workingDays += firstWeek-1;
                numberOfDays -= firstWeek;
            }


            int lastWeek = numberOfDays % 7;

            if(lastWeek > 0){

                numberOfDays -= lastWeek;
                workingDays += lastWeek - 1;

            }

            workingDays += (numberOfDays/7)*5;

            return workingDays;
        }

0

এই কোডটির একটি কঠিন টিএসকিউএল সংস্করণ খুঁজে পেতে আমার সমস্যা হচ্ছে। নীচে হলিডে টেবিল যুক্ত করে এখানে মূলত সি # কোডের একটি রূপান্তর রয়েছে যা ছুটির প্রাক গণনা করতে ব্যবহার করা উচিত।

CREATE TABLE dbo.Holiday
(
    HolidayDt       DATE NOT NULL,
    Name            NVARCHAR(50) NOT NULL,
    IsWeekday       BIT NOT NULL,
    CONSTRAINT PK_Holiday PRIMARY KEY (HolidayDt)
)
GO
CREATE INDEX IDX_Holiday ON Holiday (HolidayDt, IsWeekday)

GO

CREATE function dbo.GetBusinessDays
(
     @FirstDay  datetime,
     @LastDay   datetime
) 
RETURNS INT
 AS
BEGIN
    DECLARE @BusinessDays INT, @FullWeekCount INT 
    SELECT  @FirstDay = CONVERT(DATETIME,CONVERT(DATE,@FirstDay))
        ,   @LastDay = CONVERT(DATETIME,CONVERT(DATE,@LastDay))

    IF @FirstDay > @LastDay
        RETURN NULL;

    SELECT @BusinessDays = DATEDIFF(DAY, @FirstDay, @LastDay) + 1 
    SELECT @FullWeekCount = @BusinessDays / 7;

    -- find out if there are weekends during the time exceedng the full weeks
    IF @BusinessDays > (@FullWeekCount * 7)
    BEGIN
    -- we are here to find out if there is a 1-day or 2-days weekend
    -- in the time interval remaining after subtracting the complete weeks
        DECLARE @firstDayOfWeek INT, @lastDayOfWeek INT;
        SELECT @firstDayOfWeek = DATEPART(DW, @FirstDay), @lastDayOfWeek = DATEPART(DW, @LastDay);

        IF @lastDayOfWeek < @firstDayOfWeek
                SELECT @lastDayOfWeek = @lastDayOfWeek + 7;

        IF @firstDayOfWeek <= 6 
            BEGIN
                IF (@lastDayOfWeek >= 7) --Both Saturday and Sunday are in the remaining time interval
                    BEGIN 
                        SELECT @BusinessDays = @BusinessDays - 2
                    END
                ELSE IF @lastDayOfWeek>=6 --Only Saturday is in the remaining time interval
                    BEGIN
                        SELECT @BusinessDays = @BusinessDays - 1
                    END

            END
        ELSE IF @firstDayOfWeek <= 7 AND @lastDayOfWeek >=7 -- Only Sunday is in the remaining time interval
        BEGIN 
            SELECT @BusinessDays = @BusinessDays - 1
        END
    END

    -- subtract the weekends during the full weeks in the interval
    DECLARE @Holidays INT;
    SELECT  @Holidays = COUNT(*) 
    FROM    Holiday 
    WHERE   HolidayDt BETWEEN @FirstDay AND @LastDay 
    AND     IsWeekday = CAST(1 AS BIT)

    SELECT @BusinessDays = @BusinessDays - (@FullWeekCount + @FullWeekCount) -- - @Holidays

    RETURN @BusinessDays
END

0
    int BusinessDayDifference(DateTime Date1, DateTime Date2)
    {
        int Sign = 1;
        if (Date2 > Date1)
        {
            Sign = -1;
            DateTime TempDate = Date1;
            Date1 = Date2;
            Date2 = TempDate;
        }
        int BusDayDiff = (int)(Date1.Date - Date2.Date).TotalDays;
        if (Date1.DayOfWeek == DayOfWeek.Saturday)
            BusDayDiff -= 1;
        if (Date2.DayOfWeek == DayOfWeek.Sunday)
            BusDayDiff -= 1;
        int Week1 = GetWeekNum(Date1);
        int Week2 = GetWeekNum(Date2);
        int WeekDiff = Week1 - Week2;
        BusDayDiff -= WeekDiff * 2;
        foreach (DateTime Holiday in Holidays)
            if (Date1 >= Holiday && Date2 <= Holiday)
                BusDayDiff--;
        BusDayDiff *= Sign;
        return BusDayDiff;
    }

    private int GetWeekNum(DateTime Date)
    {
        return (int)(Date.AddDays(-(int)Date.DayOfWeek).Ticks / TimeSpan.TicksPerDay / 7);
    }

0

এই সমস্যার জন্য এখানে একটি খুব সাধারণ সমাধান। দিনটি ঘেরাও করার জন্য এবং ডেকঅফউইকে স্ট্রিংয়ে রূপান্তর করে কোনও ওয়ার্ক ডে বা উইকএন্ড আছে কিনা তা গণনা করার জন্য আমাদের কাছে তারিখ, শেষের তারিখ এবং "লুপের জন্য" রয়েছে।

class Program
{
    static void Main(string[] args)
    {
        DateTime day = new DateTime();
        Console.Write("Inser your end date (example: 01/30/2015): ");
        DateTime endDate = DateTime.Parse(Console.ReadLine());
        int numberOfDays = 0;
        for (day = DateTime.Now.Date; day.Date < endDate.Date; day = day.Date.AddDays(1))
        {
            string dayToString = Convert.ToString(day.DayOfWeek);
            if (dayToString != "Saturday" && dayToString != "Sunday") numberOfDays++;
        }
        Console.WriteLine("Number of working days (not including local holidays) between two dates is "+numberOfDays);
    }
}

0

উত্তর হিসাবে চিহ্নিত হিসাবে চিহ্নিত মন্তব্যের উপর ভিত্তি করে প্রস্তাবিত প্যাচ, পাশাপাশি -> এই সংস্করণটি দিনকে ব্যবসায়িক সময়গুলিতে রূপান্তর করতে চায় ... একই দিনের ঘন্টা বিবেচনা করে।

 /// <summary>
    /// Calculates number of business days, taking into account:
    ///  - weekends (Saturdays and Sundays)
    ///  - bank holidays in the middle of the week
    /// </summary>
    /// <param name="firstDay">First day in the time interval</param>
    /// <param name="lastDay">Last day in the time interval</param>
    /// <param name="bankHolidays">List of bank holidays excluding weekends</param>
    /// <returns>Number of business hours during the 'span'</returns>
    public static int BusinessHoursUntil(DateTime firstDay, DateTime lastDay, params DateTime[] bankHolidays)
    {
        var original_firstDay = firstDay;
        var original_lastDay = lastDay;
        firstDay = firstDay.Date;
        lastDay = lastDay.Date;
        if (firstDay > lastDay)
            return -1; //// throw new ArgumentException("Incorrect last day " + lastDay);

        TimeSpan span = lastDay - firstDay;
        int businessDays = span.Days + 1;
        int fullWeekCount = businessDays / 7;
        // find out if there are weekends during the time exceedng the full weeks
        if (businessDays > fullWeekCount * 7)
        {
            // we are here to find out if there is a 1-day or 2-days weekend
            // in the time interval remaining after subtracting the complete weeks
            int firstDayOfWeek = firstDay.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)firstDay.DayOfWeek;
            int lastDayOfWeek = lastDay.DayOfWeek == DayOfWeek.Sunday ? 7 : (int)lastDay.DayOfWeek;

            if (lastDayOfWeek < firstDayOfWeek)
                lastDayOfWeek += 7;
            if (firstDayOfWeek <= 6)
            {
                if (lastDayOfWeek >= 7)// Both Saturday and Sunday are in the remaining time interval
                    businessDays -= 2;
                else if (lastDayOfWeek >= 6)// Only Saturday is in the remaining time interval
                    businessDays -= 1;
            }
            else if (firstDayOfWeek <= 7 && lastDayOfWeek >= 7)// Only Sunday is in the remaining time interval
                businessDays -= 1;
        }

        // subtract the weekends during the full weeks in the interval
        businessDays -= fullWeekCount + fullWeekCount;

        if (bankHolidays != null && bankHolidays.Any())
        {
            // subtract the number of bank holidays during the time interval
            foreach (DateTime bankHoliday in bankHolidays)
            {
                DateTime bh = bankHoliday.Date;
                if (firstDay <= bh && bh <= lastDay)
                    --businessDays;
            }
        }

        int total_business_hours = 0;
        if (firstDay.Date == lastDay.Date)
        {//If on the same day, go granular with Hours from the Orginial_*Day values
            total_business_hours = (int)(original_lastDay - original_firstDay).TotalHours;
        }
        else
        {//Convert Business-Days to TotalHours
            total_business_hours = (int)(firstDay.AddDays(businessDays).AddHours(firstDay.Hour) - firstDay).TotalHours;
        }
        return total_business_hours;
    }

0

আমি শনিবার একটি ব্যবসায়ের দিন, বা এমনকি ব্যবসায়ের দিন হিসাবে বিবেচিত সপ্তাহের দু'দিক দিন রয়েছে এমন ক্ষেত্রেও যেমন প্যারামিটার হিসাবে একটি ব্যবসায়িক সপ্তাহকে সমর্থন করার জন্য আমি @ অ্যালেক্সান্ডার এবং @ স্লুমার জবাব উন্নত করেছি:

/// <summary>
/// Calculate the number of business days between two dates, considering:
///  - Days of the week that are not considered business days.
///  - Holidays between these two dates.
/// </summary>
/// <param name="fDay">First day of the desired 'span'.</param>
/// <param name="lDay">Last day of the desired 'span'.</param>
/// <param name="BusinessDaysOfWeek">Days of the week that are considered to be business days, if NULL considers monday, tuesday, wednesday, thursday and friday as business days of the week.</param>
/// <param name="Holidays">Holidays, if NULL, considers no holiday.</param>
/// <returns>Number of business days during the 'span'</returns>
public static int BusinessDaysUntil(this DateTime fDay, DateTime lDay, DayOfWeek[] BusinessDaysOfWeek = null, DateTime[] Holidays = null)
{
    if (BusinessDaysOfWeek == null)
        BusinessDaysOfWeek = new DayOfWeek[] { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday };
    if (Holidays == null)
        Holidays = new DateTime[] { };

    fDay = fDay.Date;
    lDay = lDay.Date;

    if (fDay > lDay)
        throw new ArgumentException("Incorrect last day " + lDay);

    int bDays = (lDay - fDay).Days + 1;
    int fullWeekCount = bDays / 7;
    int fullWeekCountMult = 7 - WeekDays.Length;
    //  Find out if there are weekends during the time exceedng the full weeks
    if (bDays > (fullWeekCount * 7))
    {
        int fDayOfWeek = (int)fDay.DayOfWeek;
        int lDayOfWeek = (int)lDay.DayOfWeek;

        if (fDayOfWeek > lDayOfWeek)
            lDayOfWeek += 7;

        // If they are the same, we already covered it right before the Holiday subtraction
        if (lDayOfWeek != fDayOfWeek)
        {
            //  Here we need to see if any of the days between are considered business days
            for (int i = fDayOfWeek; i <= lDayOfWeek; i++)
                if (!WeekDays.Contains((DayOfWeek)(i > 6 ? i - 7 : i)))
                    bDays -= 1;
        }
    }

    //  Subtract the days that are not in WeekDays[] during the full weeks in the interval
    bDays -= (fullWeekCount * fullWeekCountMult);
    //  Subtract the number of bank holidays during the time interval
    bDays = bDays - Holidays.Select(x => x.Date).Count(x => fDay <= x && x <= lDay);

    return bDays;
}

0

এখানে ফাংশনটি আমরা দুটি তারিখের মধ্যে ব্যবসায়ের দিন গণনা করতে ব্যবহার করতে পারি। আমি ছুটির তালিকা ব্যবহার করছি না কারণ এটি দেশ / অঞ্চল জুড়ে পরিবর্তিত হতে পারে।

যদি আমরা যাইহোক এটি ব্যবহার করতে চাই তবে আমরা তৃতীয় যুক্তিটি ছুটির তালিকা হিসাবে গ্রহণ করতে পারি এবং গণনা বাড়ানোর আগে আমাদের পরীক্ষা করে দেখা উচিত যে তালিকায় ডি নেই

public static int GetBussinessDaysBetweenTwoDates(DateTime StartDate,   DateTime EndDate)
    {
        if (StartDate > EndDate)
            return -1;

        int bd = 0;

        for (DateTime d = StartDate; d < EndDate; d = d.AddDays(1))
        {
            if (d.DayOfWeek != DayOfWeek.Saturday && d.DayOfWeek != DayOfWeek.Sunday)
                bd++;
        }

        return bd;
    }

0

আমি বিশ্বাস করি এটি একটি সহজ উপায় হতে পারে:

    public int BusinessDaysUntil(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

এখানে আরও একটি ধারণা এখানে রয়েছে - এই পদ্ধতিটি কোনও কার্যদিবস এবং ছুটির দিন নির্দিষ্ট করতে দেয়।

এখানে ধারণাটি হ'ল আমরা তারিখের মূলটির সন্ধান করি সপ্তাহের প্রথম প্রথম কার্যদিবস থেকে সপ্তাহের শেষ সপ্তাহের দিন পর্যন্ত। এই সহজে (পুরো সপ্তাহ গণনা করতে সক্ষম ছাড়া তারিখ সর্বাঙ্গে iterating)। তারপরে আমাদের যা করতে হবে তা হ'ল এই মূল পরিসীমাটির শুরু এবং শেষের আগে যে কার্যদিবস পড়েছে তা যুক্ত করা।

public static int CalculateWorkingDays(
    DateTime startDate, 
    DateTime endDate, 
    IList<DateTime> holidays, 
    DayOfWeek firstDayOfWeek,
    DayOfWeek lastDayOfWeek)
{
    // Make sure the defined working days run contiguously
    if (lastDayOfWeek < firstDayOfWeek)
    {
        throw new Exception("Last day of week cannot fall before first day of week!");
    }

    // Create a list of the days of the week that make-up the weekend by working back
    // from the firstDayOfWeek and forward from lastDayOfWeek to get the start and end
    // the weekend
    var weekendStart = lastDayOfWeek == DayOfWeek.Saturday ? DayOfWeek.Sunday : lastDayOfWeek + 1;
    var weekendEnd = firstDayOfWeek == DayOfWeek.Sunday ? DayOfWeek.Saturday : firstDayOfWeek - 1;
    var weekendDays = new List<DayOfWeek>();

    var w = weekendStart;
    do {
        weekendDays.Add(w);
        if (w == weekendEnd) break;
        w = (w == DayOfWeek.Saturday) ? DayOfWeek.Sunday : w + 1;
    } while (true);


    // Force simple dates - no time
    startDate = startDate.Date;
    endDate = endDate.Date;

    // Ensure a progessive date range
    if (endDate < startDate)
    {
        var t = startDate;
        startDate = endDate;
        endDate = t;
    }

    // setup some working variables and constants
    const int daysInWeek = 7;           // yeah - really!
    var actualStartDate = startDate;    // this will end up on startOfWeek boundary
    var actualEndDate = endDate;        // this will end up on weekendEnd boundary
    int workingDaysInWeek = daysInWeek - weekendDays.Count;

    int workingDays = 0;        // the result we are trying to find
    int leadingDays = 0;        // the number of working days leading up to the firstDayOfWeek boundary
    int trailingDays = 0;       // the number of working days counting back to the weekendEnd boundary

    // Calculate leading working days
    // if we aren't on the firstDayOfWeek we need to step forward to the nearest
    if (startDate.DayOfWeek != firstDayOfWeek)
    {
        var d = startDate;
        do {
            if (d.DayOfWeek == firstDayOfWeek || d >= endDate)
            {
                actualStartDate = d;
                break;  
            }
            if (!weekendDays.Contains(d.DayOfWeek))
            {
                leadingDays++;
            }
            d = d.AddDays(1);
        } while(true);
    }

    // Calculate trailing working days
    // if we aren't on the weekendEnd we step back to the nearest
    if (endDate >= actualStartDate && endDate.DayOfWeek != weekendEnd)
    {
        var d = endDate;
        do {
            if (d.DayOfWeek == weekendEnd || d < actualStartDate)
            {
                actualEndDate = d;
                break;  
            }
            if (!weekendDays.Contains(d.DayOfWeek))
            {
                trailingDays++;
            }
            d = d.AddDays(-1);
        } while(true);
    }

    // Calculate the inclusive number of days between the actualStartDate and the actualEndDate
    var coreDays = (actualEndDate - actualStartDate).Days + 1;
    var noWeeks =  coreDays / daysInWeek;

    // add together leading, core and trailing days
    workingDays +=  noWeeks * workingDaysInWeek;
    workingDays += leadingDays;
    workingDays += trailingDays;

    // Finally remove any holidays that fall within the range.
    if (holidays != null)
    {
        workingDays -= holidays.Count(h => h >= startDate && (h <= endDate));
    }

    return workingDays;
}

0

যেহেতু আমি মন্তব্য করতে পারি না। গ্রহণযোগ্য সমাধানে আরও একটি সমস্যা রয়েছে যেখানে উইকএন্ডে অবস্থিত হয়েও ব্যাঙ্কের ছুটিগুলি বিয়োগ করা হয়। অন্যান্য ইনপুট কীভাবে চেক করা হচ্ছে তা দেখে এটি কেবল উপযুক্ত।

ভবিষ্যদ্বাণী তাই করা উচিত:

    // subtract the number of bank holidays during the time interval
    foreach (DateTime bankHoliday in bankHolidays)
    {
        DateTime bh = bankHoliday.Date;

        // Do not subtract bank holidays when they fall in the weekend to avoid double subtraction
        if (bh.DayOfWeek == DayOfWeek.Saturday || bh.DayOfWeek == DayOfWeek.Sunday)
                continue;

        if (firstDay <= bh && bh <= lastDay)
            --businessDays;
    }

0

আপনি যদি এমভিসি ব্যবহার করেন তবে এখানে একটি পদ্ধতির কথা রয়েছে। আমি জাতীয় ছুটির দিনগুলি বা ছুটির দিনগুলিতে এটি আনার মাধ্যমে বাদ দেওয়ার জন্য কোনও উত্সব দিনগুলি গণনা করেছি যা আপনাকে একটি তৈরি করতে হবে।

        foreach (DateTime day in EachDay(model))
        {
            bool key = false;
            foreach (LeaveModel ln in holidaycalendar)
            {
                if (day.Date == ln.Date && day.DayOfWeek != DayOfWeek.Saturday && day.DayOfWeek != DayOfWeek.Sunday)
                {
                    key = true; break;
                }
            }
            if (day.DayOfWeek == DayOfWeek.Saturday || day.DayOfWeek == DayOfWeek.Sunday)
            {
                key = true;
            }
            if (key != true)
            {
                leavecount++;
            }
        }

ছেড়ে দেওয়া মডেল এখানে একটি তালিকা


0

এই কাজের জন্য আমি লিখেছি এমন একটি সহায়ক ফাংশন এখানে।
এটি outপ্যারামিটারের মাধ্যমে উইকএন্ডের গণনাও ফেরত দেয় ।
যদি আপনি চান আপনি বিভিন্ন উইকএন্ডের দিনগুলি ব্যবহার করেন এমন দেশগুলির জন্য ছুটির সময়ের মধ্যে "উইকএন্ড" দিনগুলি কাস্টমাইজ করতে পারেন বা holidaysচ্ছিক weekendDays[]প্যারামিটারের ছুটির গর্তকে অন্তর্ভুক্ত করতে পারেন :

public static int GetNetworkDays(DateTime startDate, DateTime endDate,out int totalWeekenDays, DayOfWeek[] weekendDays = null)
{
    if (startDate >= endDate)
    {
        throw new Exception("start date can not be greater then or equel to end date");
    }

    DayOfWeek[] weekends = new DayOfWeek[] { DayOfWeek.Sunday, DayOfWeek.Saturday };
    if (weekendDays != null)
    {
        weekends = weekendDays;
    }

    var totaldays = (endDate - startDate).TotalDays + 1; // add one to include the first day to
    var counter = 0;
    var workdaysCounter = 0;
    var weekendsCounter = 0;

    for (int i = 0; i < totaldays; i++)
    {

        if (weekends.Contains(startDate.AddDays(counter).DayOfWeek))
        {
            weekendsCounter++;
        }
        else
        {
            workdaysCounter++;
        }

        counter++;
    }

    totalWeekenDays = weekendsCounter;
    return workdaysCounter;
}

0

আমি নিম্নলিখিত সমাধান নিয়ে এসেছি

var dateStart = new DateTime(2019,01,10);
var dateEnd = new DateTime(2019,01,31);

var timeBetween = (dateEnd - dateStart).TotalDays + 1;
int numberOf7DayWeeks = (int)(timeBetween / 7);
int numberOfWeekendDays = numberOf7DayWeeks * 2;
int workingDays =(int)( timeBetween - numberOfWeekendDays);

if(dateStart.DayOfWeek == DayOfWeek.Saturday || dateEnd.DayOfWeek == DayOfWeek.Sunday){
    workingDays -=2;
}       
if(dateStart.DayOfWeek == DayOfWeek.Sunday || dateEnd.DayOfWeek == DayOfWeek.Saturday){
    workingDays -=1;
}

0

আপনাকে কেবল সময়ের পরিসরে প্রতিটি দিনের মধ্যে পুনরাবৃত্তি করতে হবে এবং শনিবার বা রবিবার যদি কাউন্টার থেকে কোনও দিন বিয়োগ করতে হয়।

    private float SubtractWeekend(DateTime start, DateTime end) {
        float totaldays = (end.Date - start.Date).Days;
        var iterationVal = totalDays;
        for (int i = 0; i <= iterationVal; i++) {
            int dayVal = (int)start.Date.AddDays(i).DayOfWeek;
            if(dayVal == 6 || dayVal == 0) {
                // saturday or sunday
                totalDays--;
            }
        }
        return totalDays;
    }

0
public static int CalculateBusinessDaysInRange(this DateTime startDate, DateTime endDate, params DateTime[] holidayDates)
{
    endDate = endDate.Date;
    if(startDate > endDate)
        throw new ArgumentException("The end date can not be before the start date!", nameof(endDate));
    int accumulator = 0;
    DateTime itterator = startDate.Date;
    do 
    {
        if(itterator.DayOfWeek != DayOfWeek.Saturday && itterator.DayOfWeek != DayOfWeek.Sunday && !holidayDates.Any(hol => hol.Date == itterator))
        { accumulator++; }
    } 
    while((itterator = itterator.AddDays(1)).Date <= endDate);
    return accumulator
}

আমি কেবল এটি পোস্ট করছি কারণ যে সমস্ত দুর্দান্ত উত্তর দেওয়া হয়েছে তার পরেও গণিতের কোনওটিই আমার কাছে বোধগম্য হয়নি। এটি অবশ্যই একটি KISS পদ্ধতি যা কাজ করা এবং মোটামুটি রক্ষণাবেক্ষণ করা উচিত। আপনি যদি ২-৩ মাসের বেশি রেঞ্জগুলি গণনা করে থাকেন তবে এটি সবচেয়ে কার্যকর উপায় হবে না Gran আমরা কেবল নির্ধারণ করি এটি শনিবার বা রবিবার বা তারিখটি প্রদত্ত ছুটির তারিখ কিনা। এটি না হলে আমরা একটি ব্যবসায়িক দিন যুক্ত করি। যদি তা হয় তবে সবকিছু ঠিক আছে।

আমি নিশ্চিত যে লিনকিউ এর মাধ্যমে আরও সহজসাধ্য হতে পারে তবে এটি বোঝা আরও সহজ।


0

ব্যবসায়ের দিন গণনা করার জন্য আরেকটি পদ্ধতির, ছুটির দিনগুলি বিবেচনা না করে, কিন্তু দিনের কিছু সময়কে এক ভগ্নাংশের পরিমাণ ফেরত দেওয়ার বিষয়টি বিবেচনা করে:

public static double GetBusinessDays(DateTime startD, DateTime endD)
{
    while (IsWeekend(startD))
        startD = startD.Date.AddDays(1);

    while (IsWeekend(endD))
        endD = endD.Date.AddDays(-1);

    var bussDays = (endD - startD).TotalDays -
        (2 * ((int)(endD - startD).TotalDays / 7)) -
        (startD.DayOfWeek > endD.DayOfWeek ? 2 : 0);

    return bussDays;
}

public static bool IsWeekend(DateTime d)
{
    return d.DayOfWeek == DayOfWeek.Saturday || d.DayOfWeek == DayOfWeek.Sunday;
}

আপনি এটি এখানে ঝাঁকুনি করতে পারেন: https://rextester.com/ASHRS53997


-1

এটি একটি জেনেরিক সমাধান।

শুরুর তারিখের শুরু সংখ্যা start

উইকএন্ডডে_1 এ সপ্তাহের শেষের দিন ner

দিনের নম্বর - সোম - 1, মঙ্গল - 2, ... স্যাট - 6, সান -7।

পার্থক্য দুটি তারিখের মধ্যে পার্থক্য ..

উদাহরণ: শুরুর তারিখ: 4 এপ্রিল, 2013, শেষ তারিখ: 14 এপ্রিল, 2013

পার্থক্য: 10, প্রারম্ভকালীন মূল্য: 4, সাপ্তাহিক দিন_1: 7 (যদি রবিবার আপনার জন্য একটি উইকএন্ড হয়।)

এটি আপনাকে ছুটির সংখ্যা দেবে।

ব্যবসায়ের দিনের সংখ্যা = (পার্থক্য + 1) - হলিডে 1

    if (startdayvalue > weekendday_1)
    {

        if (difference > ((7 - startdayvalue) + weekendday_1))
        {
            holiday1 = (difference - ((7 - startdayvalue) + weekendday_1)) / 7;
            holiday1 = holiday1 + 1;
        }
        else
        {
            holiday1 = 0;
        }
    }
    else if (startdayvalue < weekendday_1)
    {

        if (difference > (weekendday_1 - startdayvalue))
        {
            holiday1 = (difference - (weekendday_1 - startdayvalue)) / 7;
            holiday1 = holiday1 + 1;
        }
        else if (difference == (weekendday_1 - startdayvalue))
        {
            holiday1 = 1;
        }
        else
        {
            holiday1 = 0;
        }
    }
    else
    {
        holiday1 = difference / 7;
        holiday1 = holiday1 + 1;
    }
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.