Obtenga el número de semana correcto de una fecha determinada

Busqué en Google mucho y encontré muchas soluciones, pero ninguna de ellas me dio el número de semana correcto para el 2012-12-31. Incluso el ejemplo en MSDN ( enlace ) falla.

2012-12-31 es lunes, por lo tanto, debería ser la semana 1, pero cada método que probé me da 53. Estos son algunos de los métodos que he probado:

De la Biblioteca MDSN:

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

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

Solución 2:

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

Solución 3:

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

Actualizar

El siguiente método en realidad devuelve 1 cuando la fecha es 2012-12-31. En otras palabras, mi problema era que mis métodos no seguían el estándar 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);
}

Como se señaló en esta página de MSDN, hay una ligera diferencia entre la numeración de la semana ISO8601 y .Net.

Puede consultar este artículo en el blog de MSDN para obtener una mejor explicación: " Formato ISO 8601 Semana del año en Microsoft .Net "

En pocas palabras, .Net permite que las semanas se dividan en años, mientras que el estándar ISO no. En el artículo también hay una función simple para obtener el número de semana ISO 8601 correcto para la última semana del año.

Actualización El siguiente método en realidad devuelve 1 para el 2012-12-31cual es correcto en ISO 8601 (por ejemplo, Alemania).

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

Puede haber más de 52 semanas en un año. Cada año tiene 52 semanas completas + 1 o +2 (año bisiesto) días adicionales. Componen una semana 53.

• 52 semanas * 7 días = 364 días.

Entonces, por cada año, tiene al menos uno por día adicional. Dos por años bisiestos. ¿Se cuentan estos días adicionales como semanas separadas?

Cuántas semanas hay realmente depende del día de inicio de su semana. Consideremos esto para el 2012.

• EE. UU. (Domingo -> sábado): 52 semanas + una semana corta de 2 días para el 30/12/2012 y el 31/12/2012. Esto da como resultado un total de 53 semanas. Los últimos dos días de este año (domingo + lunes) conforman su propia semana corta.

Verifique la configuración actual de su Cultura para ver qué usa como primer día de la semana.

Como puede ver, es normal obtener 53 como resultado.

• Europa (lunes -> domingo): el 2 de enero (2012-1-2) es el primer lunes, así que este es el primer día de la primera semana. Pregunte el número de la semana para el 1 de enero y obtendrá 52, ya que se considera parte de 2011 la semana pasada.

Incluso es posible tener una semana 54. Ocurre cada 28 años cuando el 1 de enero y el 31 de diciembre se tratan como semanas separadas. Debe ser un año bisiesto también.

Por ejemplo, el año 2000 tuvo 54 semanas. El 1 de enero (sábado) fue el primer día de una semana, y el 31 de diciembre (sol) fue el segundo día de una semana.

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

Imprime: Año: 2012 Semana: 54

Cambie CalendarWeekRule en el ejemplo anterior a FirstFullWeek o FirstFourDayWeek y obtendrá 53. Guardemos el día de inicio el lunes ya que estamos tratando con Alemania.

Entonces, la semana 53 comienza el lunes 31/12/2012, dura un día y luego se detiene.

53 es la respuesta correcta. Cambia la Cultura a Alemania si quieres probarlo.

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

Esta es la forma:

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

Lo más importante para es el CalendarWeekRuleparámetro.

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

¡Buenas noticias! Se acaba de fusionar una solicitud de extracción que se agrega System.Globalization.ISOWeeka .NET Core y actualmente está programada para la versión 3.0. Con suerte, se propagará a las otras plataformas .NET en un futuro no muy lejano.

El tipo tiene la siguiente firma, que debería cubrir la mayoría de las necesidades de la semana 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);
    }
}

Puedes encontrar el código fuente aquí .

ACTUALIZACIÓN : Estas API también se han incluido en la versión 2.1 de .NET Standard .

Como no parece haber una cultura .Net que produzca el número de semana ISO-8601 correcto, prefiero omitir por completo la determinación de semana incorporada y hacer el cálculo manualmente, en lugar de intentar corregir una corrección parcialmente correcta resultado.

Lo que terminé con es el siguiente método de extensión:

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

En primer lugar, ((int)date.DayOfWeek + 6) % 7)determina el número del día de la semana, 0 = lunes, 6 = domingo.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) determina la fecha del lunes anterior al número de semana solicitado.

Tres días después es el jueves objetivo, que determina en qué año está la semana.

Si divide el número de día (basado en cero) dentro del año por siete (redondeando hacia abajo), obtendrá el número de semana (basado en cero) en el año.

En c #, los resultados de cálculo de enteros se redondean hacia abajo implícitamente.

En .NET 3.0 y versiones posteriores, puede usar el ISOWeek.GetWeekOfDatemétodo .

Tenga en cuenta que el año en el formato de número de año + semana puede diferir del año DateTimedebido a las semanas que cruzan el límite del año.

C # al puerto Powershell desde el código anterior de 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
}

La forma más fácil de determinar el estilo de número de semana ISO 8601 usando c # y la clase DateTime.

Pregunte esto: el jueves cuántos años es el jueves de esta semana. La respuesta es igual al número de semana deseado.

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;

Funciona bien tanto para las culturas estadounidense como rusa. ISO 8601 también será correcta, porque la semana rusa comienza el lunes.

Aquí hay una versión de extensión y una versión anulable de la respuesta de il_guru .

Extensión:

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

Anulable:

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

Usos:

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

La pregunta es: ¿Cómo define si una semana es en 2012 o en 2013? Supongo que su suposición es que, dado que 6 días de la semana son en 2013, esta semana debe marcarse como la primera semana de 2013.

No estoy seguro si este es el camino correcto. Esa semana comenzó en 2012 (el lunes 31 de diciembre), por lo que debe marcarse como la última semana de 2012, por lo tanto, debe ser el 53 de 2012. La primera semana de 2013 debe comenzar el lunes 7.

Ahora, puede manejar el caso particular de semanas límite (primera y última semana del año) utilizando la información del día de la semana. Todo depende de tu lógica.

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

Basado en la respuesta de il_guru, creé esta versión para mis propias necesidades que también devuelve el componente del año.

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

Estos dos métodos ayudarán, suponiendo que nuestra semana comience el lunes

/// <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 año tiene 52 semanas y 1 día o 2 en caso de un año de vuelta (52 x 7 = 364). 2012-12-31 sería la semana 53, una semana que solo tendría 2 días porque 2012 es un año de vuelta.

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