Uzyskaj prawidłowy numer tygodnia dla określonej daty

Dużo googlowałem i znalazłem wiele rozwiązań, ale żadne z nich nie podaje prawidłowego numeru tygodnia na 31.12.2012. Nawet przykład w MSDN ( link ) zawodzi.

31.12.2012 jest poniedziałek, dlatego powinien to być Tydzień 1, ale każda metoda, którą wypróbowałem, daje mi 53. Oto niektóre metody, które wypróbowałem:

Z biblioteki MDSN:

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

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

Rozwiązanie 2:

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

Rozwiązanie 3:

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

Aktualizacja

Następująca metoda zwraca 1, gdy data jest 31.12.2012. Innymi słowy, moim problemem było to, że moje metody nie były zgodne ze standardem ISO-8601.

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

Jak zauważono na tej stronie MSDN, istnieje niewielka różnica między tygodniem ISO8601 a numeracją tygodnia .Net.

Więcej informacji można znaleźć w tym artykule na blogu MSDN: „ Format tygodnia w roku ISO 8601 w Microsoft .Net ”

Mówiąc najprościej, .Net pozwala na podział tygodni na lata, podczas gdy norma ISO nie. W artykule jest również prosta funkcja uzyskania prawidłowego numeru tygodnia ISO 8601 dla ostatniego tygodnia roku.

Aktualizacja Następująca metoda faktycznie zwraca 1, 2012-12-31co jest poprawne w ISO 8601 (np. Niemcy).

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

W ciągu roku może być więcej niż 52 tygodnie. Każdy rok ma dodatkowe 52 pełne tygodnie + 1 lub +2 (rok przestępny). Nadrabiają 53. tydzień.

• 52 tygodnie * 7 dni = 364 dni.

Tak więc na każdy rok masz co najmniej jeden dodatkowy dzień. Dwa za lata przestępne. Czy te dodatkowe dni są liczone jako osobne tygodnie?

Ile jest naprawdę tygodni, zależy od pierwszego dnia tygodnia. Rozważmy to w 2012 roku.

• USA (niedziela -> sobota): 52 tygodnie + jeden krótki 2-dniowy tydzień w dniach 2012-12-30 i 2012-12-31. To daje w sumie 53 tygodnie. Ostatnie dwa dni tego roku (niedziela + poniedziałek) tworzą własny krótki tydzień.

Sprawdź bieżące ustawienia kultury, aby zobaczyć, czego używa jako pierwszego dnia tygodnia.

Jak widzisz, normalne jest uzyskanie 53.

• Europa (poniedziałek -> niedziela): 2 stycznia (2012-1-2) to pierwszy poniedziałek, więc jest to pierwszy dzień pierwszego tygodnia. Zapytaj numer tygodnia na 1 stycznia, a otrzymasz 52, ponieważ jest on uważany za część ostatniego tygodnia 2011 roku.

Możliwe jest nawet 54. tydzień. Zdarza się co 28 lat, gdy 1 stycznia i 31 grudnia są traktowane jako osobne tygodnie. To musi być także rok przestępny.

Na przykład rok 2000 miał 54 tygodnie. 1 stycznia (sobota) był pierwszym dniem jednego tygodnia, a 31 grudnia (niedziela) był drugim dniem tygodnia.

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

Wydruki: Rok: 2012 Tydzień: 54

Zmień CalendarWeekRule w powyższym przykładzie na FirstFullWeek lub FirstFourDayWeek, a wrócisz 53. Trzymaj dzień rozpoczęcia w poniedziałek, ponieważ mamy do czynienia z Niemcami.

Tydzień 53 rozpoczyna się w poniedziałek 31.12.2012, trwa jeden dzień, a następnie kończy się.

53 to poprawna odpowiedź. Zmień Kulturę na Niemcy, jeśli chcesz spróbować.

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

To jest sposób:

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

Najważniejszy jest CalendarWeekRuleparametr.

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

Dobre wieści! Prośba przyciąganie dodanie System.Globalization.ISOWeekdo .NET Rdzenia właśnie połączyły się i jest obecnie planowana na wydaniu 3.0. Mamy nadzieję, że w niedalekiej przyszłości rozprzestrzeni się na inne platformy .NET.

Ten typ ma następującą sygnaturę, która powinna pokryć większość potrzeb tygodnia ISO :

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

Możesz znaleźć kod źródłowy tutaj .

AKTUALIZACJA : Te interfejsy API zostały również uwzględnione w wersji 2.1 .NET Standard .

Ponieważ wydaje się, że nie istnieje .Net-kultura, która daje prawidłowy numer tygodnia ISO-8601, wolałbym całkowicie pominąć wbudowane określenie tygodnia i wykonać obliczenia ręcznie, zamiast próbować poprawić częściowo poprawną wynik.

Skończyło się na następującej metodzie rozszerzenia:

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

Przede wszystkim ((int)date.DayOfWeek + 6) % 7)określa numer dnia tygodnia, 0 = poniedziałek, 6 = niedziela.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) określa datę poniedziałku poprzedzającą żądany numer tygodnia.

Trzy dni później jest czwartek docelowy, który określa, w którym roku jest ten tydzień.

Jeśli podzielisz (w oparciu o zero) liczbę dni w ciągu roku przez siedem (zaokrąglenie w dół), otrzymasz (w oparciu o zero) liczbę tygodni w roku.

W c # wyniki obliczeń liczb całkowitych są domyślnie zaokrąglane w dół.

W .NET 3.0 i nowszych można użyć opcji ISOWeek.GetWeekOfDate-Method .

Pamiętaj, że rok w formacie rok + tydzień może różnić się od roku z DateTimepowodu tygodni przekraczających granicę roku.

C # do portu Powershell z powyższego kodu z 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
}

Najłatwiejszym sposobem ustalenia stylu tygodnia numer ISO 8601 przy użyciu c # i klasy DateTime.

Zapytaj o to: ile czwartków tego roku jest czwartek tego tygodnia. Odpowiedź jest równa pożądanej liczbie tygodni.

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;

Działa dobrze zarówno dla kultury amerykańskiej i rosyjskiej. ISO 8601 również będzie poprawna, ponieważ rosyjski tydzień zaczyna się w poniedziałek.

Oto wersja rozszerzenia i zerowa wersja odpowiedzi il_guru .

Rozbudowa:

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

Zastosowania:

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

Pytanie brzmi: w jaki sposób określasz, czy tydzień przypada na rok 2012 czy 2013? Przypuszczam, że przypuszczasz, że skoro 6 dni tygodnia przypada na 2013 r., Ten tydzień powinien być oznaczony jako pierwszy tydzień 2013 r.

Nie jestem pewien, czy jest to właściwa droga. Tydzień ten rozpoczął się w 2012 r. (W poniedziałek 31 grudnia), więc powinien być oznaczony jako ostatni tydzień 2012 r., A zatem powinien być 53. 2012 r. Pierwszy tydzień 2013 r. Powinien rozpocząć się w poniedziałek, 7 grudnia.

Teraz możesz obsłużyć konkretny przypadek tygodni skrajnych (pierwszy i ostatni tydzień roku), korzystając z informacji o dniu tygodnia. Wszystko zależy od twojej logiki.

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

Na podstawie odpowiedzi il_guru stworzyłem tę wersję na własne potrzeby, która zwraca również komponent roku.

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

Te dwie metody pomogą, zakładając, że nasz tydzień zaczyna się w poniedziałek

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

Rok ma 52 tygodnie i 1 dzień lub 2 w przypadku roku okrążenia (52 x 7 = 364). 31.12.2012 byłby 53 tydzień, tydzień, który miałby tylko 2 dni, ponieważ 2012 jest rokiem okrążenia.

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