Holen Sie sich die richtige Wochennummer eines bestimmten Datums

Ich habe viel gegoogelt und viele Lösungen gefunden, aber keine davon gibt mir die richtige Wochennummer für den 31.12.2012. Auch das Beispiel auf MSDN ( Link ) schlägt fehl.

2012-12-31 ist Montag, daher sollte es Woche 1 sein, aber jede Methode, die ich ausprobiert habe, gibt mir 53. Hier sind einige der Methoden, die ich ausprobiert habe:

Aus der MDSN-Bibliothek:

DateTimeFormatInfo dfi = DateTimeFormatInfo.CurrentInfo;
Calendar cal = dfi.Calendar;

return cal.GetWeekOfYear(date, dfi.CalendarWeekRule, dfi.FirstDayOfWeek);

Lösung 2:

return new GregorianCalendar(GregorianCalendarTypes.Localized).GetWeekOfYear(date, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);

Lösung 3:

CultureInfo ciCurr = CultureInfo.CurrentCulture;
int weekNum = ciCurr.Calendar.GetWeekOfYear(dtPassed, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
return weekNum;

Aktualisieren

Die folgende Methode gibt tatsächlich 1 zurück, wenn das Datum 2012-12-31 ist. Mit anderen Worten, mein Problem war, dass meine Methoden nicht dem ISO-8601-Standard entsprachen.

// This presumes that weeks start with Monday.
// Week 1 is the 1st week of the year with a Thursday in it.
public static int GetIso8601WeekOfYear(DateTime time)
{
    // Seriously cheat.  If its Monday, Tuesday or Wednesday, then it'll 
    // be the same week# as whatever Thursday, Friday or Saturday are,
    // and we always get those right
    DayOfWeek day = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(time);
    if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday)
    {
        time = time.AddDays(3);
    }

    // Return the week of our adjusted day
    return CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(time, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
}

Wie auf dieser MSDN-Seite angegeben, gibt es einen geringfügigen Unterschied zwischen der ISO8601-Wochen- und der .Net-Wochennummerierung.

Eine bessere Erklärung finden Sie in diesem Artikel im MSDN-Blog: " ISO 8601 Week of Year-Format in Microsoft .Net "

Einfach ausgedrückt, .Net ermöglicht die Aufteilung von Wochen auf Jahre, während der ISO-Standard dies nicht tut. In dem Artikel gibt es auch eine einfache Funktion, um die richtige ISO 8601-Wochennummer für die letzte Woche des Jahres zu erhalten.

Update Die folgende Methode gibt tatsächlich 1 zurück, 2012-12-31was in ISO 8601 (z. B. Deutschland) korrekt ist.

// This presumes that weeks start with Monday.
// Week 1 is the 1st week of the year with a Thursday in it.
public static int GetIso8601WeekOfYear(DateTime time)
{
    // Seriously cheat.  If its Monday, Tuesday or Wednesday, then it'll 
    // be the same week# as whatever Thursday, Friday or Saturday are,
    // and we always get those right
    DayOfWeek day = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(time);
    if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday)
    {
        time = time.AddDays(3);
    }

    // Return the week of our adjusted day
    return CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(time, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
} 

Ein Jahr kann mehr als 52 Wochen dauern. Jedes Jahr hat 52 volle Wochen + 1 oder + 2 (Schaltjahr) Tage mehr. Sie machen eine 53. Woche wieder gut.

• 52 Wochen * 7 Tage = 364 Tage.

Sie haben also für jedes Jahr mindestens einen zusätzlichen Tag. Zwei für Schaltjahre. Werden diese zusätzlichen Tage als eigene Wochen gezählt?

Wie viele Wochen es wirklich gibt, hängt vom Starttag Ihrer Woche ab. Betrachten wir dies für 2012.

• USA (Sonntag -> Samstag): 52 Wochen + eine kurze 2-Tage-Woche für 2012-12-30 & 2012-12-31. Dies ergibt insgesamt 53 Wochen. Die letzten beiden Tage dieses Jahres (Sonntag + Montag) bilden ihre eigene kurze Woche.

Überprüfen Sie die Einstellungen Ihrer aktuellen Kultur, um festzustellen, was als erster Tag der Woche verwendet wird.

Wie Sie sehen, ist es normal, 53 zu erhalten.

• Europa (Montag -> Sonntag): Der 2. Januar (2012-1-2) ist der erste Montag, also der erste Tag der ersten Woche. Wenn Sie nach der Wochennummer für den 1. Januar fragen, erhalten Sie 52 zurück, da dies Teil der letzten Woche 2011 ist.

Es ist sogar möglich, eine 54. Woche zu haben. Passiert alle 28 Jahre, wenn der 1. Januar und der 31. Dezember als separate Wochen behandelt werden. Es muss auch ein Schaltjahr sein.

Zum Beispiel hatte das Jahr 2000 54 Wochen. Der 1. Januar (gesessen) war der erste einwöchige Tag und der 31. Dezember (sonntags) war der zweite einwöchige Tag.

var d = new DateTime(2012, 12, 31);
CultureInfo cul = CultureInfo.CurrentCulture;

var firstDayWeek = cul.Calendar.GetWeekOfYear(
    d,
    CalendarWeekRule.FirstDay,
    DayOfWeek.Monday);

int weekNum = cul.Calendar.GetWeekOfYear(
    d,
    CalendarWeekRule.FirstDay,
    DayOfWeek.Monday);

int year = weekNum == 52 && d.Month == 1 ? d.Year - 1 : d.Year;
Console.WriteLine("Year: {0} Week: {1}", year, weekNum);

Ausdrucke: Jahr: 2012 Woche: 54

Wenn Sie die CalendarWeekRule im obigen Beispiel in FirstFullWeek oder FirstFourDayWeek ändern, erhalten Sie 53 zurück. Lassen Sie uns den Starttag am Montag beibehalten, da es sich um Deutschland handelt.

Woche 53 beginnt also am Montag, den 31.12.2012, dauert einen Tag und endet dann.

53 ist die richtige Antwort. Ändern Sie die Kultur nach Deutschland, wenn Sie es versuchen möchten.

CultureInfo cul = CultureInfo.GetCultureInfo("de-DE");

Das ist der Weg:

public int GetWeekNumber()
{
    CultureInfo ciCurr = CultureInfo.CurrentCulture;
    int weekNum = ciCurr.Calendar.GetWeekOfYear(DateTime.Now, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
    return weekNum;
}

Am wichtigsten für ist der CalendarWeekRuleParameter.

Siehe hier: https://msdn.microsoft.com/query/dev14.query?appId=Dev14IDEF1&l=IT-IT&k=k(System.Globalization.CalendarWeekRule);k(TargetFrameworkMoniker-.NETFramework

Gute Nachrichten! Eine Pull-Anfrage wird hinzugefügtSystem.Globalization.ISOWeek zu .NET Core , wurde gerade zusammengeführt und ist derzeit für die Version 3.0 vorgesehen. Hoffentlich wird es in nicht allzu ferner Zukunft auf die anderen .NET-Plattformen übertragen.

Der Typ hat die folgende Signatur, die die meisten Anforderungen der ISO-Woche abdecken sollte :

namespace System.Globalization
{
    public static class ISOWeek
    {
        public static int GetWeekOfYear(DateTime date);
        public static int GetWeeksInYear(int year);
        public static int GetYear(DateTime date);
        public static DateTime GetYearEnd(int year);
        public static DateTime GetYearStart(int year);
        public static DateTime ToDateTime(int year, int week, DayOfWeek dayOfWeek);
    }
}

Den Quellcode finden Sie hier .

UPDATE : Diese APIs wurden auch in die 2.1-Version von .NET Standard aufgenommen .

Da es anscheinend keine .Net-Kultur gibt, die die korrekte ISO-8601-Wochenzahl liefert, würde ich die integrierte Wochenbestimmung lieber ganz umgehen und die Berechnung manuell durchführen, anstatt zu versuchen, eine teilweise korrekte zu korrigieren Ergebnis.

Am Ende hatte ich folgende Erweiterungsmethode:

/// <summary>
/// Converts a date to a week number.
/// ISO 8601 week 1 is the week that contains the first Thursday that year.
/// </summary>
public static int ToIso8601Weeknumber(this DateTime date)
{
    var thursday = date.AddDays(3 - date.DayOfWeek.DayOffset());
    return (thursday.DayOfYear - 1) / 7 + 1;
}

/// <summary>
/// Converts a week number to a date.
/// Note: Week 1 of a year may start in the previous year.
/// ISO 8601 week 1 is the week that contains the first Thursday that year, so
/// if December 28 is a Monday, December 31 is a Thursday,
/// and week 1 starts January 4.
/// If December 28 is a later day in the week, week 1 starts earlier.
/// If December 28 is a Sunday, it is in the same week as Thursday January 1.
/// </summary>
public static DateTime FromIso8601Weeknumber(int weekNumber, int? year = null, DayOfWeek day = DayOfWeek.Monday)
{
    var dec28 = new DateTime((year ?? DateTime.Today.Year) - 1, 12, 28);
    var monday = dec28.AddDays(7 * weekNumber - dec28.DayOfWeek.DayOffset());
    return monday.AddDays(day.DayOffset());
}

/// <summary>
/// Iso8601 weeks start on Monday. This returns 0 for Monday.
/// </summary>
private static int DayOffset(this DayOfWeek weekDay)
{
    return ((int)weekDay + 6) % 7;
}

Zunächst einmal ((int)date.DayOfWeek + 6) % 7)bestimmt den Wochentag Zahl, 0 = Montag, 6 = Sonntag.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) bestimmt das Datum des Montags vor der angeforderten Wochennummer.

Drei Tage später ist der Ziel-Donnerstag, der bestimmt, in welchem ​​Jahr die Woche ist.

Wenn Sie die (auf Null basierende) Tageszahl innerhalb des Jahres durch sieben (Abrundung) teilen, erhalten Sie die (auf Null basierende) Wochennummer im Jahr.

In c # werden die Ergebnisse der Ganzzahlberechnung implizit abgerundet.

In .NET 3.0 und höher können Sie die ISOWeek.GetWeekOfDate-Methode verwenden .

Beachten Sie, dass das Jahr im Format Jahr + Woche DateTimeaufgrund von Wochen, die die Jahresgrenze überschreiten, vom Jahr des Jahres abweichen kann .

C # zum Powershell-Port vom obigen Code von il_guru :

function GetWeekOfYear([datetime] $inputDate)
{
   $day = [System.Globalization.CultureInfo]::InvariantCulture.Calendar.GetDayOfWeek($inputDate)
   if (($day -ge [System.DayOfWeek]::Monday) -and ($day -le [System.DayOfWeek]::Wednesday))
   {
      $inputDate = $inputDate.AddDays(3)
   }

   # Return the week of our adjusted day
   $weekofYear = [System.Globalization.CultureInfo]::InvariantCulture.Calendar.GetWeekOfYear($inputDate, [System.Globalization.CalendarWeekRule]::FirstFourDayWeek, [System.DayOfWeek]::Monday)
   return $weekofYear
}

Der einfachste Weg, um den ISO 8601-Stil der Wochennummer mithilfe von c # und der DateTime-Klasse zu bestimmen.

Fragen Sie dies: Der Donnerstag des Jahres ist der Donnerstag dieser Woche. Die Antwort entspricht der gewünschten Wochennummer.

var dayOfWeek = (int)moment.DayOfWeek;
// Make monday the first day of the week
if (--dayOfWeek < 0)
    dayOfWeek = 6;
// The whole nr of weeks before this thursday plus one is the week number
var weekNumber = (moment.AddDays(3 - dayOfWeek).DayOfYear - 1) / 7 + 1;

var cultureInfo = CultureInfo.CurrentCulture;
var calendar = cultureInfo.Calendar;

var calendarWeekRule = cultureInfo.DateTimeFormat.CalendarWeekRule;
var firstDayOfWeek = cultureInfo.DateTimeFormat.FirstDayOfWeek;
var lastDayOfWeek = cultureInfo.LCID == 1033 //En-us
                    ? DayOfWeek.Saturday
                    : DayOfWeek.Sunday;

var lastDayOfYear = new DateTime(date.Year, 12, 31);

var weekNumber = calendar.GetWeekOfYear(date, calendarWeekRule, firstDayOfWeek);

 //Check if this is the last week in the year and it doesn`t occupy the whole week
return weekNumber == 53 && lastDayOfYear.DayOfWeek != lastDayOfWeek 
       ? 1  
       : weekNumber;

Es funktioniert sowohl für die US-amerikanische als auch für die russische Kultur. ISO 8601 wird auch korrekt sein, da die russische Woche am Montag beginnt.

Hier ist eine Erweiterungsversion und eine nullfähige Version der Antwort von il_guru .

Erweiterung:

public static int GetIso8601WeekOfYear(this DateTime time)
{
    var day = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(time);
    if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday)
    {
        time = time.AddDays(3);
    }

    return CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(time, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
}

Nullable:

public static int? GetIso8601WeekOfYear(this DateTime? time)
{
    return time?.GetIso8601WeekOfYear();
}

Verwendung:

new DateTime(2019, 03, 15).GetIso8601WeekOfYear(); //returns 11
((DateTime?) new DateTime(2019, 03, 15)).GetIso8601WeekOfYear(); //returns 11
((DateTime?) null).GetIso8601WeekOfYear(); //returns null

Die Frage ist: Wie definieren Sie, ob eine Woche 2012 oder 2013 ist? Ihre Vermutung ist, dass diese Woche als die erste Woche des Jahres 2013 markiert werden sollte, da 6 Tage der Woche im Jahr 2013 sind.

Ich bin mir nicht sicher, ob dies der richtige Weg ist. Diese Woche begann am Jahr 2012 (am Montag, den 31. Dezember), daher sollte sie als letzte Woche des Jahres 2012 markiert sein, daher sollte es die 53. Woche des Jahres 2012 sein. Die erste Woche des Jahres 2013 sollte am Montag, den 7. Dezember beginnen.

Jetzt können Sie den speziellen Fall von Randwochen (erste und letzte Woche des Jahres) anhand der Informationen zum Wochentag behandeln. Es hängt alles von Ihrer Logik ab.

  DateTimeFormatInfo dfi = DateTimeFormatInfo.CurrentInfo;
  DateTime date1 = new DateTime(2011, 1, 1);
  Calendar cal = dfi.Calendar;

  Console.WriteLine("{0:d}: Week {1} ({2})", date1, 
                    cal.GetWeekOfYear(date1, dfi.CalendarWeekRule, 
                                      dfi.FirstDayOfWeek),
                    cal.ToString().Substring(cal.ToString().LastIndexOf(".") + 1));      

Basierend auf der Antwort von il_guru habe ich diese Version für meine eigenen Bedürfnisse erstellt, die auch die Jahreskomponente zurückgibt.

    /// <summary>
    /// This presumes that weeks start with Monday.
    /// Week 1 is the 1st week of the year with a Thursday in it.
    /// </summary>
    /// <param name="time">The date to calculate the weeknumber for.</param>
    /// <returns>The year and weeknumber</returns>
    /// <remarks>
    /// Based on Stack Overflow Answer: https://stackoverflow.com/a/11155102
    /// </remarks>
    public static (short year, byte week) GetIso8601WeekOfYear(DateTime time)
    {
        // Seriously cheat.  If its Monday, Tuesday or Wednesday, then it'll
        // be the same week# as whatever Thursday, Friday or Saturday are,
        // and we always get those right
        DayOfWeek day = CultureInfo.InvariantCulture.Calendar.GetDayOfWeek(time);
        if (day >= DayOfWeek.Monday && day <= DayOfWeek.Wednesday)
        {
            time = time.AddDays(3);
        }
        // Return the week of our adjusted day
        var week = (byte)CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(time, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
        return ((short)(week >= 52 & time.Month == 1 ? time.Year - 1 : time.Year), week);
    }

Diese beiden Methoden werden helfen, vorausgesetzt, unsere Woche beginnt am Montag

/// <summary>
    /// Returns the weekId
    /// </summary>
    /// <param name="DateTimeReference"></param>
    /// <returns>Returns the current week id</returns>
    public static DateTime GetDateFromWeek(int WeekReference)
    {
        //365 leap
        int DaysOffset = 0;
        if (WeekReference > 1)
        {
            DaysOffset = 7;
            WeekReference = WeekReference - 1;
        }
        DateTime DT = new DateTime(DateTime.Now.Year, 1, 1);
        int CurrentYear = DT.Year;
        DateTime SelectedDateTime = DateTime.MinValue;

        while (CurrentYear == DT.Year)
        {
            int TheWeek = WeekReportData.GetWeekId(DT);
            if (TheWeek == WeekReference)
            {
                SelectedDateTime = DT;
                break;
            }
            DT = DT.AddDays(1.0D);
        }

        if (SelectedDateTime == DateTime.MinValue)
        {
            throw new Exception("Please check week");
        }

        return SelectedDateTime.AddDays(DaysOffset);
    }
/// <summary>
    /// Returns the weekId
    /// </summary>
    /// <param name="DateTimeReference"></param>
    /// <returns>Returns the current week id</returns>
    public static int GetWeekId(DateTime DateTimeReference)
    {
        CultureInfo ciCurr = CultureInfo.InvariantCulture;
        int weekNum = ciCurr.Calendar.GetWeekOfYear(DateTimeReference,
        CalendarWeekRule.FirstFullWeek, DayOfWeek.Monday);
        return weekNum;
    }

Ein Jahr hat 52 Wochen und 1 Tag oder 2 im Falle eines Rundenjahres (52 x 7 = 364). 2012-12-31 wäre Woche 53, eine Woche, die nur 2 Tage haben würde, weil 2012 ein Rundenjahr ist.

public int GetWeekNumber()
{
   CultureInfo ciCurr = CultureInfo.CurrentCulture;
   int weekNum = ciCurr.Calendar.GetWeekOfYear(DateTime.Now, 
   CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
   return weekNum;
}