Holen Sie sich die richtige Wochennummer eines bestimmten Datums

222

Ich habe viel gegoogelt und viele Lösungen gefunden, aber keine davon gibt mir die richtige Wochennummer für den 31.12.2012. Auch das Beispiel auf MSDN ( Link ) schlägt fehl.

2012-12-31 ist Montag, daher sollte es Woche 1 sein, aber jede Methode, die ich ausprobiert habe, gibt mir 53. Hier sind einige der Methoden, die ich ausprobiert habe:

Aus der MDSN-Bibliothek:

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

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

Lösung 2:

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

Lösung 3:

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

Aktualisieren

Die folgende Methode gibt tatsächlich 1 zurück, wenn das Datum 2012-12-31 ist. Mit anderen Worten, mein Problem war, dass meine Methoden nicht dem ISO-8601-Standard entsprachen.

// 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);
}
Amberlamps
quelle
4
Wie ist Woche 1 am Ende des Jahres? Ich meine, ich sehe, wo du es bekommst. Aber 53 macht für mich Sinn.
benjer3
1
In meinen Codefragmenten bekomme ich die CultureInfo und so. Ich dachte, mein Programm weiß bis dahin, welchen Kalender ich benutze. (Hier in Deutschland ist der 31. Dezember 2012 in Woche 1 von 2013)
Amberlamps
Dieser Code funktioniert nicht ganz so, wie er beispielsweise die Daten vom 31. Dezember 2016 oder vom 1.
Januar
@ Höhlej03 31.12.2016 ist Woche 52 und GetIso8601WeekOfYear gibt 52 zurück, also denke ich, dass es richtig funktioniert.
Muflix

Antworten:

311

Wie auf dieser MSDN-Seite angegeben, gibt es einen geringfügigen Unterschied zwischen der ISO8601-Wochen- und der .Net-Wochennummerierung.

Eine bessere Erklärung finden Sie in diesem Artikel im MSDN-Blog: " ISO 8601 Week of Year-Format in Microsoft .Net "

Einfach ausgedrückt, .Net ermöglicht die Aufteilung von Wochen auf Jahre, während der ISO-Standard dies nicht tut. In dem Artikel gibt es auch eine einfache Funktion, um die richtige ISO 8601-Wochennummer für die letzte Woche des Jahres zu erhalten.

Update Die folgende Methode gibt tatsächlich 1 zurück, 2012-12-31was in ISO 8601 (z. B. Deutschland) korrekt ist.

// 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);
} 
il_guru
quelle
1
@il_guru Was ist, wenn ich möchte, dass die Woche mit Sonntag beginnt? Ersetze ich alle "Montag" durch "Sonntag"?
User2012384
2
@ User2012384 fyi, wenn Sie dem ISO8601-Standard folgen möchten, sollte der erste Tag der Woche immer Montag sein.
Starceaker
1
@il_guru Du brauchst nicht einmal diesen "Cheat", wenn? Soweit ich sagen kann "GetWeekOfYear (Zeit, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);" funktioniert gut.
Starceaker
2
Wenn Sie sich den zweiten Link ansehen (ISO 8601 Week of Year-Format in Microsoft .Net), finden Sie die Antwort auf Ihre Frage direkt bei Microsoft. Ein Beispiel ist Montag, der 31.12.2007: Mit der .Net-Funktion wird Woche 53 von 2007 zurückgegeben, während es für den ISO-Standard Woche 1 von 2008 ist
il_guru
3
Ich habe dies manuell für die Jahre 2012 bis 2018 als korrekt überprüft (vorausgesetzt, epochconverter.com ist korrekt). Wir sollten uns alle dieses Jahr freuen, dass die erste Woche von 2018 tatsächlich einmal am ersten Januar begann!
Aidan
32

Ein Jahr kann mehr als 52 Wochen dauern. Jedes Jahr hat 52 volle Wochen + 1 oder + 2 (Schaltjahr) Tage mehr. Sie machen eine 53. Woche wieder gut.

  • 52 Wochen * 7 Tage = 364 Tage.

Sie haben also für jedes Jahr mindestens einen zusätzlichen Tag. Zwei für Schaltjahre. Werden diese zusätzlichen Tage als eigene Wochen gezählt?

Wie viele Wochen es wirklich gibt, hängt vom Starttag Ihrer Woche ab. Betrachten wir dies für 2012.

  • USA (Sonntag -> Samstag): 52 Wochen + eine kurze 2-Tage-Woche für 2012-12-30 & 2012-12-31. Dies ergibt insgesamt 53 Wochen. Die letzten beiden Tage dieses Jahres (Sonntag + Montag) bilden ihre eigene kurze Woche.

Überprüfen Sie die Einstellungen Ihrer aktuellen Kultur, um festzustellen, was als erster Tag der Woche verwendet wird.

Wie Sie sehen, ist es normal, 53 zu erhalten.

  • Europa (Montag -> Sonntag): Der 2. Januar (2012-1-2) ist der erste Montag, also der erste Tag der ersten Woche. Wenn Sie nach der Wochennummer für den 1. Januar fragen, erhalten Sie 52 zurück, da dies Teil der letzten Woche 2011 ist.

Es ist sogar möglich, eine 54. Woche zu haben. Passiert alle 28 Jahre, wenn der 1. Januar und der 31. Dezember als separate Wochen behandelt werden. Es muss auch ein Schaltjahr sein.

Zum Beispiel hatte das Jahr 2000 54 Wochen. Der 1. Januar (gesessen) war der erste einwöchige Tag und der 31. Dezember (sonntags) war der zweite einwöchige Tag.

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

Ausdrucke: Jahr: 2012 Woche: 54

Wenn Sie die CalendarWeekRule im obigen Beispiel in FirstFullWeek oder FirstFourDayWeek ändern, erhalten Sie 53 zurück. Lassen Sie uns den Starttag am Montag beibehalten, da es sich um Deutschland handelt.

Woche 53 beginnt also am Montag, den 31.12.2012, dauert einen Tag und endet dann.

53 ist die richtige Antwort. Ändern Sie die Kultur nach Deutschland, wenn Sie es versuchen möchten.

CultureInfo cul = CultureInfo.GetCultureInfo("de-DE");
Christophe Geers
quelle
Ich weiß, dass es möglich ist, dass es 53 Wochen gibt. Aber wenn Sie Sonntag (30.12.) Und Montag (31.12.) Haben, zählen Sie den Dienstag (01.01.) Nicht auch als Teil der 53. Woche in den USA?
Amberlamps
Ich habe noch nie eine 54. Woche gesehen!
Amberlamps
Bestimmte steuerliche Softwarepakete haben sie.
Christophe Geers
Okay, ich habe herausgefunden, dass es in US-Kalendern möglich ist, aber in deutschen Kalendern wird es nicht passieren.
Amberlamps
1
+1 für Ihre tiefen Gedanken zu diesem Thema, aber das Code-Snippet im Blogeintrag in einer anderen Antwort hat mein Problem tatsächlich gelöst.
Amberlamps
22

Das ist der Weg:

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

Am wichtigsten für ist der CalendarWeekRuleParameter.

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

daniele3004
quelle
3
"Mehrere Leute haben bemerkt, dass Calendar.GetWeekOfYear () fast wie die ISO 8601-Woche ist, wenn CalendarWeekRule.FirstFourDayWeek und DayOfWeek.Monday bestanden werden, es ist jedoch ein bisschen anders. Insbesondere hat ISO 8601 immer 7-Tage-Wochen." Blogs.msdn. microsoft.com/shawnste/2006/01/24/…
Juha Palomäki
1
Ihr Link ist in Italienisch
Radbyx
für neue DateTime (2000,12,31) gibt es nur 52?
Leszek P
18

Gute Nachrichten! Eine Pull-Anfrage wird hinzugefügtSystem.Globalization.ISOWeek zu .NET Core , wurde gerade zusammengeführt und ist derzeit für die Version 3.0 vorgesehen. Hoffentlich wird es in nicht allzu ferner Zukunft auf die anderen .NET-Plattformen übertragen.

Der Typ hat die folgende Signatur, die die meisten Anforderungen der ISO-Woche abdecken sollte :

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

Den Quellcode finden Sie hier .

UPDATE : Diese APIs wurden auch in die 2.1-Version von .NET Standard aufgenommen .

Khellang
quelle
Irgendeine Idee, wann v 3.0 veröffentlicht wird?
Jacques
"Wir planen, noch in diesem Jahr eine erste Vorschau von .NET Core 3 und die endgültige Version 2019 zu veröffentlichen." (aus dem Roadmap-Blog-Beitrag )
Khellang
@ Khellang Wie kann ich eine Ordnungswoche in einem Monat basierend auf Datum / Uhrzeit erhalten? Anstatt Woche 33 zu bekommen, würde ich gerne Woche 2 sehen (weil Woche 33 Woche 2 im August ist). stackoverflow.com/questions/58039103/…
Roxy'Pro
11

Da es anscheinend keine .Net-Kultur gibt, die die korrekte ISO-8601-Wochenzahl liefert, würde ich die integrierte Wochenbestimmung lieber ganz umgehen und die Berechnung manuell durchführen, anstatt zu versuchen, eine teilweise korrekte zu korrigieren Ergebnis.

Am Ende hatte ich folgende Erweiterungsmethode:

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

Zunächst einmal ((int)date.DayOfWeek + 6) % 7)bestimmt den Wochentag Zahl, 0 = Montag, 6 = Sonntag.

date.AddDays(-((int)date.DayOfWeek + 6) % 7) bestimmt das Datum des Montags vor der angeforderten Wochennummer.

Drei Tage später ist der Ziel-Donnerstag, der bestimmt, in welchem ​​Jahr die Woche ist.

Wenn Sie die (auf Null basierende) Tageszahl innerhalb des Jahres durch sieben (Abrundung) teilen, erhalten Sie die (auf Null basierende) Wochennummer im Jahr.

In c # werden die Ergebnisse der Ganzzahlberechnung implizit abgerundet.

Realbart
quelle
1
Dies ist bei weitem die beste Lösung, aber ich werde auf eine etwas andere Art und Weise hinweisen: DateTime basiert auf dem proleptischen Gregorianischen Kalender - dh es erweitert den Gregorianischen Kalender auf das Jahr 1. Der 1. Januar 0001 ist zufällig ein Montag. Ticksist die Anzahl der 100-Nanosekunden-Inkremente seit dem 1. Januar 0001. Angesichts der Tatsache, dass ein Tag 86.400 Sekunden hat, können wir schreiben:var thursday = date.AddDays(3 - date.Ticks / 86400 / 10_000_000 % 7); return (thursday.DayOfYear - 1) / 7 + 1;
Adrian S
5

In .NET 3.0 und höher können Sie die ISOWeek.GetWeekOfDate-Methode verwenden .

Beachten Sie, dass das Jahr im Format Jahr + Woche DateTimeaufgrund von Wochen, die die Jahresgrenze überschreiten, vom Jahr des Jahres abweichen kann .

johh
quelle
3

C # zum Powershell-Port vom obigen Code von 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
}
Rainer
quelle
1
Könnten Sie Ihren Code erklären? Nur-Code-Antworten sind in StackOverflow im Allgemeinen nicht akzeptabel und können daher gelöscht werden.
Wai Ha Lee
@Wai Ha Lee der Code ist bereits erklärt. Siehe Beitrag oben von il_guru. Ich habe seinen Code auf Powershell portiert, damit andere ihn in Powershell verwenden können, da es in Powershell bisher keine gute Lösung gibt.
Rainer
Wenn Sie dies getan haben, sollten Sie den ursprünglichen Autor in der Antwort selbst angeben. Die Antwort, die Sie portiert haben, enthält bessere Kommentare, die Sie vermutlich entfernt haben. Dies ist auch keine Antwort auf die Frage, da in der Frage PowerShell nicht erwähnt wurde.
Wai Ha Lee
1
Ich habe jetzt @Wai Ha Lee. Die Frage ist bereits als beantwortet markiert, daher wäre dies dieselbe Lösung, die in einer anderen Sprache geschrieben wurde. Ich habe Menschen einen Gefallen getan, die nach einer Lösung in Powershell-Sprache suchen (ich habe intensiv nach einer Lösung in Powershell gesucht, aber ich habe eine Lösung in C # gefunden). Die Idee bleibt die gleiche und der Autor bekommt die Anerkennung dafür.
Rainer
2

Der einfachste Weg, um den ISO 8601-Stil der Wochennummer mithilfe von c # und der DateTime-Klasse zu bestimmen.

Fragen Sie dies: Der Donnerstag des Jahres ist der Donnerstag dieser Woche. Die Antwort entspricht der gewünschten Wochennummer.

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;
user6887101
quelle
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;

Es funktioniert sowohl für die US-amerikanische als auch für die russische Kultur. ISO 8601 wird auch korrekt sein, da die russische Woche am Montag beginnt.

Donskikh Andrei
quelle
1

Hier ist eine Erweiterungsversion und eine nullfähige Version der Antwort von il_guru .

Erweiterung:

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

Verwendung:

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

Die Frage ist: Wie definieren Sie, ob eine Woche 2012 oder 2013 ist? Ihre Vermutung ist, dass diese Woche als die erste Woche des Jahres 2013 markiert werden sollte, da 6 Tage der Woche im Jahr 2013 sind.

Ich bin mir nicht sicher, ob dies der richtige Weg ist. Diese Woche begann am Jahr 2012 (am Montag, den 31. Dezember), daher sollte sie als letzte Woche des Jahres 2012 markiert sein, daher sollte es die 53. Woche des Jahres 2012 sein. Die erste Woche des Jahres 2013 sollte am Montag, den 7. Dezember beginnen.

Jetzt können Sie den speziellen Fall von Randwochen (erste und letzte Woche des Jahres) anhand der Informationen zum Wochentag behandeln. Es hängt alles von Ihrer Logik ab.

Samy Arous
quelle
Okay, ich kann deinen Standpunkt sehen. Die Sache ist, wenn ich 2013/01/07 in einer meiner Methoden verwende, heißt es Woche 2. Also, 2012/12/31 ist Woche 53 und 2013/01/07 ist Woche 2. Sie könnten denken, es gibt keine Woche 1 von 2013. Aber wenn ich 2013/01/01 versuche, heißt es Woche 1.
Amberlamps
0
  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));      
Imran
quelle
0

Basierend auf der Antwort von il_guru habe ich diese Version für meine eigenen Bedürfnisse erstellt, die auch die Jahreskomponente zurückgibt.

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

Diese beiden Methoden werden helfen, vorausgesetzt, unsere Woche beginnt am Montag

/// <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;
    }
Mnyikka
quelle
-1

Ein Jahr hat 52 Wochen und 1 Tag oder 2 im Falle eines Rundenjahres (52 x 7 = 364). 2012-12-31 wäre Woche 53, eine Woche, die nur 2 Tage haben würde, weil 2012 ein Rundenjahr ist.

CarlosJ
quelle
Das ist falsch. Der erste Tag der Woche des Jahres kann auf jeden Wochentag fallen, je nachdem, wie Sie die Wochen zählen, kann das Jahr eine 54. Woche haben.
Krowe2
-2
public int GetWeekNumber()
{
   CultureInfo ciCurr = CultureInfo.CurrentCulture;
   int weekNum = ciCurr.Calendar.GetWeekOfYear(DateTime.Now, 
   CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
   return weekNum;
}
Meghnath Das
quelle