DateTime.ToString ()을 사용할 때 요일 접미사 얻기

DateTime.ToString ()을 사용하여 날짜 형식을 지정할 때 요일 접미사를 포함 할 수 있습니까?

예를 들어 2009 년 7 월 27 일 월요일 형식으로 날짜를 인쇄하고 싶습니다. 그러나 DateTime.ToString ()을 사용하여 찾을 수있는 가장 가까운 예는 2009 년 7 월 27 일 월요일입니다.

DateTime.ToString ()을 사용하여이 작업을 수행 할 수 있습니까? 아니면 내 코드로 돌아 가야합니까?

참고로 저는 항상 SteveX String Formatting 을 사용 / 참조 하며 사용 가능한 변수에 "th"가없는 것처럼 보이지만 다음을 사용하여 문자열을 쉽게 작성할 수 있습니다.

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

그런 다음 1에는 "st", 2에는 "nd", 3에는 "rd", 다른 모든 경우에는 "th"를 제공해야하며 "? :"문으로 인라인 될 수 있습니다.

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"

스위치를 사용하는 또 다른 옵션 :

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

몇 가지 확장 방법 사용 :

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

용법:

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

참고 : 정수 확장 방법은 1에서 31까지가 아닌 모든 숫자에 사용할 수 있습니다. 예 :

return 332211.ToOccurrenceSuffix();
// th

또 다른 옵션은 모듈로 연산자를 사용하는 것입니다 .

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

그런 다음 DateTime 개체를 매개 변수로 전달하여 위의 메서드를 호출합니다 . 예를 들면 다음과 같습니다.

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

DateTime 생성자 에 대한 자세한 내용 은 Microsoft Docs 페이지 를 참조하세요 .

다음은 11 일, 12 일, 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";

완전한 솔루션에 대한 @Lazlow의 답변을 취하면 다음은 예제 사용과 함께 완전히 재사용 가능한 확장 방법입니다.

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

이것을 사용하려면 단순히 DateTime객체 에서 호출하면됩니다 .

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

당신에게 줄 것 :

2016 년 6 월 17 일 금요일

최신 정보

NuGet 패키지 :
https://www.nuget.org/packages/DateTimeToStringWithSuffix

예 :
https://dotnetfiddle.net/zXQX7y

지원 :
.NET Core 1.0 이상
.NET Framework 4.5 이상

Lazlow의 답변을 기초로 (읽기 쉽기 때문에 Lazlow를 선택했습니다) 확장 방법이 있습니다 (모든 사람이 확장 방법을 좋아하기 때문입니다).

단지 일반처럼 작품 ToString()에 대한 방법 DateTime형식이 포함 된 경우 점을 제외 d하거나 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);
}

나는 이것이 111 번째 등과 같은 숫자를 다루는 좋은 해결책이라고 믿습니다.

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

public static String SuffixDate (DateTime date) {문자열 서수;

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

외부 종속성 (이 경우 환상적인 Humanizr .net ) 을 사용하는 데 만족하는 사람들에게는 다음 과 같이 간단합니다.

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

나는 이것을 이렇게했고, 그것은 다른 예에서 주어진 문제의 일부를 우회합니다.

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

저렴하고 유쾌한 VB 솔루션 :

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

여기에서 그 가치는 아래 답변을 사용하는 최종 솔루션입니다.

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

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

humanizr 확인 : 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"

이 글을 올린 직후 @Gumzle이 똑같은 제안을했다는 사실을 깨달았지만 코드 조각에 묻혀서 그의 글을 놓쳤습니다. 그래서 이것은 누군가 (나와 같은) 빠르게 스크롤하여 볼 수있을만큼 충분한 코드가있는 그의 대답입니다.

마지막 문자열 문자를 사용하는 또 다른 옵션 :

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

MSDN 문서에는 17을 17로 변환 할 수있는 문화에 대한 언급이 없습니다. 따라서 코드 숨김을 통해 수동으로 수행하거나 하나를 빌드해야합니다 ... 그렇게하는 함수를 빌드 할 수 있습니다.

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