Ottieni il numero di settimana corretto di una determinata data

Ho cercato su Google molto e ho trovato molte soluzioni, ma nessuna mi ha dato il numero di settimana corretto per il 2012-12-31. Anche l'esempio su MSDN ( collegamento ) non riesce.

31-12-2012 è lunedì, quindi dovrebbe essere la settimana 1, ma ogni metodo che ho provato mi dà 53. Ecco alcuni dei metodi che ho provato:

Dalla libreria MDSN:

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

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

Soluzione 2:

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

Soluzione 3:

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

Aggiornare

Il seguente metodo restituisce effettivamente 1 quando la data è 2012-12-31. In altre parole, il mio problema era che i miei metodi non seguivano lo standard 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);
}

Come indicato in questa pagina MSDN, esiste una leggera differenza tra la numerazione ISO8601 della settimana e quella della settimana .Net.

È possibile fare riferimento a questo articolo nel blog MSDN per una spiegazione migliore: " Formato ISO 8601 Settimana dell'anno in Microsoft .Net "

In poche parole, .Net consente alle settimane di essere suddivise tra anni, mentre lo standard ISO no. Nell'articolo c'è anche una semplice funzione per ottenere il numero di settimana ISO 8601 corretto per l'ultima settimana dell'anno.

Aggiornamento Il seguente metodo restituisce effettivamente 1 per il 2012-12-31quale è corretto in ISO 8601 (ad es. Germania).

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

Possono esserci più di 52 settimane in un anno. Ogni anno ha 52 settimane intere + 1 o +2 (anno bisestile) in più. Compongono una 53a settimana.

• 52 settimane * 7 giorni = 364 giorni.

Quindi per ogni anno hai almeno un giorno in più. Due per gli anni bisestili. Questi giorni extra vengono conteggiati come settimane separate?

Quante settimane ci sono davvero dipende dal giorno di inizio della settimana. Consideriamo questo per il 2012.

• Stati Uniti (domenica -> sabato): 52 settimane + una breve settimana di 2 giorni per il 2012-12-30 e il 2012-12-31. Ciò si traduce in un totale di 53 settimane. Gli ultimi due giorni di quest'anno (domenica + lunedì) formano la loro breve settimana.

Controlla le impostazioni della tua Cultura corrente per vedere cosa utilizza come primo giorno della settimana.

Come vedi è normale ottenere 53 di conseguenza.

• Europa (lunedì -> domenica): 2 gennaio (2012-1-2) è il primo lunedì, quindi questo è il primo giorno della prima settimana. Chiedi il numero della settimana per il 1 ° gennaio e ne riceverai 52 poiché è considerato parte della settimana scorsa del 2011.

È anche possibile avere una 54a settimana. Accade ogni 28 anni quando il 1 ° gennaio e il 31 dicembre vengono trattati come settimane separate. Deve essere anche un anno bisestile.

Ad esempio, l'anno 2000 ha avuto 54 settimane. Il 1 ° gennaio (sabato) è stato il primo giorno di una settimana e il 31 dicembre (domenica) è stato il secondo giorno di una settimana.

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

Stampe: Anno: 2012 Settimana: 54

Cambia CalendarWeekRule nell'esempio sopra in FirstFullWeek o FirstFourDayWeek e tornerai 53. Manteniamo il giorno di inizio lunedì poiché abbiamo a che fare con la Germania.

Quindi la settimana 53 inizia lunedì 2012-12-31, dura un giorno e poi si ferma.

53 è la risposta corretta. Cambia la cultura in Germania se vuoi provarla.

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

Questo è il modo:

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

Il più importante per è il CalendarWeekRuleparametro.

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

Buone notizie! Una richiesta di pull aggiungendoSystem.Globalization.ISOWeek a .NET Core è stata appena unita ed è attualmente prevista per la versione 3.0. Spero che si propaghi alle altre piattaforme .NET in un futuro non troppo lontano.

Il tipo ha la seguente firma, che dovrebbe coprire la maggior parte delle esigenze della settimana 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);
    }
}

Puoi trovare il codice sorgente qui .

AGGIORNAMENTO : Queste API sono state incluse anche nella versione 2.1 di .NET Standard .

Poiché non sembra esserci una cultura .Net che produce il numero di settimana ISO-8601 corretto, preferirei bypassare del tutto la determinazione della settimana integrata e fare il calcolo manualmente, invece di tentare di correggere un parzialmente corretto risultato.

Quello che ho finito è il seguente metodo di estensione:

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

Prima di tutto, ((int)date.DayOfWeek + 6) % 7)determina il numero del giorno della settimana, 0 = lunedì, 6 = domenica.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) determina la data del lunedì che precede il numero della settimana richiesta.

Tre giorni dopo è l'obiettivo giovedì, che determina in che anno è la settimana.

Se si divide il numero del giorno (in base zero) nell'anno per sette (arrotondato per difetto), si ottiene il numero della settimana (in base zero) nell'anno.

In c #, i risultati del calcolo dei numeri interi sono arrotondati implicitamente.

In .NET 3.0 e ISOWeek.GetWeekOfDateversioni successive è possibile utilizzare il -Method .

Si noti che l'anno nel formato numero anno + settimana potrebbe differire dall'anno dell'anno a DateTimecausa delle settimane che attraversano il confine dell'anno.

C # alla porta Powershell dal codice sopra da 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
}

Il modo più semplice per determinare lo stile ISO 8601 del numero di settimana utilizzando c # e la classe DateTime.

Chiedi questo: il giovedì di quanti anni è il giovedì di questa settimana. La risposta è uguale al numero della settimana desiderata.

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;

Funziona bene sia per le culture statunitensi che russe. Anche ISO 8601 sarà corretto, poiché la settimana russa inizia il lunedì.

Ecco una versione di estensione e una versione nullable della risposta di il_guru .

Estensione:

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

usi:

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

La domanda è: come si definisce se una settimana è nel 2012 o nel 2013? La tua supposizione, suppongo, è che dal momento che 6 giorni della settimana sono nel 2013, questa settimana dovrebbe essere contrassegnata come la prima settimana del 2013.

Non sono sicuro che questa sia la strada giusta da percorrere. Quella settimana è iniziata il 2012 (lunedì 31 dicembre), quindi dovrebbe essere contrassegnata come l'ultima settimana del 2012, quindi dovrebbe essere il 53 ° del 2012. La prima settimana del 2013 dovrebbe iniziare lunedì 7.

Ora puoi gestire il caso particolare delle settimane marginali (prima e ultima settimana dell'anno) usando le informazioni del giorno della settimana. Tutto dipende dalla tua logica.

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

Sulla base della risposta di il_guru, ho creato questa versione per le mie esigenze che restituisce anche la componente dell'anno.

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

Questi due metodi aiuteranno, supponendo che la nostra settimana inizi lunedì

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

Un anno ha 52 settimane e 1 giorno o 2 in caso di un anno di giro (52 x 7 = 364). 2012-12-31 sarebbe la settimana 53, una settimana che avrebbe solo 2 giorni perché il 2012 è un anno di giro.

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