C#: Hinzufügen Werktagen von einem cetain Datum

Ich habe Mühe, dies zu tun. Ich bin momentan dabei, eine Methode, die add Werktage zu einem bestimmten Datum.
zum Beispiel möchte ich hinzufügen-3 Werktage, sept 15, 2010 (Mittwoch) - Methode liefert sept 20 (Montag nächste Woche). es missachtet Samstag und Sonntag, weil seine nicht-Arbeitstag..

So etwas in C#:

DateTime AddWorkingDays(DateTime specificDate, int workingDaysToAdd)
{
   return specificDate + (workingDaysToAdd - (all saturdays and sundays))
}

Halte ich nicht für Besondere Feiertage, die auf den Berechnungen, ich habe gerade buchstäblich hinzufügen möchten Tage außer Samstag und Sonntag.. vielen Dank im Voraus! =)

InformationsquelleAutor CSharpNoob | 2010-09-15

algorithm c#datetime

18

Wenn Sie nicht brauchen, zu prüfen, Ferien, würde ich vorschlagen, Sie tun so etwas wie dieses:
```
public static DateTime AddWorkingDays(DateTime specificDate,
                                      int workingDaysToAdd)
{
    int completeWeeks = workingDaysToAdd / 5;
    DateTime date = specificDate.AddDays(completeWeeks * 7);
    workingDaysToAdd = workingDaysToAdd % 5;
    for (int i = 0; i < workingDaysToAdd; i++)
    {
        date = date.AddDays(1);
        while (!IsWeekDay(date))
        {
            date = date.AddDays(1);
        }
    }
    return date;
}

private static bool IsWeekDay(DateTime date)
{
    DayOfWeek day = date.DayOfWeek;
    return day != DayOfWeek.Saturday && day != DayOfWeek.Sunday;
}
```
Es ist ineffizient, aber einfach zu verstehen. Für eine effiziente version, Sie würden arbeiten aus der Anzahl der vollständigen Wochen, um hinzuzufügen, wie vor, aber habe dann eine Zuordnung von jedem "aktuelle Wochentag" und "Werktagen Links hinzufügen" zu "Anzahl der tatsächlichen Tage hinzufügen". Dann könnten Sie einfach work out die Gesamtzahl der Tage an, die Sie hinzufügen möchten, und tun es in einem Aufruf.

EDIT: In Bezug auf den Grad der Ineffizienz... es ist wirklich nicht sehr schlecht. Es werden nur manuelle "ist das ein Wochenende" Prüfungen für bis zu 4 Tage, das ist nicht zu schlecht. Insbesondere, trotz Igors (aktuell zum Zeitpunkt der Veröffentlichung) behauptet, es ist eher schneller als sein Ansatz, fehlerhafte benchmarks trotz 😉

Beachten Sie, dass es nicht mit negativen Eingänge noch - ich habe noch nicht überprüft.

Einer der Gründe, warum der Ansatz, den ich verwende, ist, dass es sich nicht auf entweder mir oder dem code-Leser wissen, was die Werte in der DayOfWeek enum sind. Ich glaube nicht, egal, ob es 0-6, 1-7, Montag-Sonntag, Samstag-Freitag... oder auch wenn es völlig bizarre Werte. Ich habe nur Vergleiche auf Gleichheit, das macht den code besser "offensichtlich richtig".
- Jon, wäre es effizienter zu nutzen workingDaysToAdd = workingDaysToAdd % 5; date = date.AddDays(workingDaysToAdd); if (date.DayOfWeek == DayOfWeek.Saturday) date.AddDays(2); if (date.DayOfWeek == DayOfWeek.Sunday) date.AddDays(1); anstatt das loop-Konstrukt? Einfach nur neugierig.
- Habe es getestet und es funktioniert, was ich genau brauche. Hast du es on-the-fly? in weniger als 5 Minuten, seit ich es gepostet.. Mann, das ist ziemlich genial.. aber ich würde es begrüßen, effizienter Antworten.. danke btw..
- Ich würde nicht sagen, dass es ineffizient ist, aber alle Dinge sind relativ. Die Antwort, die Konten für die Wochen nach vorne, so dass die meisten es jemals haben wird, um eine Schleife ist 6-mal (max 4 Tage % 5, max 2 Wochenend-Tage). Nicht ein ungeheurer Erfolg.
- Code wird nicht funktionieren, wenn Sie versuchen, fügen Sie 3 Tage Freitag - es gebe Montag anstatt Mittwoch.
- Ja. Froh, dass es funktioniert. Ich kann nicht sagen, dass ich getestet habe oder selbst kompiliert... 🙁 @Anthony: Sicher, es ist wahrscheinlich zu sein, schnell genug in den meisten Fällen... aber es gibt Raum zu verbessern, wenn es überhaupt einen Engpass.
- Dank Jon. Ich werde konvertieren Erweiterung Methode .. =)
- Knackte es am Ende if ((int)specificDate.DayOfWeek + workingdaysToAdd > 5) specificDate = specificDate.AddDays(2); ersetzt die Schleife.
- Yup, so etwas wie, dass funktionieren wird... aber ich würde es nur schwieriger zu Lesen. Es ist nicht so, natürlich Recht... in allem, müssen Sie wissen, die enum-Werte. Ich weiß nicht, aus der Spitze von meinem Kopf, was die Werte für Samstag und Sonntag sind... was ist der Grund, warum ich geschrieben habe, der code, um das nicht zu kümmern.
- Sie haben zerbrochen meine Illusionen... etwas, das Sie nicht kennen, aus der Spitze von Ihrem Kopf an! Ich geben Sie dass das ist Rahmen und nicht C# so vielleicht Ihr status bleibt intakt, wenn auch etwas wackelig 🙂 Sonntag = 0, Samstag = 6, also etwas größer als 5 (Freitag) bedeutet, schlagen wir ein Wochenende und einfügen müssen 2 Tage.
- Es gibt einen größeren Punkt hier, obwohl... wollen Sie verlassen sich auf jeder, der den code liest, zu wissen, die enum-Werte, um zu verstehen, was es tut? Das ist, was ich versucht bin, um Weg von.
- Ich sehe, was Sie sagen & ich bin damit einverstanden, dass Sie hätte zu greifen, um Unterlagen sicher zu sein, was ich machte, wo man sich hinsetzen mit Papier und Stift zu Fuß durch die Schleife, um es zu verstehen, obwohl auf dem Papier für Freitag + 3 Tage bekomme ich am Dienstag als das Ergebnis. @i==0 (date = Friday, date.AddDays(1) = Saturday, !IsWeekday, date.AddDays(1) = Sunday), @i==1 (date = Sunday, date.AddDays(1) = Monday, IsWeekday), @i==2 (date = Monday, date.AddDays(1) = Tuesday), return date = Tuesday Was bin ich?
- Sie übersehen die Tatsache, dass es eine while-Schleife, nicht nur ein einzelner test. Grundsätzlich nehme ich einen Tag, und fahren Sie dann über das Wochenende komplett.
- Ich behaupten, das n th änderungsantrag "Mangels alternativen" und der Rückzug in die Ecke 🙂
- Hier ist ein Algorithmus getestet, um es zu tun, ohne Schleifen über: stackoverflow.com/a/33943576/4389984 (zweite Lösung) Abgesehen von der Erkenntnis des Tages-der Woche-mapping - (1-7 ) und die Lesbarkeit, sehen Sie irgendwelche Fehler in der Logik? Danke!
- Der Mangel an Lesbarkeit macht es viel schwieriger die Suche nach Schwächen, um ehrlich zu sein. Das ist, warum ich wie die looping-option - es ist kinderleicht zu verstehen, und es sei denn, Sie wissen, dass Sie werden hinzufügen viel Arbeit Tagen (nicht der Fall in dieser Frage), würde ich zugunsten der Lesbarkeit über Effizienz. Darüber hinaus ist wirklich einfach zu gehen, von einer naiven Umsetzung, die ignoriert Feiertage eine naive Implementierung, die beinhaltet Feiertage, eine Liste der Feiertage - es ist sehr schwieriger, das gleiche zu tun mit der Berechnung, version.
- Ich bekomme es. Zumal Feiertagen wird wirklich immer komplexer in der Berechnung-version. Vielen Dank für den Einblick!
InformationsquelleAutor Jon Skeet
1

Ganz cool (wie ich finde) ist, die in eine extension-Methode, wie:
```
public static class DateTimeExtensions
{
    public static DateTime AddWorkingDays(this DateTime self, int days)
    {
        self = self.AddDays(days);
        while (self.DayOfWeek == DayOfWeek.Saturday || self.DayOfWeek == DayOfWeek.Sunday)
        {
            self = self.AddDays(1);
        }

        return self;
    }
}
```
damit Ihre endgültige code wird wie folgt Aussehen:
```
specificDate.AddWorkingDays(3);
```
- es fügt nur einen Tag, auch wenn ich den pass 2 oder mehr Tagen..
- Als CSharpNoob darauf hingewiesen, dieser code funktioniert nicht ganz korrekt, aber mir gefällt der Ansatz, eine Erweiterung Methode für diese.
- ja, seine falsche, von mir nicht getestet gut vor der post. sorry Jungs, mein Fehler.
InformationsquelleAutor Leonardo Uzon Nowaczyk

Hier ist, was Sie brauchen :

Aktualisiert :

public static DateTime AddWeekdays(DateTime start, int days)
    {
        int remainder = days % 5;
        int weekendDays = (days / 5) * 2;

        DateTime end = start.AddDays(remainder);

        if (start.DayOfWeek == DayOfWeek.Saturday && days > 0)
        {
            //fix for saturday.
            end = end.AddDays(-1);
        }

        if (end.DayOfWeek == DayOfWeek.Saturday && days > 0)
        {
            //add two days for landing on saturday
            end = end.AddDays(2);
        }
        else if (end.DayOfWeek < start.DayOfWeek)
        {
            //add two days for rounding the weekend
            end = end.AddDays(2);
        }

        //add the remaining days
        return end.AddDays(days + weekendDays - remainder);
    }

aber der datetime-parameter(start) kann auch Sonntag sein und saturrday .. :(.. wenn Samstag und Sonntag, es muss wieder der Mittwoch der nächsten Woche,
Ich habe gerade editiert das tun, was u fragte nach.
Ist es nicht etwas zu kompliziert? Ich denke, dass es getan werden kann in einem viel einfacheren Weg

InformationsquelleAutor Manaf Abu.Rous

int foundWorkingDays = 0;
while (foundWorkingDays < workingDaysToAdd)
{ 
  specificDate= specificDate.AddDays(1); 
  if(specificDate.DayOfWeek != DayOfWeek.Sunday && specificDate.DayOfWeek != DayOfWeek.Saturday)
     foundWorkingDays++;

}
return specificDate;

HINZUGEFÜGT:

class Program
    {

        public static DateTime AddWorkingDays(DateTime specificDate,
                                      int workingDaysToAdd)
        {
            int completeWeeks = workingDaysToAdd / 5;
            DateTime date = specificDate.AddDays(completeWeeks * 7);
            workingDaysToAdd = workingDaysToAdd % 5;
            for (int i = 0; i < workingDaysToAdd; i++)
            {
                date = date.AddDays(1);
                while (!IsWeekDay(date))
                {
                    date = date.AddDays(1);
                }
            }
            return date;
        }

        private static bool IsWeekDay(DateTime date)
        {
            DayOfWeek day = date.DayOfWeek;
            return day != DayOfWeek.Saturday && day != DayOfWeek.Sunday;
        }

        public static DateTime MyAddWorkingDays(DateTime specificDate,
                                      int workingDaysToAdd)
        {
            int foundWorkingDays = 0;
            while (foundWorkingDays < workingDaysToAdd)
            {
                specificDate = specificDate.AddDays(1);
                if (specificDate.DayOfWeek != DayOfWeek.Sunday && specificDate.DayOfWeek != DayOfWeek.Saturday)
                    foundWorkingDays++;

            }
            return specificDate;
        }


        static void Main(string[] args)
        {

            DateTime specificDate = DateTime.Now;

            Stopwatch globalTimer = Stopwatch.StartNew();
            Console.WriteLine(AddWorkingDays(specificDate, 300));  //100000 :)
            globalTimer.Stop();
            Console.WriteLine(globalTimer.ElapsedMilliseconds);

            globalTimer = Stopwatch.StartNew();
            Console.WriteLine(MyAddWorkingDays(specificDate, 300)); //100000 :)
            globalTimer.Stop();
            Console.WriteLine(globalTimer.ElapsedMilliseconds);



            Console.ReadLine();
        }
    }

Ist es effizienter als Herr. Jon Skeet ' s Vorschlag?
Nein. Dies ist im wesentlichen die gleiche Logik, ohne Umgang mit ganzen Wochen vorne. Anstatt also eine Schleife, die von 1 bis 4 (und bis zu zwei Tage am Wochenende), müssen Sie eine Schleife, die von 1 auf n (plus alle Tage am Wochenende)
was ist der Unterschied zwischen MyAddWorkingDays und AddWorkingDays in deinem code?
MyAddWorkingDays ist main, AddWorkingDays ist Herr. Jon Skeet ist eine. Ich habe nicht getestet und die anderen. Versuchen Sie Sie alle, wenn Sie müssen
es versucht, aber es fügt nur 1 Werktag, wenn der angegebene Tag ist Montag-Freitag, und es fügt 2 wenn sa/so.. =)
der erste code hat typo "currentDate" (ich habe es schon behoben). Versuchen Sie, die zweite! 🙂
performance, performance, performance 🙂
Danke Igor, ich habe es nochmal getestet und es funktioniert jetzt perfekt, es ist kürzer als Jon ist und Leistung klug, wie Sie sagen, ist es besser.. und ich werde es konvertieren zu Erweiterung Methode.. thanks alot Mann..
Ihre benchmark ist schrecklich fehlerhaft. Versuchen swapping-Runde, deren Ergebnis Sie zuerst drucken... die Ergebnisse Schalter zu. Sie sind einschließlich JIT-Kompilierung, einschließlich JIT-Kompilierung der Konsole.WriteLine. Versuchen Sie, beide Versionen 10000-mal in einer Schleife, ist auch nur für 300 Tage, und Sie werden finden, meine version ist sehr schneller als Ihr... und so sollte es auch sein, gegeben, dass Sie testen wollen, ob jeden Tag wird auf das Wochenende, anstatt nur ein paar von Ihnen.
Skeet oh, vielen Dank! ja, natürlich, Sie haben Recht. es war das erwartete Ergebnis. Ihr ist schneller, sorry.

InformationsquelleAutor garik

Ist eine alte post, aber jemand könnte daran interessiert sein, eine Erweiterung, die Griffe auch negative Tage. (Ich habe Sie überarbeitet @Jon Antwort)

    public static DateTime AddWeekDays(this DateTime start, int days)
    {
        int direction = Math.Sign(days);

        int completeWeeks = days / 5;
        int remaining = days % 5;

        DateTime end = start.AddDays(completeWeeks * 7);

        for (int i = 0; i < remaining * direction; i++)
        {
            end = end.AddDays(direction * 1);
            while (!IsWeekDay(end))
            {
                end = end.AddDays(direction * 1);
            }
        }
        return end;
    }

    private static bool IsWeekDay(DateTime date)
    {
        DayOfWeek day = date.DayOfWeek;
        return day != DayOfWeek.Saturday && day != DayOfWeek.Sunday;
    }

InformationsquelleAutor Maurizio Pozzobon

Dies scheint mir der sauberste Weg:

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

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

    return date;
}

InformationsquelleAutor tocqueville

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.