Btukfyl

There can be more than 52 weeks in a year. Each year has 52 full weeks + 1 or +2 (leap year) days extra. They make up for a 53th week.

• 52 weeks * 7days = 364 days.

So for each year you have at least one an extra day. Two for leap years. Are these extra days counted as separate weeks of their own?

How many weeks there are really depends on the starting day of your week. Let's consider this for 2012.

• US (Sunday -> Saturday): 52 weeks + one short 2 day week for 2012-12-30 & 2012-12-31. This results in a total of 53 weeks. Last two days of this year (Sunday + Monday) make up their own short week.

Check your current Culture's settings to see what it uses as the first day of the week.

As you see it's normal to get 53 as a result.

• Europe (Monday -> Sunday): January 2dn (2012-1-2) is the first monday, so this is the first day of the first week. Ask the week number for the 1st of January and you'll get back 52 as it is considered part of 2011 last's week.

It's even possible to have a 54th week. Happens every 28 years when the 1st of January and the 31st of December are treated as separate weeks. It must be a leap year too.

For example, the year 2000 had 54 weeks. January 1st (sat) was the first one week day, and 31st December (sun) was the second one week day.

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

Prints out: Year: 2012 Week: 54

Change CalendarWeekRule in the above example to FirstFullWeek or FirstFourDayWeek and you'll get back 53. Let's keep the start day on Monday since we are dealing with Germany.

So week 53 starts on monday 2012-12-31, lasts one day and then stops.

53 is the correct answer. Change the Culture to germany if want to to try it.

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

This is the way:

public int GetWeekNumber()

{

    CultureInfo ciCurr = CultureInfo.CurrentCulture;

    int weekNum = ciCurr.Calendar.GetWeekOfYear(DateTime.Now, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);

    return weekNum;

}

Most important for is the CalendarWeekRule parameter.

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

I'm going to play Necromancer here :-)

Since there doesn't seem to be a .Net-culture that yields the correct ISO-8601 week number, I'd rather bypass the built-in week determination altogether, and do the calculation manually, instead of attempting to correct a partially correct result.

What I ended up with is the following extension method:

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

}

First of all, ((int)date.DayOfWeek + 6) % 7) determines the weekday number, 0=monday, 6=sunday.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) determines the date of the monday preceiding the requested week number.

Three days later is the target thursday, which determines what year the week is in.

If you divide the (zero based) day-number within the year by seven (round down), you get the (zero based) week number in the year.

In c#, integer calculation results are round down implicitly.

Good news! A pull request adding System.Globalization.ISOWeek to .NET Core was just merged and is currently slated for the 3.0 release. Hopefully it will propagate to the other .NET platforms in a not-too-distant future.

The type has the following signature, which should cover most ISO week needs:

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

    }

}

You can find the source code here.

C# to Powershell port from code above from 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

}

The easiest way to determine the week number ISO 8601 style using c# and the DateTime class.

Ask this: the how-many-eth thursday of the year is the thursday of this week.
The answer equals the wanted week number.

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;

It works well both for US and Russian cultures. ISO 8601 also will be correct, `cause Russian week starts at Monday.

The question is: How do you define if a week is in 2012 or in 2013?
Your supposition, I guess, is that since 6 days of the week are in 2013, this week should be marked as the first week of 2013.

Not sure if this is the right way to go.
That week started on 2012 (On monday 31th Dec), so it should be marked as the last week of 2012, therefore it should be the 53rd of 2012. The first week of 2013 should start on monday the 7th.

Now, you can handle the particular case of edge weeks (first and last week of the year) using the day of week information. It all depends on your logic.

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

A year has 52 weeks and 1 day or 2 in case of a lap year (52 x 7 = 364). 2012-12-31 would be week 53, a week that would only have 2 days because 2012 is a lap year.