Belirli bir tarihte doğru hafta sayısını alın

Çok fazla Google buldum ve birçok çözüm buldum, ancak hiçbiri bana 2012-12-31 için doğru hafta numarasını vermedi. MSDN'deki ( link ) örnek bile başarısız oluyor.

2012-12-31 Pazartesi, bu nedenle 1. Hafta olmalı, ancak denediğim her yöntem bana 53 veriyor. İşte denediğim yöntemlerden bazıları:

MDSN Kütüphanesinden:

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

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

Çözüm 2:

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

Çözüm 3:

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

Güncelleme

Tarih 2012-12-31 olduğunda aşağıdaki yöntem aslında 1 değerini döndürür. Başka bir deyişle, benim sorunum yöntemlerimin ISO-8601 standardına uymamasıydı.

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

Bu MSDN sayfasında belirtildiği gibi, ISO8601 haftası ile .Net haftası numaralandırması arasında küçük bir fark vardır.

Daha iyi bir açıklama için MSDN Blogundaki bu makaleye başvurabilirsiniz: " Microsoft .Net'te ISO 8601 Yılın Haftası biçimi "

Basitçe söylemek gerekirse, .Net, ISO standardı desteklemezken haftaların yıllara bölünmesine izin verir. Makalede ayrıca yılın son haftası için doğru ISO 8601 hafta numarasını almak için basit bir işlev var.

Güncelleme Aşağıdaki yöntem aslında 2012-12-31ISO 8601 (örn. Almanya) için doğru olan 1 değerini döndürür .

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

Yılda 52 haftadan fazla olabilir. Her yıl 52 tam hafta + 1 veya +2 ​​(artık yıl) ekstra gün vardır. 53. haftayı telafi ediyorlar.

• 52 hafta * 7 gün = 364 gün.

Yani her yıl fazladan bir gününüz var. Artık iki yıl. Bu ekstra günler ayrı haftalar olarak mı sayılıyor?

Kaç hafta olduğu gerçekten haftanızın başlangıç ​​gününe bağlıdır. Bunu 2012 için düşünelim.

• ABD (Pazar -> Cumartesi): 52 hafta + 2012-12-30 ve 2012-12-31 için bir kısa 2 günlük hafta. Bu toplam 53 hafta ile sonuçlanır. Bu yılın son iki günü (Pazar + Pazartesi) kendi kısa haftasını oluşturur.

Haftanın ilk günü olarak ne kullandığını görmek için mevcut Kültür ayarlarınızı kontrol edin.

Gördüğünüz gibi sonuç olarak 53 elde etmek normaldir.

• Avrupa (Pazartesi -> Pazar): 2dn (2012-1-2) ilk pazartesi, bu yüzden bu ilk haftanın ilk günü. 1 Ocak için hafta numarasını isteyin ve geçen hafta 2011'in bir parçası olarak kabul edildiğinden 52 geri döneceksiniz.

54. hafta bile olabilir. 1 Ocak ve 31 Aralık tarihleri ​​ayrı hafta olarak değerlendirildiğinde 28 yılda bir olur. Artık bir sıçrama yılı olmalı.

Örneğin, 2000 yılında 54 hafta vardı. 1 Ocak (sat) ilk bir hafta gün, 31 Aralık (güneş) ikinci bir hafta gün oldu.

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

Çıktıları: Yıl: 2012 Hafta: 54

Yukarıdaki örnekteki CalendarWeekRule öğesini FirstFullWeek veya FirstFourDayWeek olarak değiştirin ve 53'ü geri alacaksınız. Almanya ile iş yaptığımızdan beri başlangıç ​​gününü Pazartesi günü tutalım.

Böylece 53. hafta 2012-12-31 Pazartesi günü başlar, bir gün sürer ve sonra durur.

53 doğru cevaptır. Denemek istiyorsanız Kültürü almanya olarak değiştirin.

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

Bu şekilde:

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

En önemlisi CalendarWeekRuleparametredir.

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

İyi haberler! .NET Core'a eklenen bir çekme isteğiSystem.Globalization.ISOWeek yeni birleştirildi ve şu anda 3.0 sürümü için destekleniyor. Umarım çok uzak olmayan bir gelecekte diğer .NET platformlarına da yayılır.

Tür, çoğu ISO haftası ihtiyacını karşılaması gereken aşağıdaki imzayı içerir :

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

Kaynak kodu burada bulabilirsiniz .

GÜNCELLEME : Bu API'ler ayrıca .NET Standard'ın 2.1 sürümüne dahil edilmiştir .

Doğru ISO-8601 hafta sayısını veren bir .Net-kültürü olmadığı için, yerleşik hafta tespitini tamamen atlamak ve kısmen doğru düzeltmeye çalışmak yerine hesaplamayı manuel olarak yapmak istiyorum. sonuç.

Ne ile sona erdi aşağıdaki uzantı yöntemidir:

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

Her şeyden önce, ((int)date.DayOfWeek + 6) % 7)hafta içi sayısını belirler, 0 = pazartesi, 6 = pazar.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) istenen hafta numarasından önce pazartesi tarihini belirler.

Üç gün sonra, haftanın hangi yılda olduğunu belirleyen hedef perşembe olur.

Yıl içindeki (sıfır temelli) gün sayısını yedi (aşağı yuvarlama) bölerseniz, yıl içindeki (sıfır temelli) hafta sayısını alırsınız.

C # 'da, tamsayı hesaplama sonuçları dolaylı olarak aşağı yuvarlanır.

.NET 3.0 ve sonraki sürümlerde ISOWeek.GetWeekOfDate-Method kullanabilirsiniz .

Yıl + hafta sayı biçimindeki yıl DateTime, yıl sınırını geçen haftalar nedeniyle yıldan farklı olabilir .

Il_guru yukarıdaki koddan Powershell bağlantı noktasına C # :

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
}

ISO # 8601 stilini c # ve DateTime sınıfını kullanarak belirlemenin en kolay yolu.

Şunu sorun: Yılın nasıl yapılır? Perşembe günü bu haftanın perşembe günüdür. Cevap istenen hafta sayısına eşittir.

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;

Hem ABD hem de Rus kültürleri için iyi çalışıyor. ISO 8601 de doğru olacak, çünkü Rus haftası Pazartesi günü başlıyor.

İşte il_guru'nun cevabının bir uzantı sürümü ve null edilebilir sürümü .

Uzantı:

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

null:

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

Usages:

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

Soru şudur: Bir haftanın 2012'de mi yoksa 2013'te mi olduğunu nasıl tanımlarsınız? Tahmininiz, sanırım haftanın 6 günü 2013'te olduğundan, bu haftanın 2013'ün ilk haftası olarak işaretlenmesi gerekiyor.

Bunun doğru yol olup olmadığından emin değilim. O hafta 2012'de başladı (31 Aralık Pazartesi), bu nedenle 2012'nin son haftası olarak işaretlenmelidir, bu nedenle 2012'nin 53'ü olmalıdır. 2013'ün ilk haftası 7 Pazartesi günü başlamalıdır.

Şimdi, hafta sonu bilgilerini kullanarak belirli haftaları (yılın ilk ve son haftası) ele alabilirsiniz. Her şey mantığınıza bağlıdır.

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

İl_guru'nun cevabına dayanarak, bu bileşeni yıl bileşenini de döndüren kendi ihtiyaçlarım için oluşturdum.

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

Bu iki yöntem, haftanın Pazartesi günü başladığını varsayarsak,

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

Bir yıl, bir tur yılı olması durumunda 52 hafta ve 1 gün veya 2'dir (52 x 7 = 364). 2012-12-31, 2012 tur yılı olduğundan sadece 2 gün sürecek bir hafta olan 53. hafta olacaktır.

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