Abrufen des Tagessuffix bei Verwendung von DateTime.ToString ()

Ist es möglich, das Tagessuffix beim Formatieren eines Datums mit DateTime.ToString () einzuschließen?

Zum Beispiel möchte ich das Datum im folgenden Format drucken - Montag, 27. Juli 2009. Das nächste Beispiel, das ich mit DateTime.ToString () finden kann, ist Montag, 27. Juli 2009.

Kann ich dies mit DateTime.ToString () tun oder muss ich auf meinen eigenen Code zurückgreifen?

Als Referenz verwende / verweise ich immer auf SteveX String Formatierung und es scheint kein "th" in einer der verfügbaren Variablen zu geben, aber Sie könnten leicht einen String mit erstellen

string.Format("{0:dddd dd}{1} {0:MMMM yyyy}", DateTime.Now, (?));

Sie müssten dann ein "st" für 1, ein "nd" für 2, ein "rd" für 3 und ein "th" für alle anderen angeben und könnten mit einer "?:" - Anweisung versehen sein.

var now = DateTime.Now;
(now.Day % 10 == 1 && now.Day != 11) ? "st"
: (now.Day % 10 == 2 && now.Day != 12) ? "nd"
: (now.Day % 10 == 3 && now.Day != 13) ? "rd"
: "th"

Eine weitere Option mit Schalter:

string GetDaySuffix(int day)
{
    switch (day)
    {
        case 1:
        case 21:
        case 31:
            return "st";
        case 2:
        case 22:
            return "nd";
        case 3:
        case 23:
            return "rd";
        default:
            return "th";
    }
}

Verwenden einiger Erweiterungsmethoden:

namespace System
{
    public static class IntegerExtensions
    {
        public static string ToOccurrenceSuffix(this int integer)
        {
            switch (integer % 100)
            {
                case 11:
                case 12:
                case 13:
                    return "th";
            }
            switch (integer % 10)
            {
                case 1:
                    return "st";
                case 2:
                    return "nd";
                case 3:
                    return "rd";
                default:
                    return "th";
            }
        }
    }   

    public static class DateTimeExtensions
    {
        public static string ToString(this DateTime dateTime, string format, bool useExtendedSpecifiers)
        {
            return useExtendedSpecifiers 
                ? dateTime.ToString(format)
                    .Replace("nn", dateTime.Day.ToOccurrenceSuffix().ToLower())
                    .Replace("NN", dateTime.Day.ToOccurrenceSuffix().ToUpper())
                : dateTime.ToString(format);
        } 
    }
}

Verwendung:

return DateTime.Now.ToString("dddd, dnn MMMM yyyy", useExtendedSpecifiers: true);
// Friday, 7th March 2014

Hinweis: Die Ganzzahl-Erweiterungsmethode kann für eine beliebige Zahl verwendet werden, nicht nur für 1 bis 31. ZB

return 332211.ToOccurrenceSuffix();
// th

Eine weitere Option ist die Verwendung des Modulo-Operators :

public string CreateDateSuffix(DateTime date)
{
    // Get day...
    var day = date.Day;

    // Get day modulo...
    var dayModulo = day%10;

    // Convert day to string...
    var suffix = day.ToString(CultureInfo.InvariantCulture);

    // Combine day with correct suffix...
    suffix += (day == 11 || day == 12 || day == 13) ? "th" :
        (dayModulo == 1) ? "st" :
        (dayModulo == 2) ? "nd" :
        (dayModulo == 3) ? "rd" :
        "th";

    // Return result...
    return suffix;
}

Sie würden dann die obige Methode aufrufen, indem Sie ein DateTime- Objekt als Parameter übergeben, zum Beispiel:

// Get date suffix for 'October 8th, 2019':
var suffix = CreateDateSuffix(new DateTime(2019, 10, 8));

Weitere Informationen zum DateTime- Konstruktor finden Sie auf der Microsoft Docs-Seite .

Hier ist die erweiterte Version einschließlich 11., 12. und 13 .:

DateTime dt = DateTime.Now;
string d2d = dt.ToString("dd").Substring(1);
string daySuffix =
    (dt.Day == 11 || dt.Day == 12 || dt.Day == 13) ? "th"
    : (d2d == "1") ? "st"
    : (d2d == "2") ? "nd"
    : (d2d == "3") ? "rd"
    : "th";

Ausgehend von der Antwort von @ Lazlow auf eine vollständige Lösung ist das Folgende eine vollständig wiederverwendbare Erweiterungsmethode mit Beispielverwendung.

internal static string HumanisedDate(this DateTime date)
{
    string ordinal;

    switch (date.Day)
    {
        case 1:
        case 21:
        case 31:
            ordinal = "st";
            break;
        case 2:
        case 22:
            ordinal = "nd";
            break;
        case 3:
        case 23:
            ordinal = "rd";
            break;
        default:
            ordinal = "th";
            break;
    }

    return string.Format("{0:dddd dd}{1} {0:MMMM yyyy}", date, ordinal);
} 

Um dies zu verwenden, würden Sie es einfach für ein DateTimeObjekt aufrufen .

var myDate = DateTime.Now();
var myDateString = myDate.HumanisedFormat()

Welches wird Ihnen geben:

Freitag, 17. Juni 2016

AKTUALISIEREN

NuGet-Paket:
https://www.nuget.org/packages/DateTimeToStringWithSuffix

Beispiel:
https://dotnetfiddle.net/zXQX7y

Unterstützt:
.NET Core 1.0 und höher
.NET Framework 4.5 und höher

Hier ist eine Erweiterungsmethode (weil jeder Erweiterungsmethoden liebt) mit Lazlows Antwort als Grundlage (ausgewählt Lazlows, da es leicht zu lesen ist).

Funktioniert genau wie die reguläre ToString()Methode, DateTimemit der Ausnahme, dass das Suffix automatisch hinzugefügt wird , wenn das Format ein doder enthält dd.

/// <summary>
/// Return a DateTime string with suffix e.g. "st", "nd", "rd", "th"
/// So a format "dd-MMM-yyyy" could return "16th-Jan-2014"
/// </summary>
public static string ToStringWithSuffix(this DateTime dateTime, string format, string suffixPlaceHolder = "$") {
    if(format.LastIndexOf("d", StringComparison.Ordinal) == -1 || format.Count(x => x == 'd') > 2) {
        return dateTime.ToString(format);
    }

    string suffix;
    switch(dateTime.Day) {
        case 1:
        case 21:
        case 31:
            suffix = "st";
            break;
        case 2:
        case 22:
            suffix = "nd";
            break;
        case 3:
        case 23:
            suffix = "rd";
            break;
        default:
            suffix = "th";
            break;
    }

    var formatWithSuffix = format.Insert(format.LastIndexOf("d", StringComparison.InvariantCultureIgnoreCase) + 1, suffixPlaceHolder);
    var date = dateTime.ToString(formatWithSuffix);

    return date.Replace(suffixPlaceHolder, suffix);
}

Ich glaube, dass dies eine gute Lösung ist, die Zahlen wie die 111. abdeckt:

private string daySuffix(int day)
{
    if (day > 0)
    {
        if (day % 10 == 1 && day % 100 != 11)
            return "st";
        else if (day % 10 == 2 && day % 100 != 12)
            return "nd";
        else if (day % 10 == 3 && day % 100 != 13)
            return "rd";
        else
            return "th";
    }
    else
        return string.Empty;
}

Für diejenigen, die gerne externe Abhängigkeiten verwenden (in diesem Fall das fantastische Humanizr .net ), ist es so einfach wie

dateVar.Day.Ordinalize(); \\ 1st, 4th etc depending on the value of dateVar

Ich habe es so gemacht, es umgeht einige der Probleme, die in den anderen Beispielen angegeben sind.

    public static string TwoLetterSuffix(this DateTime @this)
    {
        var dayMod10 = @this.Day % 10;

        if (dayMod10 > 3 || dayMod10 == 0 || (@this.Day >= 10 && @this.Day <= 19))
        {
            return "th";
        }
        else if(dayMod10 == 1)
        {
            return "st";
        }
        else if (dayMod10 == 2)
        {
            return "nd";
        }
        else
        {
            return "rd";
        }
    }

Eine billige und fröhliche VB-Lösung:

litDate.Text = DatePart("dd", Now) & GetDateSuffix(DatePart("dd", Now))

Function GetDateSuffix(ByVal dateIn As Integer) As String

    '// returns formatted date suffix

    Dim dateSuffix As String = ""
    Select Case dateIn
        Case 1, 21, 31
            dateSuffix = "st"
        Case 2, 22
            dateSuffix = "nd"
        Case 3, 23
            dateSuffix = "rd"
        Case Else
            dateSuffix = "th"
    End Select

    Return dateSuffix

End Function

Für was es hier wert ist, ist meine endgültige Lösung mit den folgenden Antworten

     DateTime dt = DateTime.Now;
        string d2d = dt.ToString("dd").Substring(1); 

        string suffix =
       (dt.Day == 11 || dt.Day == 12 || dt.Day == 13) ? "th"
       : (d2d == "1") ? "st"
       : (d2d == "2") ? "nd"
       : (d2d == "3") ? "rd"
       : "th";


        Date.Text = DateTime.Today.ToString("dddd d") + suffix + " " + DateTime.Today.ToString("MMMM") + DateTime.Today.ToString(" yyyy"); 

public static String SuffixDate (DateTime date) {string ordinal;

     switch (date.Day)
     {
        case 1:
        case 21:
        case 31:
           ordinal = "st";
           break;
        case 2:
        case 22:
           ordinal = "nd";
           break;
        case 3:
        case 23:
           ordinal = "rd";
           break;
        default:
           ordinal = "th";
           break;
     }
     if (date.Day < 10)
        return string.Format("{0:d}{2} {1:MMMM yyyy}", date.Day, date, ordinal);
     else
        return string.Format("{0:dd}{1} {0:MMMM yyyy}", date, ordinal);
  }

Datumssuffix abrufen. (Statische Funktion)

public static string GetSuffix(this string day)
{
    string suffix = "th";

    if (int.Parse(day) < 11 || int.Parse(day) > 20)
    {
        day = day.ToCharArray()[day.ToCharArray().Length - 1].ToString();
        switch (day)
        {
            case "1":
                suffix = "st";
                break;
            case "2":
                suffix = "nd";
                break;
            case "3":
                suffix = "rd";
                break;
        }
    }

    return suffix;
}

Referenz: https://www.aspsnippets.com/Articles/Display-st-nd-rd-and-th-suffix-after-day-numbers-in-Formatted-Dates-using-C-and-VBNet.aspx

Schauen Sie sich humanizr an: https://github.com/Humanizr/Humanizer#date-time-to-ordinal-words

new DateTime(2015, 1, 1).ToOrdinalWords() => "1st January 2015"
new DateTime(2015, 2, 12).ToOrdinalWords() => "12th February 2015"
new DateTime(2015, 3, 22).ToOrdinalWords() => "22nd March 2015"
// for English US locale
new DateTime(2015, 1, 1).ToOrdinalWords() => "January 1st, 2015"
new DateTime(2015, 2, 12).ToOrdinalWords() => "February 12th, 2015"
new DateTime(2015, 3, 22).ToOrdinalWords() => "March 22nd, 2015"

Gleich nach dem Posten wurde mir klar, dass @Gumzle dasselbe vorschlug, aber ich habe seinen Beitrag verpasst, weil er in Codefragmenten vergraben war. Dies ist also seine Antwort mit genügend Code, damit jemand (wie ich), der schnell durchblättert, ihn sehen kann.

Eine weitere Option, bei der das letzte Zeichen verwendet wird:

public static string getDayWithSuffix(int day) {
 string d = day.ToString();
 if (day < 11 || day > 13) {
  if (d.EndsWith("1")) {
   d += "st";
  } else if (d.EndsWith("2")) {
   d += "nd";
  } else if (d.EndsWith("3")) {
   d += "rd";
  } else {
   d += "th";
 } else {
  d += "th";
 }
 return d;
}

In der MSDN-Dokumentation gibt es keinen Hinweis auf eine Kultur, die diese 17 in die 17. umwandeln könnte. Sie sollten dies also manuell über CodeBehind tun. Oder erstellen Sie eine ... Sie könnten eine Funktion erstellen, die dies tut.

public string CustomToString(this DateTime date)
    {
        string dateAsString = string.empty;
        <here wright your code to convert 17 to 17th>
        return dateAsString;
    }