Dapatkan nomor minggu yang benar dari tanggal yang ditentukan

Saya telah banyak Googled dan menemukan banyak solusi, tetapi tidak satupun dari mereka memberi saya angka minggu yang benar untuk 2012-12-31. Bahkan contoh di MSDN ( tautan ) gagal.

2012-12-31 adalah hari Senin, oleh karena itu seharusnya Minggu 1, tetapi setiap metode yang saya coba beri saya 53. Berikut adalah beberapa metode yang saya coba:

Dari Perpustakaan MDSN:

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

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

Solusi 2:

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

Solusi 3:

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

Memperbarui

Metode berikut ini benar-benar mengembalikan 1 ketika tanggal 2012-12-31. Dengan kata lain, masalah saya adalah bahwa metode saya tidak mengikuti standar 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);
}

Sebagaimana dicatat dalam halaman MSDN ini ada sedikit perbedaan antara penomoran ISO8601 minggu dan .Net minggu.

Anda dapat merujuk ke artikel ini di Blog MSDN untuk penjelasan yang lebih baik: " Format ISO 8601 Week of Year di Microsoft .Net "

Sederhananya, .Net memungkinkan berminggu-minggu untuk membagi tahun sedangkan standar ISO tidak. Dalam artikel ini juga ada fungsi sederhana untuk mendapatkan nomor minggu ISO 8601 yang benar untuk minggu terakhir tahun ini.

Pembaruan Metode berikut ini benar-benar mengembalikan 1 2012-12-31yang benar di ISO 8601 (misalnya Jerman).

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

Mungkin ada lebih dari 52 minggu dalam setahun. Setiap tahun memiliki 52 minggu penuh + 1 atau +2 (tahun kabisat) ekstra. Mereka menebus untuk minggu ke-53.

• 52 minggu * 7 hari = 364 hari.

Jadi untuk setiap tahun Anda memiliki setidaknya satu hari ekstra. Dua untuk tahun kabisat. Apakah hari-hari tambahan ini dihitung sebagai minggu tersendiri?

Berapa minggu ada benar-benar tergantung pada hari awal minggu Anda. Mari kita pertimbangkan ini untuk 2012.

• AS (Minggu -> Sabtu): 52 minggu + satu minggu pendek 2 hari untuk 2012-12-30 & 2012-12-31. Ini menghasilkan total 53 minggu. Dua hari terakhir tahun ini (Minggu + Senin) merupakan minggu singkat mereka sendiri.

Periksa pengaturan Budaya Anda saat ini untuk melihat apa yang digunakannya sebagai hari pertama dalam seminggu.

Seperti yang Anda lihat, hasilnya adalah normal.

• Eropa (Senin -> Minggu): 2 Januari (2012-1-2) adalah hari Senin pertama, jadi ini adalah hari pertama dari minggu pertama. Tanyakan nomor minggu untuk tanggal 1 Januari dan Anda akan mendapatkan kembali 52 karena dianggap sebagai bagian dari minggu 2011 lalu.

Bahkan mungkin memiliki minggu ke-54. Terjadi setiap 28 tahun ketika tanggal 1 Januari dan 31 Desember diperlakukan sebagai minggu yang terpisah. Itu juga harus tahun kabisat.

Sebagai contoh, tahun 2000 memiliki 54 minggu. 1 Januari (sat) adalah hari satu minggu pertama, dan 31 Desember (matahari) adalah hari satu minggu kedua.

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

Cetakan: Tahun: 2012 Minggu: 54

Ubah CalendarWeekRule dalam contoh di atas menjadi FirstFullWeek atau FirstFourDayWeek dan Anda akan kembali 53. Mari kita mulai hari Senin, karena kita berurusan dengan Jerman.

Jadi minggu ke 53 dimulai pada hari Senin 2012-12-31, berlangsung satu hari dan kemudian berhenti.

53 adalah jawaban yang benar. Ubah Budaya menjadi Jerman jika ingin mencobanya.

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

Begini caranya:

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

Yang paling penting adalah CalendarWeekRuleparameternya.

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

Kabar baik! Sebuah permintaan tarik menambahkan System.Globalization.ISOWeekke NET Core hanya bergabung dan saat ini dijadwalkan untuk rilis 3.0. Semoga ini akan menyebar ke platform .NET lainnya dalam waktu yang tidak terlalu lama.

Jenis ini memiliki tanda tangan berikut, yang harus mencakup sebagian besar kebutuhan minggu 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);
    }
}

Anda dapat menemukan kode sumber di sini .

UPDATE : API ini juga telah disertakan dalam versi 2.1 .NET Standard .

Karena sepertinya tidak ada .Net-culture yang menghasilkan angka minggu ISO-8601 yang benar, saya lebih baik mem-bypass penetapan built-in week sama sekali, dan melakukan perhitungan secara manual, daripada mencoba untuk memperbaiki sebagian yang benar hasil.

Yang akhirnya saya dapatkan adalah metode ekstensi berikut:

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

Pertama-tama, ((int)date.DayOfWeek + 6) % 7)tentukan angka hari kerja, 0 = Senin, 6 = Minggu.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) menentukan tanggal hari Senin dari tanggal minggu yang diminta.

Tiga hari kemudian adalah target Kamis, yang menentukan tahun berapa dalam minggu ini.

Jika Anda membagi angka hari (berbasis nol) dalam tahun dengan tujuh (bulat), Anda mendapatkan nomor minggu (berbasis nol) di tahun tersebut.

Dalam c #, hasil perhitungan integer dibulatkan ke bawah secara implisit.

Di .NET 3.0 dan yang lebih baru Anda bisa menggunakan ISOWeek.GetWeekOfDate-Metode .

Perhatikan bahwa tahun dalam format angka tahun + minggu mungkin berbeda dari tahun DateTimekarena minggu yang melewati batas tahun.

C # ke Powershell port dari kode di atas dari 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
}

Cara termudah untuk menentukan angka minggu gaya ISO 8601 menggunakan c # dan kelas DateTime.

Tanyakan ini: berapa banyak hari Kamis dalam setahun adalah hari Kamis minggu ini. Jawabannya sama dengan angka minggu yang diinginkan.

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;

Ini bekerja baik untuk budaya AS dan Rusia. ISO 8601 juga akan benar, karena minggu Rusia dimulai pada hari Senin.

Berikut adalah versi ekstensi dan versi nullable dari jawaban il_guru .

Perpanjangan:

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

Tidak dapat dibatalkan:

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

Penggunaan:

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

Pertanyaannya adalah: Bagaimana Anda mendefinisikan apakah satu minggu di 2012 atau di 2013? Anggapan Anda, saya kira, adalah karena 6 hari dalam seminggu adalah pada tahun 2013, minggu ini harus ditandai sebagai minggu pertama tahun 2013.

Tidak yakin apakah ini cara yang tepat untuk pergi. Minggu itu dimulai pada 2012 (Pada Senin 31 Desember), jadi harus ditandai sebagai minggu terakhir 2012, oleh karena itu harus menjadi yang ke-53 tahun 2012. Minggu pertama 2013 harus dimulai pada hari Senin tanggal 7.

Sekarang, Anda dapat menangani kasus minggu tepi tertentu (minggu pertama dan terakhir tahun itu) menggunakan informasi hari dalam seminggu. Itu semua tergantung pada logika Anda.

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

Berdasarkan jawaban il_guru, saya membuat versi ini untuk kebutuhan saya sendiri yang juga mengembalikan komponen tahun.

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

Dua metode ini akan membantu, dengan asumsi minggu kita dimulai pada hari Senin

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

Satu tahun memiliki 52 minggu dan 1 hari atau 2 dalam kasus satu tahun putaran (52 x 7 = 364). 2012-12-31 akan menjadi minggu 53, satu minggu yang hanya akan memiliki 2 hari karena 2012 adalah tahun putaran.

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