รับหมายเลขสัปดาห์ที่ถูกต้องของวันที่ที่กำหนด

ฉันใช้ Google เป็นจำนวนมากและพบวิธีแก้ปัญหามากมาย แต่ไม่มีใครให้หมายเลขในสัปดาห์ที่ถูกต้องสำหรับ 2012-12-31 แม้แต่ตัวอย่างบน MSDN ( ลิงค์ ) ก็ล้มเหลว

2012-12-31 คือวันจันทร์จึงควรเป็นสัปดาห์ที่ 1 แต่ทุกวิธีที่ฉันลองให้ฉัน 53 นี่คือวิธีการบางอย่างที่ฉันได้ลอง:

จาก MDSN Library:

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

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

โซลูชันที่ 2:

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

โซลูชันที่ 3:

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

ปรับปรุง

วิธีการดังต่อไปนี้จริง ๆ แล้วส่งกลับ 1 เมื่อวันที่เป็น 2012-12-31 ปัญหาของฉันคือว่าวิธีการของฉันไม่เป็นไปตามมาตรฐาน 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);
}

ดังที่ระบุไว้ในหน้า MSDN นี้มีความแตกต่างกันเล็กน้อยระหว่าง ISO8601 สัปดาห์และ. Net สัปดาห์ที่นับ

คุณสามารถอ้างถึงบทความนี้ในบล็อก MSDN สำหรับคำอธิบายที่ดีกว่า: " รูปแบบ ISO 8601 สัปดาห์แห่งปีใน Microsoft .Net "

เพียงแค่ใส่. Net จะอนุญาตให้แบ่งสัปดาห์เป็นเวลาหลายปีในขณะที่มาตรฐาน ISO ไม่สามารถทำได้ ในบทความยังมีฟังก์ชั่นง่าย ๆ เพื่อรับหมายเลข ISO 8601 สัปดาห์ที่ถูกต้องสำหรับสัปดาห์สุดท้ายของปี

อัปเดตวิธีการต่อไปนี้จะคืนค่า 1 2012-12-31ซึ่งถูกต้องใน 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);
} 

อาจมีมากกว่า 52 สัปดาห์ในหนึ่งปี ในแต่ละปีมี 52 สัปดาห์เต็ม + 1 หรือ +2 (ปีอธิกสุรทิน) วันพิเศษ พวกเขาประกอบกันเป็นสัปดาห์ที่ 53

• 52 สัปดาห์ * 7 วัน = 364 วัน

ดังนั้นในแต่ละปีคุณมีอย่างน้อยหนึ่งวันต่อวัน สองปีอธิกสุรทิน วันพิเศษเหล่านี้ถูกนับเป็นสัปดาห์แยกจากกัน

กี่สัปดาห์ขึ้นอยู่กับวันเริ่มต้นของสัปดาห์ ลองพิจารณาสิ่งนี้สำหรับปี 2012

• สหรัฐอเมริกา (วันอาทิตย์ -> วันเสาร์): 52 สัปดาห์ + หนึ่งสัปดาห์สั้น ๆ 2 วันสำหรับ 2012-12-30 และ 2012-12-31 ส่งผลให้ทั้งหมด 53 สัปดาห์ สองวันสุดท้ายของปีนี้ (วันอาทิตย์ + วันจันทร์) เป็นสัปดาห์สั้น ๆ

ตรวจสอบการตั้งค่าปัจจุบันของวัฒนธรรมของคุณเพื่อดูว่ามันใช้เป็นวันแรกของสัปดาห์

ตามที่คุณเห็นเป็นเรื่องปกติที่จะได้รับ 53 ตามลำดับ

• ยุโรป (วันจันทร์ -> วันอาทิตย์): 2 มกราคม (2012-1-2) เป็นวันจันทร์แรกดังนั้นนี่เป็นวันแรกของสัปดาห์แรก ถามหมายเลขสัปดาห์สำหรับวันที่ 1 มกราคมและคุณจะได้รับคืน 52 เนื่องจากถือเป็นส่วนหนึ่งของสัปดาห์สุดท้ายของปี 2011

เป็นไปได้ที่จะมีสัปดาห์ที่ 54 เกิดขึ้นทุก ๆ 28 ปีเมื่อวันที่ 1 มกราคมและ 31 ธันวาคมได้รับการปฏิบัติเป็นสัปดาห์ที่แยกกัน มันจะต้องเป็นปีอธิกสุรทินด้วยเช่นกัน

ตัวอย่างเช่นปี 2000 มี 54 สัปดาห์ วันที่ 1 มกราคม (วันเสาร์) เป็นวันแรกของสัปดาห์และวันที่ 31 ธันวาคม (วันอาทิตย์) เป็นวันที่สองในหนึ่งสัปดาห์

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

พิมพ์ออกมา: ปี: 2012 สัปดาห์: 54

เปลี่ยน CalendarWeekRule ในตัวอย่างด้านบนเป็น FirstFullWeek หรือ FirstFourDayWeek และคุณจะได้รับกลับมา 53. ให้เราเริ่มวันจันทร์ในวันจันทร์เพราะเราจะติดต่อกับเยอรมนี

ดังนั้นสัปดาห์ 53 เริ่มในวันจันทร์ 2012-12-31 มีระยะเวลาหนึ่งวันแล้วหยุด

53 คือคำตอบที่ถูกต้อง เปลี่ยนวัฒนธรรมเป็นเยอรมนีหากต้องการลอง

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

นี่คือวิธี:

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

สิ่งสำคัญที่สุดคือCalendarWeekRuleพารามิเตอร์

ดูที่นี่: https://msdn.microsoft.com/query/dev14.query?appId=Dev14IDEF1&l=IT-IT&k=k(System.Globalization.CalendarWeekRule);k(TargetFrameworkMoniker-.NETFramework

ข่าวดี! คำขอดึงเพิ่มSystem.Globalization.ISOWeekเพื่อ .NET หลักรวมเพียงและมีกำหนดในขณะนี้สำหรับการเปิดตัว 3.0 หวังว่ามันจะแพร่กระจายไปยังแพลตฟอร์ม NET อื่น ๆ ในอนาคตไม่ไกลเกินไป

ชนิดมีลายเซ็นต่อไปนี้ซึ่งควรครอบคลุมความต้องการ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);
    }
}

คุณสามารถค้นหารหัสที่มาที่นี่

UPDATE : API เหล่านี้ยังได้รับการรวมอยู่ในรุ่น 2.1 .NET มาตรฐาน

เนื่องจากดูเหมือนว่าจะไม่เป็น. Net-culture ที่ให้ค่าหมายเลข ISO-8601 สัปดาห์ที่ถูกต้องฉันควรข้ามการตรวจสอบภายในสัปดาห์ทั้งหมดและทำการคำนวณด้วยตนเองแทนที่จะพยายามแก้ไขให้ถูกต้องเพียงบางส่วน ผลลัพธ์.

สิ่งที่ฉันลงเอยด้วยวิธีการต่อไปนี้คือ:

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

ก่อนอื่น((int)date.DayOfWeek + 6) % 7)กำหนดจำนวนวันทำงาน 0 = วันจันทร์ 6 = วันอาทิตย์

date.AddDays(-((int)date.DayOfWeek + 6) % 7) กำหนดวันที่ของวันจันทร์ล่วงหน้าหมายเลขสัปดาห์ที่ร้องขอ

สามวันต่อมาคือเป้าหมายของวันพฤหัสบดีซึ่งเป็นตัวกำหนดปีของสัปดาห์

หากคุณหารจำนวนวันตาม (เป็นศูนย์) ภายในปีเจ็ด (ปัดเศษลง) คุณจะได้รับหมายเลขสัปดาห์ตาม (เป็นศูนย์) ในปี

ใน c # ผลการคำนวณจำนวนเต็มจะปัดลงโดยปริยาย

ใน .NET 3.0 และต่อมาคุณสามารถใช้-MethodISOWeek.GetWeekOfDate

โปรดทราบว่าปีในรูปแบบตัวเลขปี + สัปดาห์อาจแตกต่างจากปีDateTimeเนื่องจากสัปดาห์ที่ข้ามขอบเขตปี

C # ถึง Powershell พอร์ตจากโค้ดด้านบนจาก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
}

วิธีที่ง่ายที่สุดในการกำหนดสไตล์ ISO 8601 ของสัปดาห์โดยใช้ c # และคลาส DateTime

ถามสิ่งนี้: วันพฤหัสบดีของสัปดาห์มีกี่วันกี่วัน คำตอบเท่ากับจำนวนสัปดาห์ที่ต้องการ

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;

มันทำงานได้ดีทั้งกับวัฒนธรรมของสหรัฐอเมริกาและรัสเซีย ISO 8601 ก็จะถูกต้องเช่นกัน `ทำให้สัปดาห์ของรัสเซียเริ่มต้นในวันจันทร์

นี่คือส่วนขยายและคำตอบของรุ่นil_guru

ส่วนขยาย:

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

ประเพณี:

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

คำถามคือ: คุณจะกำหนดได้อย่างไรถ้าสัปดาห์หนึ่งอยู่ในปี 2012 หรือในปี 2013 ฉันเดาว่าคุณคาดคะเนได้ว่าตั้งแต่ 6 วันของสัปดาห์ในปี 2013 สัปดาห์นี้ควรถูกทำเครื่องหมายเป็นสัปดาห์แรกของปี 2013

ไม่แน่ใจว่านี่เป็นวิธีที่ถูกต้องหรือไม่ สัปดาห์นั้นเริ่มต้นในปี 2012 (ในวันจันทร์ที่ 31 ธันวาคม) ดังนั้นจึงควรถูกทำเครื่องหมายเป็นสัปดาห์สุดท้ายของปี 2012 ดังนั้นจึงควรเป็นวันที่ 53 ของปี 2012 สัปดาห์แรกของปี 2013 ควรเริ่มในวันจันทร์ที่ 7

ตอนนี้คุณสามารถจัดการกับกรณีเฉพาะของสัปดาห์ขอบ (สัปดาห์แรกและสัปดาห์สุดท้ายของปี) โดยใช้ข้อมูลวันของสัปดาห์ ทุกอย่างขึ้นอยู่กับตรรกะของคุณ

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

จากคำตอบของ il_guru ฉันได้สร้างเวอร์ชันนี้ขึ้นมาเพื่อตอบสนองความต้องการของตัวเองและส่งคืนองค์ประกอบปี

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

ทั้งสองวิธีนี้จะช่วยสมมติว่าสัปดาห์ของเราเริ่มต้นในวันจันทร์

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

ปีมี 52 สัปดาห์และ 1 วันหรือ 2 ในกรณีของรอบปี (52 x 7 = 364) 2012-12-31 จะเป็นสัปดาห์ 53 สัปดาห์ที่จะมีเพียง 2 วันเพราะปี 2012 เป็นปีแห่งการตัก

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