C# 문자열 숫자형식 포맷팅 String.Format ( C# Numberic Formatting )

작성자 admin 작성일자 9th 6월 2017

숫자형식 포맷팅을 이용하면 숫자로 이루어진 문자열을 다양한 형태로 출력 할 수 있습니다.
기본적으로 이 포맷팅은 System. String.Format 매서드에 기반하여 적용됩니다.

형식지정자	종류	예제코드	출력결과
C / c	통화 Currency	Response.Write(string.Format(“{0:C}”, 2.5));	₩3
		Response.Write(string.Format(“{0:C}”, -3.5));	-₩4
D / d	10진법 Decimal	Response.Write(string.Format(“{0:D}”, 00035));	35
				E / e	과학적지수 Scientific	Response.Write(string.Format(“{0:E}”, 342));	3.420000E+02
F / f	고정 소수점 Fixed-point	Response.Write(string.Format(“{0:F2}”, 35.22));	35.22
		Response.Write(string.Format(“{0:F0}”, 35.22));	35
G / g	일반 General	Response.Write(string.Format(“{0:G}”, 123456));	123456
				N / n	숫자 Number	Response.Write(string.Format(“{0:N}”, 25000000));	25,000,000.00
P / p	백분율 Percentage	Response.Write(string.Format(“{0:P}”, .21548));	21.55%
		Response.Write(string.Format(“{0:P1}”, .112345));	11.2%
X / x	16진법 Hexadecimal	Response.Write(string.Format(“{0:X}”, 250));	FA
		Response.Write(string.Format(“{0:X}”, 0xffff));	FFFF

자릿수 고정의 경우 Response.Write(string.Format(“{0:D2}”, 1)); ==>”01″

100

101

102

103

104

105

// This code example demonstrates the String.Format() method.
// Formatting for this example uses the "en-US" culture.
usingSystem;
classSample 
{
    enumColor {Yellow = 1, Blue, Green};
    staticDateTime thisDate = DateTime.Now;
    publicstaticvoidMain() 
    {
// Store the output of the String.Format method in a string.
    strings = "";
    Console.Clear();
// Format a negative integer or floating-point number in various ways.
    Console.WriteLine("Standard Numeric Format Specifiers");
    s = String.Format(
        "(C) Currency: . . . . . . . . {0:C}\n"+
        "(D) Decimal:. . . . . . . . . {0:D}\n"+
        "(E) Scientific: . . . . . . . {1:E}\n"+
        "(F) Fixed point:. . . . . . . {1:F}\n"+
        "(G) General:. . . . . . . . . {0:G}\n"+
        "    (default):. . . . . . . . {0} (default = 'G')\n"+
        "(N) Number: . . . . . . . . . {0:N}\n"+
        "(P) Percent:. . . . . . . . . {1:P}\n"+
        "(R) Round-trip: . . . . . . . {1:R}\n"+
        "(X) Hexadecimal:. . . . . . . {0:X}\n",
        -123, -123.45f); 
    Console.WriteLine(s);
// Format the current date in various ways.
    Console.WriteLine("Standard DateTime Format Specifiers");
    s = String.Format(
        "(d) Short date: . . . . . . . {0:d}\n"+
        "(D) Long date:. . . . . . . . {0:D}\n"+
        "(t) Short time: . . . . . . . {0:t}\n"+
        "(T) Long time:. . . . . . . . {0:T}\n"+
        "(f) Full date/short time: . . {0:f}\n"+
        "(F) Full date/long time:. . . {0:F}\n"+
        "(g) General date/short time:. {0:g}\n"+
        "(G) General date/long time: . {0:G}\n"+
        "    (default):. . . . . . . . {0} (default = 'G')\n"+
        "(M) Month:. . . . . . . . . . {0:M}\n"+
        "(R) RFC1123:. . . . . . . . . {0:R}\n"+
        "(s) Sortable: . . . . . . . . {0:s}\n"+
        "(u) Universal sortable: . . . {0:u} (invariant)\n"+
        "(U) Universal sortable: . . . {0:U}\n"+
        "(Y) Year: . . . . . . . . . . {0:Y}\n", 
        thisDate);
    Console.WriteLine(s);
// Format a Color enumeration value in various ways.
    Console.WriteLine("Standard Enumeration Format Specifiers");
    s = String.Format(
        "(G) General:. . . . . . . . . {0:G}\n"+
        "    (default):. . . . . . . . {0} (default = 'G')\n"+
        "(F) Flags:. . . . . . . . . . {0:F} (flags or integer)\n"+
        "(D) Decimal number: . . . . . {0:D}\n"+
        "(X) Hexadecimal:. . . . . . . {0:X}\n", 
        Color.Green);       
    Console.WriteLine(s);
    }
}
/*
This code example produces the following results:
Standard Numeric Format Specifiers
(C) Currency: . . . . . . . . ($123.00)
(D) Decimal:. . . . . . . . . -123
(E) Scientific: . . . . . . . -1.234500E+002
(F) Fixed point:. . . . . . . -123.45
(G) General:. . . . . . . . . -123
    (default):. . . . . . . . -123 (default = 'G')
(N) Number: . . . . . . . . . -123.00
(P) Percent:. . . . . . . . . -12,345.00 %
(R) Round-trip: . . . . . . . -123.45
(X) Hexadecimal:. . . . . . . FFFFFF85
Standard DateTime Format Specifiers
(d) Short date: . . . . . . . 6/26/2004
(D) Long date:. . . . . . . . Saturday, June 26, 2004
(t) Short time: . . . . . . . 8:11 PM
(T) Long time:. . . . . . . . 8:11:04 PM
(f) Full date/short time: . . Saturday, June 26, 2004 8:11 PM
(F) Full date/long time:. . . Saturday, June 26, 2004 8:11:04 PM
(g) General date/short time:. 6/26/2004 8:11 PM
(G) General date/long time: . 6/26/2004 8:11:04 PM
    (default):. . . . . . . . 6/26/2004 8:11:04 PM (default = 'G')
(M) Month:. . . . . . . . . . June 26
(R) RFC1123:. . . . . . . . . Sat, 26 Jun 2004 20:11:04 GMT
(s) Sortable: . . . . . . . . 2004-06-26T20:11:04
(u) Universal sortable: . . . 2004-06-26 20:11:04Z (invariant)
(U) Universal sortable: . . . Sunday, June 27, 2004 3:11:04 AM
(Y) Year: . . . . . . . . . . June, 2004
Standard Enumeration Format Specifiers
(G) General:. . . . . . . . . Green
    (default):. . . . . . . . Green (default = 'G')
(F) Flags:. . . . . . . . . . Green (flags or integer)
(D) Decimal number: . . . . . 3
(X) Hexadecimal:. . . . . . . 00000003
*/

String Format for DateTime [C#]

This example shows how to format DateTime using String.Format method. All formatting can be done also using DateTime.ToString method.

Custom DateTime Formatting

There are following custom format specifiers y (year), M (month), d (day), h (hour 12), H (hour 24), m (minute), s (second), f (second fraction), F (second fraction, trailing zeroes are trimmed), t (P.M or A.M) and z (time zone).
Following examples demonstrate how are the format specifiers rewritten to the output.
[C#]

// create date time 2008-03-09 16:05:07.123
DateTime dt = new DateTime(2008, 3, 9, 16, 5, 7, 123);
String.Format("{0:y yy yyy yyyy}", dt);  // "8 08 008 2008"   year
String.Format("{0:M MM MMM MMMM}", dt);  // "3 03 Mar March"  month
String.Format("{0:d dd ddd dddd}", dt);  // "9 09 Sun Sunday" day
String.Format("{0:h hh H HH}",     dt);  // "4 04 16 16"      hour 12/24
String.Format("{0:m mm}",          dt);  // "5 05"            minute
String.Format("{0:s ss}",          dt);  // "7 07"            second
String.Format("{0:f ff fff ffff}", dt);  // "1 12 123 1230"   sec.fraction
String.Format("{0:F FF FFF FFFF}", dt);  // "1 12 123 123"    without zeroes
String.Format("{0:t tt}",          dt);  // "P PM"            A.M. or P.M.
String.Format("{0:z zz zzz}",      dt);  // "-6 -06 -06:00"   time zone

You can use also date separator / (slash) and time sepatator : (colon). These characters will be rewritten to characters defined in the current DateTimeFormatInfo.DateSeparator and DateTimeFormatInfo.TimeSeparator.
[C#]

// date separator in german culture is "." (so "/" changes to ".")
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9/3/2008 16:05:07" - english (en-US)
String.Format("{0:d/M/yyyy HH:mm:ss}", dt); // "9.3.2008 16:05:07" - german (de-DE)

Here are some examples of custom date and time formatting:
[C#]

// month/day numbers without/with leading zeroes
String.Format("{0:M/d/yyyy}", dt);            // "3/9/2008"
String.Format("{0:MM/dd/yyyy}", dt);          // "03/09/2008"
// day/month names
String.Format("{0:ddd, MMM d, yyyy}", dt);    // "Sun, Mar 9, 2008"
String.Format("{0:dddd, MMMM d, yyyy}", dt);  // "Sunday, March 9, 2008"
// two/four digit year
String.Format("{0:MM/dd/yy}", dt);            // "03/09/08"
String.Format("{0:MM/dd/yyyy}", dt);          // "03/09/2008"

Standard DateTime Formatting

In DateTimeFormatInfo there are defined standard patterns for the current culture. For example property ShortTimePattern is string that contains value h:mm tt for en-US culture and value HH:mm for de-DE culture.
Following table shows patterns defined in DateTimeFormatInfo and their values for en-US culture. First column contains format specifiers for the String.Format method.

Specifier	DateTimeFormatInfo property	Pattern value (for en-US culture)
`t`	ShortTimePattern	`h:mm tt`
`d`	ShortDatePattern	`M/d/yyyy`
`T`	LongTimePattern	`h:mm:ss tt`
`D`	LongDatePattern	`dddd, MMMM dd, yyyy`
`f`	(combination of `D` and `t`)	`dddd, MMMM dd, yyyy h:mm tt`
`F`	FullDateTimePattern	`dddd, MMMM dd, yyyy h:mm:ss tt`
`g`	(combination of `d` and `t`)	`M/d/yyyy h:mm tt`
`G`	(combination of `d` and `T`)	`M/d/yyyy h:mm:ss tt`
`m`, `M`	MonthDayPattern	`MMMM dd`
`y`, `Y`	YearMonthPattern	`MMMM, yyyy`
`r`, `R`	RFC1123Pattern	`ddd, dd MMM yyyy HH':'mm':'ss 'GMT'` ()*
`s`	SortableDateTimePattern	`yyyy'-'MM'-'dd'T'HH':'mm':'ss` ()*
`u`	UniversalSortableDateTimePattern	`yyyy'-'MM'-'dd HH':'mm':'ss'Z'` ()*
		() = culture independent*

Following examples show usage of standard format specifiers in String.Format method and the resulting output.
[C#]

String.Format("{0:t}", dt);  // "4:05 PM"                         ShortTime
String.Format("{0:d}", dt);  // "3/9/2008"                        ShortDate
String.Format("{0:T}", dt);  // "4:05:07 PM"                      LongTime
String.Format("{0:D}", dt);  // "Sunday, March 09, 2008"          LongDate
String.Format("{0:f}", dt);  // "Sunday, March 09, 2008 4:05 PM"  LongDate+ShortTime
String.Format("{0:F}", dt);  // "Sunday, March 09, 2008 4:05:07 PM" FullDateTime
String.Format("{0:g}", dt);  // "3/9/2008 4:05 PM"                ShortDate+ShortTime
String.Format("{0:G}", dt);  // "3/9/2008 4:05:07 PM"             ShortDate+LongTime
String.Format("{0:m}", dt);  // "March 09"                        MonthDay
String.Format("{0:y}", dt);  // "March, 2008"                     YearMonth
String.Format("{0:r}", dt);  // "Sun, 09 Mar 2008 16:05:07 GMT"   RFC1123
String.Format("{0:s}", dt);  // "2008-03-09T16:05:07"             SortableDateTime
String.Format("{0:u}", dt);  // "2008-03-09 16:05:07Z"            UniversalSortableDateTime