C# DateTime Format

C# DateTime Format
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 andDateTimeForma-
tInfo.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
ddd, dd MMM yyyy HH':'mm':'ss
r, R RFC1123Pattern
'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
========================
You need help with DateTime format strings in the C# language or
other .NET languages. The framework provides powerful formatting
capabilities, but the syntax is confusing and there are some tricks. Here
we see examples of using DateTime formats, and also the different
values you can get with the individual formats.
Format your DateTimes for your application.

You will not have to write elaborate custom routines.
The .NET Framework has a powerful DateTime format
mechanism.
DateTime format string

Here we see an example of how you can use a specific formatting string
with DateTime and ToString to obtain a special DateTime string. This is
useful when interacting with other systems, or when you require a
precise format.
=== Program that uses DateTime format [C#] ===
using System;
class Program
static void Main()
DateTime time = DateTime.Now; // Use current time
string format = "MMM ddd d HH:mm yyyy"; // Use this format
Console.WriteLine(time.ToString(format)); // Write to console
=== Output of the program ===

Feb Fri 27 11:41 2009
=== Format string pattern ===
MMM display three-letter month
ddd display three-letter day of the WEEK
d display day of the MONTH
HH display two-digit hours on 24-hour scale
mm display two-digit minutes
yyyy display four-digit year
Notes on the letters. The letters in the format string above specify

the output you want to display. The final comment shows what the
MMM, ddd, d, HH, mm, and yyyy will do.
Modify format
Here we see how you can modify the DateTime format string in the
above example to get different output with ToString. We change some
of the fields so the resulting value is shorter.
=== Program that uses different format [C#] ===
using System;
class Program
static void Main()
DateTime time = DateTime.Now; // Use current time
string format = "M d h:mm yy"; // Use this format
Console.WriteLine(time.ToString(format)); // Write to console

}
2 27 11:48 09
=== Format string pattern ===
M display one-digit month number [changed]
d display one-digit day of the MONTH [changed]
h display one-digit hour on 12-hour scale [changed]
mm display two-digit minutes
yy display two-digit year [changed]
Note on format string usages. You will also need to specify a format

string when using DateTime.ParseExact and DateTime.ParseExact. This
is because those methods require a custom pattern to parse.
Single-letter format
Here we see that you can use a single character with ToString or
DateTime.ParseExact to specify a preset format available in the
framework. These are standard formats and very useful in many
programs. They can eliminate typos in the custom format strings.
=== Program that tests formats [C#] ===
using System;
class Program
static void Main()

{
DateTime now = DateTime.Now;
Console.WriteLine(now.ToString("d"));
Console.WriteLine(now.ToString("D"));
Console.WriteLine(now.ToString("f"));
Console.WriteLine(now.ToString("F"));
Console.WriteLine(now.ToString("g"));
Console.WriteLine(now.ToString("G"));
Console.WriteLine(now.ToString("m"));
Console.WriteLine(now.ToString("M"));
Console.WriteLine(now.ToString("o"));
Console.WriteLine(now.ToString("O"));
Console.WriteLine(now.ToString("s"));
Console.WriteLine(now.ToString("t"));
Console.WriteLine(now.ToString("T"));
Console.WriteLine(now.ToString("u"));
Console.WriteLine(now.ToString("U"));
Console.WriteLine(now.ToString("y"));
Console.WriteLine(now.ToString("Y"));
d 2/27/2009
D Friday, February 27, 2009
f Friday, February 27, 2009 12:11 PM

F Friday, February 27, 2009 12:12:22 PM
g 2/27/2009 12:12 PM
G 2/27/2009 12:12:22 PM
m February 27
M February 27
o 2009-02-27T12:12:22.1020000-08:00
O 2009-02-27T12:12:22.1020000-08:00
s 2009-02-27T12:12:22
t 12:12 PM
T 12:12:22 PM
u 2009-02-27 12:12:22Z
U Friday, February 27, 2009 8:12:22 PM
y February, 2009
Y February, 2009
Date strings
Here we see the ToLongDateString, ToLongTimeString,
ToShortDateString, and ToShortTimeString methods on DateTime.
These methods are equivalent to the lowercase and uppercase D and T
methods shown in the example above.
=== Program that uses ToString methods [C#] ===
using System;
class Program
static void Main()

Console.WriteLine(now.ToLongDateString()); // Equivalent to D
Console.WriteLine(now.ToLongTimeString()); // Equivalent to T
Console.WriteLine(now.ToShortDateString()); // Equivalent to d
Console.WriteLine(now.ToShortTimeString()); // Equivalent to t
Console.WriteLine(now.ToString());
ToLongDateString Friday, February 27, 2009
ToLongTimeString 12:16:59 PM
ToShortDateString 2/27/2009
ToShortTimeString 12:16 PM
ToString 2/27/2009 12:16:59 PM
Note on default ToString method. The default ToString method on

DateTime shown above is equivalent to the simple "G" formatting string
in the previous example. In other words, ToString("G") and ToString()
do the same thing.
Format characters
When you use DateTime.ParseExact, or ToString(), you need to specify
a formatting string, which is a sequence of characters that designate
how the final result will look. What follows are my notes on the strings
from MSDN.
See 24-Hour and Military Time Formats.
d
Use this to specify the numeric value for the day of the month.
It will be one or two digits long.
dd
This is the same as a single d, except there are always two
digits, with a leading 0 prepended if necessary.
ddd
This displays a three-letter string that indicates the current day
of the week.
dddd
This displays the full string for the day of the week.
f
ff
fff
ffff
fffff
ffffff
fffffff
F
FF
FFF
FFFF
FFFFF
FFFFFF
FFFFFFF
Use the lowercase f to indicate the seconds to one digit length.
Use two lowercase fs to indicate the seconds to two digits. The
uppercase F patterns do the same but work differently on
trailing zeros.
gg
Use this to display A.D. on your date. It is unlikely that this will
be B.C. in most programs.
h
Display the hours in one digit if possible. If the hours is greater
than 9, it will display two digits. Range is 1-12.
hh
Display the hours in two digits always, even if the hour is one
digit. The range here will be 01-12.
H
This represents the hours in a range of 0-23, which is called
military time in some parts of the world.
HH
This represents the hours in a range of 00-23. The only
different here between the single H is that there is always a
leading zero if the number is one digit.
K
Use this to display time zone information.
m
mm
This formats the minutes in your date format string. Here, the
one m means that there is only one digit displayed if possible.
The two ms means that there are always two digits displayed,
with a leading zero if necessary.
M
MM
These display the months in numeric form. The one uppercase
M does not have a leading zero on it. The two uppercase Ms
will format a number with a leading zero if it is required.
MMM
This displays the abbreviated three-letter form of the month
represented in the DateTime.
MMMM
This displays the full month string, properly capitalized.
s
ss
The lowercase s displays seconds. A single lowercase s means
that you do not require a leading zero. Two lowercase s
characters means you always want two digits, such as 00-59.
t
Use the lowercase t to indicate A, when the time is in the AM,
and P, for when the time is in PM.
tt
Use two lowercase tts to display the full AM or PM string. You
will normally want this for when you are displaying the string to
a user.
y
yy
yyy
yyyy
yyyyy
These display the year to different digits. In your programs,
you won't need three digits for the year, or five. Therefore, you
should only consider one y, two ys, or four ys.
z
zz
zzz
These represent the offset from the UTC time on the local
operating system.
:
This is the time separator.
/
This is the date separator.
Difference between d and dd, ddd and dddd. It is important to note

that d and dd (one and two ds) mean something entirely different than
ddd and dddd (three and four ds). d and dd indicate the day of the
month, while ddd and dddd indicate the day of the week, in a word.
Three-letter days
In some systems it may be useful to display the day of the week in a
three-letter form. Here we see a simple program that prints out the
days of the week in three-letter format. This will vary based on the
language installed on the computer.
=== Program that tests days [C#] ===

using System;
class Program
static void Main()
DateTime now = DateTime.Today;
for (int i = 0; i < 7; i++)
Console.WriteLine(now.ToString("ddd"));
now = now.AddDays(1);
Thu
Fri
Sat
Sun
Mon
Tue
Wed
Display complete day

Often you need to display the complete day of the week in your C#
code, and the four ds together will do this for you. This simple program
shows all seven different day strings you can get from the dddd.
=== Program that shows day strings [C#] ===
using System;
class Program
static void Main()
DateTime now = DateTime.Today;
for (int i = 0; i < 7; i++)
Console.WriteLine(now.ToString("dddd"));
now = now.AddDays(1);
Thursday
Friday
Saturday
Sunday
Monday
Tuesday
Wednesday
Display the era
The .NET platform allows you to display the date with the era or period,
which is usually A.D. or B.C. It is unlikely that you will need to use B.C.,
except in a rare theoretical application. Nevertheless, here is what the
two gs will print. Use the code "DateTime.Now.ToString("gg");".
Month format
You may need to display the month name in a three-letter format. This
is equivalent, in English, to taking a substring of the first three letters,
but using the three Ms next to each other may be easier and more terse
for your code. Additionally, you may want full month strings. This site
contains a useful article that covers DateTime month strings and the
Month property in more detail.
See DateTime.Month Property.
Display AM/PM
This isn't something you are likely to need, but interesting to find out.
When you specify one t, you can get the first letter of the AM or PM
string. This is equivalent to using Substring or getting the first char of
the tt string. There is a space at the end of the format string because
the value "t" can mean something else in the format string.
Full string. Here we see how you can get the string AM or PM in your
DateTime ToString code. The code adds 12 to ensure the second
iteration is in the other half.
=== Program that displays AM and PM [C#] ===
using System;
class Program
static void Main()
for (int i = 0; i < 2; i++)

{
Console.WriteLine(now.ToString("tt "));
now = now.AddHours(12);
PM
AM
Note on lack of periods. There are no periods in the output of tt in

the example above. Therefore, if you require periods in your AM or PM,
you would have to manipulate the string.
Display year
You can vary the number of digits displayed in the year string. You will
always want to use y, yy, or yyyy for your programs. The framework
accepts different numbers, but they are impractical in the real world.
Occasionally two ys is useful for a user-oriented program, but for your
back end code, you will want to use four ys. You do not need uppercase
Ys.
=== Program that displays years [C#] ===
using System;
class Program
static void Main()
{
Console.WriteLine(now.ToString("y "));
Console.WriteLine(now.ToString("yy"));
Console.WriteLine(now.ToString("yyy")); // <-- Don't use this
Console.WriteLine(now.ToString("yyyy"));
Console.WriteLine(now.ToString("yyyyy")); // <-- Don't use this
09
2009
2009
02009
Standard Date and Time Format Strings

.NET Framework 4
Other Versions
Updated: July 2010

A standard date and time format string uses a single format specifier to define the text representation of a date
and time value. Any date and time format string that contains more than one character, including white space, is
interpreted as a custom date and time format string; for more information, see Custom Date and Time Format
Strings. A standard or custom format string can be used in two ways:
• To define the string that results from a formatting operation.
• To define the text representation of a date and time value that can be converted to
a DateTime or DateTimeOffset value by a parsing operation.
Note
Standard date and time format strings can be used with
both DateTime and DateTimeOffset values.
The following table describes the standard date and time format specifiers. Unless otherwise noted,
a particular standard date and time format specifier produces an identical string representation
regardless of whether it is used with a DateTime or a DateTimeOffset value. See the Notes section
for additional information about using standard date and time format strings.
Format
Description Examples
specifier
6/15/2009 1:45:30 PM -> 6/15/2009 (en-

US)
Short date pattern.
6/15/2009 1:45:30 PM -> 15/06/2009 (fr-
"d" More information: The Short Date
FR)
("d") Format Specifier.
6/15/2009 1:45:30 PM -> 2009/06/15 (ja-
JP)
6/15/2009 1:45:30 PM -> Monday, June 15,
2009 (en-US)
Long date pattern.
6/15/2009 1:45:30 PM -> 15 июня 2009 г.
"D" More information: The Long Date
(ru-RU)
("D") Format Specifier.
6/15/2009 1:45:30 PM -> Montag, 15. Juni
2009 (de-DE)
6/15/2009 1:45:30 PM -> Monday, June 15,
2009 1:45 PM (en-US)
Full date/time pattern (short time).
6/15/2009 1:45:30 PM -> den 15 juni 2009
"f" More information: The Full Date
13:45 (sv-SE)
Short Time ("f") Format Specifier.
6/15/2009 1:45:30 PM -> Δευτέρα, 15
Ιουνίου 2009 1:45 μμ (el-GR)
6/15/2009 1:45:30 PM -> Monday, June 15,
2009 1:45:30 PM (en-US)
Full date/time pattern (long time).
6/15/2009 1:45:30 PM -> den 15 juni 2009
"F" More information: The Full Date
13:45:30 (sv-SE)
Long Time ("F") Format Specifier.
6/15/2009 1:45:30 PM -> Δευτέρα, 15
Ιουνίου 2009 1:45:30 μμ (el-GR)
6/15/2009 1:45:30 PM -> 6/15/2009 1:45
General date/time pattern (short PM (en-US)
time). 6/15/2009 1:45:30 PM -> 15/06/2009 13:45
"g"
More information: The General Date (es-ES)
Short Time ("g") Format Specifier. 6/15/2009 1:45:30 PM -> 2009/6/15 13:45
(zh-CN)
6/15/2009 1:45:30 PM -> 6/15/2009
General date/time pattern (long 1:45:30 PM (en-US)
time). 6/15/2009 1:45:30 PM -> 15/06/2009
"G"
More information: The General Date 13:45:30 (es-ES)
Long Time ("G") Format Specifier. 6/15/2009 1:45:30 PM -> 2009/6/15
13:45:30 (zh-CN)
"M", "m" Month/day pattern. 6/15/2009 1:45:30 PM -> June 15 (en-US)
More information: The Month ("M", 6/15/2009 1:45:30 PM -> 15. juni (da-DK)
"m") Format Specifier. 6/15/2009 1:45:30 PM -> 15 Juni (id-ID)
Round-trip date/time pattern.
6/15/2009 1:45:30 PM -> 2009-06-
"O", "o" More information: The Round-trip
15T13:45:30.0900000
("O", "o") Format Specifier.
RFC1123 pattern.
6/15/2009 1:45:30 PM -> Mon, 15 Jun 2009
"R", "r" More information: The RFC1123
20:45:30 GMT
("R", "r") Format Specifier.
Sortable date/time pattern.
6/15/2009 1:45:30 PM -> 2009-06-
"s" More information: The Sortable
15T13:45:30
("s") Format Specifier.
Short time pattern. 6/15/2009 1:45:30 PM -> 1:45 PM (en-US)
"t" More information: The Short Time 6/15/2009 1:45:30 PM -> 13:45 (hr-HR)
("t") Format Specifier. 6/15/2009 1:45:30 PM -> 01:45 ‫( م‬ar-EG)
6/15/2009 1:45:30 PM -> 1:45:30 PM (en-
Long time pattern. US)
"T" More information: The Long Time 6/15/2009 1:45:30 PM -> 13:45:30 (hr-HR)
("T") Format Specifier. 6/15/2009 1:45:30 PM -> 01:45:30 ‫( م‬ar-
EG)
Universal sortable date/time pattern.
6/15/2009 1:45:30 PM -> 2009-06-15
"u" More information: The Universal
20:45:30Z
Sortable ("u") Format Specifier.
6/15/2009 1:45:30 PM -> Monday, June 15,
2009 8:45:30 PM (en-US)
Universal full date/time pattern.
6/15/2009 1:45:30 PM -> den 15 juni 2009
"U" More information: The Universal
20:45:30 (sv-SE)
Full ("U") Format Specifier.
6/15/2009 1:45:30 PM -> Δευτέρα, 15
Ιουνίου 2009 8:45:30 μμ (el-GR)
6/15/2009 1:45:30 PM -> June, 2009 (en-
Year month pattern. US)
"Y", "y" More information: The Year Month 6/15/2009 1:45:30 PM -> juni 2009 (da-
("Y") Format Specifier. DK)
6/15/2009 1:45:30 PM -> Juni 2009 (id-ID)
Any other
Unknown specifier. Throws a run-time FormatException.
single character
How Standard Format Strings Work
In a formatting operation, a standard format string is simply an alias for a custom format string. The
advantage of using an alias to refer to a custom format string is that, although the alias remains
invariant, the custom format string itself can vary. This is important because the string
representations of date and time values typically vary by culture. For example, the "d" standard
format string indicates that a date and time value is to be displayed using a short date pattern. For
the invariant culture, this pattern is "MM/dd/yyyy". For the fr-FR culture, it is "dd/MM/yyyy". For
the ja-JP culture, it is "yyyy/MM/dd".
If a standard format string in a formatting operation maps to a particular culture's custom format string, your
application can define the specific culture whose custom format strings are used in one of these ways:
• You can use the default (or current) culture. The following example displays a date using the current
culture's short date format. In this case, the current culture is en-US.
VB
C#
C++
F#
JScript
Copy
// Display using current (en-us) culture's short date format

DateTime thisDate = new DateTime(2008, 3, 15);
Console.WriteLine(thisDate.ToString("d")); // Displays 3/15/2008
• You can pass a CultureInfo object representing the culture whose formatting is to be used to a method
that has an IFormatProvider parameter. The following example displays a date using the short date
format of the pt-BR culture.
VB
C#
C++
F#
JScript
Copy
// Display using pt-BR culture's short date format

CultureInfo culture = new CultureInfo("pt-BR");
Console.WriteLine(thisDate.ToString("d", culture)); // Displays 15/3/2008
• You can pass a DateTimeFormatInfo object that provides formatting information to a method that has
an IFormatProvider parameter. The following example displays a date using the short date format from
a DateTimeFormatInfo object for the hr-HR culture.
VB
C#
C++
F#
JScript
Copy
// Display using date format information from hr-HR culture

DateTimeFormatInfo fmt = (new CultureInfo("hr-HR")).DateTimeFormat;
Console.WriteLine(thisDate.ToString("d", fmt)); // Displays 15.3.2008
In some cases, the standard format string serves as a convenient abbreviation for a longer custom format string
that is invariant. Four standard format strings fall into this category: "O" (or "o"), "R" (or "r"), "s", and "u". These
strings correspond to custom format strings defined by the invariant culture. They produce string
representations of date and time values that are intended to be identical across cultures. The following table
provides information on these four standard date and time format strings.
Standard format Defined by DateTimeFormatInfo.InvariantInfo
Custom format string
string property
yyyy'-'MM'-'dd'T'HH':'mm'
"O" or "o" None
:'ss'.'fffffffzz
ddd, dd MMM yyyy
"R" or "r" RFC1123Pattern
HH':'mm':'ss 'GMT'
yyyy'-'MM'-'dd'T'HH':'mm'
"s" SortableDateTimePattern
:'ss
yyyy'-'MM'-'dd
"u" UniversalSortableDateTimePattern
HH':'mm':'ss'Z'
Standard format strings can also be used in parsing operations with
the DateTime.ParseExact or DateTimeOffset.ParseExact methods, which require an input string to exactly
conform to a particular pattern for the parse operation to succeed. Many standard format strings map to
multiple custom format strings, so a date and time value can be represented in a variety of formats and the
parse operation will still succeed. You can determine the custom format string or strings that correspond to a
standard format string by calling the DateTimeFormatInfo.GetAllDateTimePatterns(Char) method. The following
example displays the custom format strings that map to the "d" (short date pattern) standard format string.
VB
C#
C++
F#
JScript
Copy
using System;
using System.Globalization;
public class Example

{
public static void Main()
{
Console.WriteLine("'d' standard format string:");
foreach (var customString in
DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns('d'))
Console.WriteLine(" {0}", customString);
}
}
// The example displays the following output:
// 'd' standard format string:
// M/d/yyyy
// M/d/yy
// MM/dd/yy
// MM/dd/yyyy
// yy/MM/dd
// yyyy-MM-dd
// dd-MMM-yy
The following sections describe the standard format specifiers for DateTime and DateTimeOffset values.
The Short Date ("d") Format Specifier

The "d" standard format specifier represents a custom date and time format string that is defined by
a specific culture's DateTimeFormatInfo.ShortDatePattern property. For example, the custom
format string that is returned by the ShortDatePattern property of the invariant culture is
"MM/dd/yyyy".
The following table lists the DateTimeFormatInfo object properties that control the formatting of the returned
string.
Property Description
ShortDatePattern Defines the overall format of the result string.

Defines the string that separates the year, month, and day components of a
DateSeparator
date.
The following example uses the "d" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy
DateTime date1 = new DateTime(2008,4, 10);

Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008
Console.WriteLine(date1.ToString("d",
CultureInfo.CreateSpecificCulture("en-US")));
// Displays 4/10/2008
CultureInfo.CreateSpecificCulture("en-NZ")));
// Displays 10/04/2008
CultureInfo.CreateSpecificCulture("de-DE")));
// Displays 10.04.2008
Back to table
The Long Date ("D") Format Specifier
The "D" standard format specifier represents a custom date and time format string that is defined by
the current DateTimeFormatInfo.LongDatePattern property. For example, the custom format string
for the invariant culture is "dddd, dd MMMM yyyy".
The following table lists the properties of the DateTimeFormatInfo object that control the formatting of the
returned string.
LongDatePattern Defines the overall format of the result string.

DayNames Defines the localized day names that can appear in the result string.
Defines the localized month names that can appear in the result
MonthNames
string.
The following example uses the "D" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy
DateTime date1 = new DateTime(2008, 4, 10);

Console.WriteLine(date1.ToString("D",
// Displays Thursday, April 10, 2008
CultureInfo.CreateSpecificCulture("pt-BR")));
// Displays quinta-feira, 10 de abril de 2008
CultureInfo.CreateSpecificCulture("es-MX")));
// Displays jueves, 10 de abril de 2008
Back to table
The Full Date Short Time ("f") Format Specifier
The "f" standard format specifier represents a combination of the long date ("D") and short time
("t") patterns, separated by a space.
The result string is affected by the formatting information of a specific DateTimeFormatInfo object. The
following table lists the DateTimeFormatInfo object properties that may control the formatting of the returned
string. The custom format specifier returned by
the DateTimeFormatInfo.LongDatePattern and DateTimeFormatInfo.ShortTimePatternproperties of some
cultures may not make use of all properties.
LongDatePattern Defines the format of the date component of the result string.
ShortTimePattern Defines the format of the time component of the result string.
MonthNames Defines the localized month names that can appear in the result string.
Defines the string that separates the hour, minute, and second components of a
TimeSeparator
time.
Defines the string that indicates times from midnight to before noon in a 12-
AMDesignator
hour clock.
Defines the string that indicates times from noon to before midnight in a 12-
PMDesignator
hour clock.
The following example uses the "f" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy
DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);

Console.WriteLine(date1.ToString("f",
// Displays Thursday, April 10, 2008 6:30 AM
Console.WriteLine(date1.ToString("f",
CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30
Back to table
The Full Date Long Time ("F") Format Specifier
The "F" standard format specifier represents a custom date and time format string that is defined by
the current DateTimeFormatInfo.FullDateTimePattern property. For example, the custom format
string for the invariant culture is "dddd, dd MMMM yyyy HH:mm:ss".
The following table lists the DateTimeFormatInfo object properties that may control the formatting of the
returned string. The custom format specifier that is returned by theFullDateTimePattern property of some
FullDateTimePattern Defines the overall format of the result string.

Defines the string that separates the hour, minute, and second components of
TimeSeparator
a time.
AMDesignator
hour clock.
PMDesignator
hour clock.
The following example uses the "F" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("F",
// Displays Thursday, April 10, 2008 6:30:00 AM
Console.WriteLine(date1.ToString("F",
// Displays jeudi 10 avril 2008 06:30:00
Back to table
The General Date Short Time ("g") Format Specifier
The "g" standard format specifier represents a combination of the short date ("d") and short time
("t") patterns, separated by a space.
string. The custom format specifier that is returned by
the DateTimeFormatInfo.ShortDatePattern andDateTimeFormatInfo.ShortTimePattern properties of some
ShortDatePattern Defines the format of the date component of the result string.
DateSeparator Defines the string that separates the year, month, and day components of a date.
TimeSeparator
time.
AMDesignator
hour clock.
PMDesignator
hour clock.
The following example uses the "g" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("g",
DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30
CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30 AM
CultureInfo.CreateSpecificCulture("fr-BE")));
// Displays 10/04/2008 6:30
Back to table
The General Date Long Time ("G") Format Specifier

The "G" standard format specifier represents a combination of the short date ("d") and long time
("T") patterns, separated by a space.
string. The custom format specifier that is returned by
the DateTimeFormatInfo.ShortDatePattern andDateTimeFormatInfo.LongTimePattern properties of some
ShortDatePattern Defines the format of the date component of the result string.
LongTimePattern Defines the format of the time component of the result string.
DateSeparator Defines the string that separates the year, month, and day components of a date.
TimeSeparator
time.
AMDesignator
hour clock.
PMDesignator
hour clock.
The following example uses the "G" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("G",
DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30:00
// Displays 4/10/2008 6:30:00 AM
CultureInfo.CreateSpecificCulture("nl-BE")));
// Displays 10/04/2008 6:30:00
Back to table
The Month ("M", "m") Format Specifier
The "M" or "m" standard format specifier represents a custom date and time format string that is
defined by the current DateTimeFormatInfo.MonthDayPattern property. For example, the custom
format string for the invariant culture is "MMMM dd".
string.
MonthDayPattern Defines the overall format of the result string.
MonthNames
string.
The following example uses the "m" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("m",
// Displays April 10
Console.WriteLine(date1.ToString("m",
CultureInfo.CreateSpecificCulture("ms-MY")));
// Displays 10 April
Back to table
The Round-trip ("O", "o") Format Specifier
The "O" or "o" standard format specifier represents a custom date and time format string using a
pattern that preserves time zone information. For DateTime values, this format specifier is designed
to preserve date and time values along with the DateTime.Kind property in text. The formatted
string can be parsed back by using theDateTime.Parse(String, IFormatProvider,
DateTimeStyles) or DateTime.ParseExact method if the styles parameter is set
to DateTimeStyles.RoundtripKind.
The "O" or "o" standard format specifier corresponds to the "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK" custom
format string for DateTime values and to the "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffzzz" custom format string
for DateTimeOffset values. In this string, the pairs of single quotation marks that delimit individual characters,
such as the hyphens, the colons, and the letter "T", indicate that the individual character is a literal that cannot
be changed. The apostrophes do not appear in the output string.
The pattern for this specifier reflects a defined standard (ISO 8601). Therefore, it is always the same regardless of
the culture used or the format provider supplied. Strings that are passed to the Parse or ParseExact method
must conform exactly to this custom format pattern, or a FormatException is thrown.
When this standard format specifier is used, the formatting or parsing operation always uses the invariant
culture.
The following example uses the "o" format specifier to display a DateTime and a DateTimeOffset value on a
system in the U.S. Pacific Time zone.
VB
C#
C++
F#
JScript
Copy

DateTimeOffset dateOffset = new DateTimeOffset(date1,
TimeZoneInfo.Local.GetUtcOffset(date1));
Console.WriteLine(date1.ToString("o"));
// Displays 2008-04-10T06:30:00.0000000
Console.WriteLine(dateOffset.ToString("o"));
// Displays 2008-04-10T06:30:00.0000000-07:00
The following example uses the "o" format specifier to create a formatted string, and then restores the original
date and time value by calling a date and time Parse method.
VB
C#
C++
F#
JScript
Copy
// Round-trip DateTime values.

DateTime originalDate, newDate;
string dateString;
// Round-trip a local time.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 10, 6, 30, 0),
DateTimeKind.Local);
dateString = originalDate.ToString("o");
newDate = DateTime.Parse(dateString, null, DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind,
newDate, newDate.Kind);
// Round-trip a UTC time.
DateTimeKind.Utc);
// Round-trip time in an unspecified time zone.
DateTimeKind.Unspecified);
// Round-trip a DateTimeOffset value.

DateTimeOffset originalDTO = new DateTimeOffset(2008, 4, 12, 9, 30, 0, new TimeSpan(-8,
0, 0));
dateString = originalDTO.ToString("o");
DateTimeOffset newDTO = DateTimeOffset.Parse(dateString, null,
DateTimeStyles.RoundtripKind);
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO);
// Round-tripped 4/10/2008 6:30:00 AM Local to 4/10/2008 6:30:00 AM Local.
// Round-tripped 4/12/2008 9:30:00 AM Utc to 4/12/2008 9:30:00 AM Utc.
// Round-tripped 4/13/2008 12:30:00 PM Unspecified to 4/13/2008 12:30:00 PM
Unspecified.
// Round-tripped 4/12/2008 9:30:00 AM -08:00 to 4/12/2008 9:30:00 AM -08:00.
Back to table
The RFC1123 ("R", "r") Format Specifier
The "R" or "r" standard format specifier represents a custom date and time format string that is
defined by the DateTimeFormatInfo.RFC1123Pattern property. The pattern reflects a defined
standard, and the property is read-only. Therefore, it is always the same, regardless of the culture
used or the format provider supplied. The custom format string is "ddd, dd MMM yyyy
HH':'mm':'ss 'GMT'". When this standard format specifier is used, the formatting or parsing
operation always uses the invariant culture.
The result string is affected by the following properties of the DateTimeFormatInfo object returned by
the DateTimeFormatInfo.InvariantInfo property that represents the invariant culture.
RFC1123Pattern Defines the format of the result string.

AbbreviatedDayNames Defines the abbreviated day names that can appear in the result string.
Defines the abbreviated month names that can appear in the result
AbbreviatedMonthNames
string.
Although the RFC 1123 standard expresses a time as Coordinated Universal Time (UTC), the formatting
operation does not modify the value of the DateTime or DateTimeOffsetobject that is being formatted.
Therefore, the application must convert the date and time value to UTC before it performs the formatting
operation. To perform this conversion,DateTime values can call the DateTime.ToUniversalTime method,
and DateTimeOffset values can call the ToUniversalTime method.
The following example uses the "r" format specifier to display a DateTime and a DateTimeOffset value on a
VB
C#
C++
F#
JScript
Copy

DateTimeOffset dateOffset = new DateTimeOffset(date1,
TimeZoneInfo.Local.GetUtcOffset(date1));
Console.WriteLine(date1.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Console.WriteLine(dateOffset.ToUniversalTime().ToString("r"));
// Displays Thu, 10 Apr 2008 13:30:00 GMT
Back to table
The Sortable ("s") Format Specifier
The "s" standard format specifier represents a custom date and time format string that is defined by
the DateTimeFormatInfo.SortableDateTimePattern property. The pattern reflects a defined standard
(ISO 8601), and the property is read-only. Therefore, it is always the same, regardless of the culture
used or the format provider supplied. The custom format string is "yyyy'-'MM'-'dd'T'HH':'mm':'ss".
When this standard format specifier is used, the formatting or parsing operation always uses the invariant
culture.
The following example uses the "s" format specifier to display a DateTime and a DateTimeOffset value on a
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("s"));
// Displays 2008-04-10T06:30:00
Back to table
The Short Time ("t") Format Specifier
The "t" standard format specifier represents a custom date and time format string that is defined by
the current DateTimeFormatInfo.ShortTimePattern property. For example, the custom format string
for the invariant culture is "HH:mm".
string. The custom format specifier that is returned by the DateTimeFormatInfo.ShortTimePattern property of
some cultures may not make use of all properties.
TimeSeparator
time.
AMDesignator
hour clock.
PMDesignator
hour clock.
The following example uses the "t" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("t",
// Displays 6:30 AM
Console.WriteLine(date1.ToString("t",
CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30
Back to table
The Long Time ("T") Format Specifier
The "T" standard format specifier represents a custom date and time format string that is defined by
a specific culture's DateTimeFormatInfo.LongTimePattern property. For example, the custom
format string for the invariant culture is "HH:mm:ss".
returned string. The custom format specifier that is returned by
theDateTimeFormatInfo.LongTimePattern property of some cultures may not make use of all properties.
LongTimePattern Defines the format of the time component of the result string.
TimeSeparator
time.
AMDesignator
hour clock.
PMDesignator
hour clock.
The following example uses the "T" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("T",
// Displays 6:30:00 AM
Console.WriteLine(date1.ToString("T",
CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30:00
Back to table
The Universal Sortable ("u") Format Specifier

The "u" standard format specifier represents a custom date and time format string that is defined by
the DateTimeFormatInfo.UniversalSortableDateTimePattern property. The pattern reflects a defined
standard, and the property is read-only. Therefore, it is always the same, regardless of the culture
used or the format provider supplied. The custom format string is "yyyy'-'MM'-'dd HH':'mm':'ss'Z'".
When this standard format specifier is used, the formatting or parsing operation always uses the
invariant culture.
Although the result string should express a time as Coordinated Universal Time (UTC), no conversion of the
original DateTime or DateTimeOffset value is performed during the formatting operation. Therefore, the
application must convert the date and time value to UTC before formatting it. To perform this
conversion, DateTime values can call theDateTime.ToUniversalTime method, and DateTimeOffset values can call
the ToUniversalTime method
The following example uses the "u" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToUniversalTime().ToString("u"));
// Displays 2008-04-10 13:30:00Z
Back to table
The Universal Full ("U") Format Specifier
The "U" standard format specifier represents a custom date and time format string that is defined by
a specified culture's DateTimeFormatInfo.FullDateTimePattern property. The pattern is the same as
the "F" pattern. However, the DateTime value is automatically converted to UTC before it is
formatted.
returned string. The custom format specifier that is returned by theFullDateTimePattern property of some
FullDateTimePattern Defines the overall format of the result string.

Defines the string that separates the hour, minute, and second components of
TimeSeparator
a time.
AMDesignator
hour clock.
PMDesignator
hour clock.
The "U" format specifier is not supported by the DateTimeOffset type and throws a FormatException if it is used
to format a DateTimeOffset value.
The following example uses the "U" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("U",
// Displays Thursday, April 10, 2008 1:30:00 PM
Console.WriteLine(date1.ToString("U",
CultureInfo.CreateSpecificCulture("sv-FI")));
// Displays den 10 april 2008 13:30:00
Back to table
The Year Month ("Y", "y") Format Specifier
The "Y" or "y" standard format specifier represents a custom date and time format string that is
defined by the DateTimeFormatInfo.YearMonthPattern property of a specified culture. For
example, the custom format string for the invariant culture is "yyyy MMMM".
string.
YearMonthPattern Defines the overall format of the result string.

MonthNames
string.
The following example uses the "y" format specifier to display a date and time value.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("Y",
// Displays April, 2008
Console.WriteLine(date1.ToString("y",
CultureInfo.CreateSpecificCulture("af-ZA")));
// Displays April 2008
Back to table
To customize the format of date or time you can pass appropriate format string
to ToString function.
Different types of Time formats that are commonly used in ASP.Net 2.0 are:
13:39:21.0363750
1:39 PM
13:39 21 PM
01:39 21 PM
1339
DateTime Format Examples:

You can see the live samples and examples of C# DateTime format from the following links:
• Time Formats using ToString Function
• Date Formats using ToString Function
• Convert String to DateTime
• DateTime Parse and ParseExact using IFormatProvider
C# Functions to format the server Time String

C# Time Formats:
C# Code Example 1:
Response.Write(DateTime.Now.TimeOfDay);
Output: 13:39:21.0363750

C# Code Example 2:
Response.Write(DateTime.Now.ToShortTimeString());
Output: 1:39 PM

C# Code Example 3:
Response.Write(DateTime.Now.ToString("HH:mm ss tt"));
Output: 13:39 21 PM
Note: To format the time in 24H format you can use the capital HH to display the hours, mm to
display the minutes, ss to display theseconds and tt for AM/PM.

C# Code Example 4:
Response.Write(DateTime.Now.ToString("hh:mm ss tt"));
Output: 01:39 21 PM
Note: To format the time into short string type, you can use the lower case hh to display
the hours.

C# Code Example 5:
Response.Write(DateTime.Now.ToString("HHmm"));
Output: 1339
Note: To display the time in hours format, just use HHmm without separators.
.NET Framework 4
Other Versions
Represents an instant in time, typically expressed as a date and time of day.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)
Syntax
VB
C#
C++
F#
JScript
Copy
[SerializableAttribute]
public struct DateTime : IComparable, IFormattable,
IConvertible, ISerializable, IComparable<DateTime>, IEquatable<DateTime>
The DateTime type exposes the following members.
Constructors
Name Description
Initializes a new instance of the DateTime structure to a
DateTime(Int64)
specified number of ticks.
Initializes a new instance of the DateTime structure to a
DateTime(Int64,
specified number of ticks and to Coordinated Universal Time
DateTimeKind)
(UTC) or local time.
DateTime(Int32, Int32, Initializes a new instance of the DateTime structure to the

Int32) specified year, month, and day.

Int32, Calendar) specified year, month, and day for the specified calendar.

Int32, Int32, Int32, Int32) specified year, month, day, hour, minute, and second.
Int32, Int32, Int32, Int32, specified year, month, day, hour, minute, second, and
DateTimeKind) Coordinated Universal Time (UTC) or local time.
Int32, Int32, Int32, Int32, specified year, month, day, hour, minute, and second for the
Calendar) specified calendar.
Int32) millisecond.
Int32, Int32, Int32, Int32, specified year, month, day, hour, minute, second, millisecond,
Int32, DateTimeKind) and Coordinated Universal Time (UTC) or local time.
Int32, Calendar) millisecond for the specified calendar.
Int32, Int32, Int32, Int32, specified year, month, day, hour, minute, second, millisecond,

Int32, Calendar, and Coordinated Universal Time (UTC) or local time for the
DateTimeKind) specified calendar.
Top
Properties
Name Description
Date Gets the date component of this instance.
Day Gets the day of the month represented by this instance.
DayOfWeek Gets the day of the week represented by this instance.
DayOfYear Gets the day of the year represented by this instance.
Hour Gets the hour component of the date represented by this instance.
Gets a value that indicates whether the time represented by this instance is
Kind
based on local time, Coordinated Universal Time (UTC), or neither.
Millisecond Gets the milliseconds component of the date represented by this instance.
Minute Gets the minute component of the date represented by this instance.
Month Gets the month component of the date represented by this instance.
Gets a DateTime object that is set to the current date and time on this
Now
computer, expressed as the local time.
Second Gets the seconds component of the date represented by this instance.
Ticks Gets the number of ticks that represent the date and time of this instance.
TimeOfDay Gets the time of day for this instance.
Today Gets the current date.
Gets a DateTime object that is set to the current date and time on this
UtcNow
computer, expressed as the Coordinated Universal Time (UTC).
Year Gets the year component of the date represented by this instance.
Top
Methods
Name Description
Returns a new DateTime that adds the value of the
Add
specified TimeSpan to the value of this instance.
Returns a new DateTime that adds the specified number of
AddDays
days to the value of this instance.
AddHours
hours to the value of this instance.
AddMilliseconds
milliseconds to the value of this instance.
AddMinutes
minutes to the value of this instance.
AddMonths
months to the value of this instance.
AddSeconds
seconds to the value of this instance.
AddTicks
ticks to the value of this instance.
AddYears
years to the value of this instance.
Compares two instances of DateTime and returns an integer
Compare that indicates whether the first instance is earlier than, the same
as, or later than the second instance.
Compares the value of this instance to a
specified DateTime value and returns an integer that indicates
CompareTo(DateTime)
whether this instance is earlier than, the same as, or later than
the specified DateTime value.
Compares the value of this instance to a specified object that
contains a specified DateTime value, and returns an integer
CompareTo(Object)
that indicates whether this instance is earlier than, the same as,
or later than the specified DateTime value.
DaysInMonth Returns the number of days in the specified month and year.
Returns a value indicating whether this instance is equal to the
Equals(DateTime)
specified DateTime instance.
Returns a value indicating whether this instance is equal to a
Equals(Object)
specified object. (Overrides ValueType.Equals(Object).)
Equals(DateTime, Returns a value indicating whether two instances

DateTime) of DateTime are equal.
Allows an object to try to free resources and perform other
Finalize cleanup operations before it is reclaimed by garbage
collection. (Inherited from Object.)
Deserializes a 64-bit binary value and recreates an original
FromBinary
serialized DateTime object.
Converts the specified Windows file time to an equivalent local
FromFileTime
time.
Converts the specified Windows file time to an equivalent
FromFileTimeUtc
UTC time.
Returns a DateTime equivalent to the specified OLE
FromOADate
Automation Date.
Converts the value of this instance to all the string
GetDateTimeFormats() representations supported by the standard date and time format
specifiers.
GetDateTimeFormats(Ch
representations supported by the specified standard date and
ar)
time format specifier.
GetDateTimeFormats(IF representations supported by the standard date and time format

ormatProvider) specifiers and the specified culture-specific formatting
information.
GetDateTimeFormats(Ch representations supported by the specified standard date and

ar, IFormatProvider) time format specifier and culture-specific formatting
information.
Returns the hash code for this
GetHashCode
instance. (Overrides ValueType.GetHashCode().)
GetType Gets the Type of the current instance. (Inherited from Object.)
GetTypeCode Returns the TypeCode for value type DateTime.
Indicates whether this instance of DateTime is within the
IsDaylightSavingTime
daylight saving time range for the current time zone.
IsLeapYear Returns an indication whether the specified year is a leap year.
Creates a shallow copy of the current Object. (Inherited
MemberwiseClone
from Object.)
Converts the specified string representation of a date and time
Parse(String)
to its DateTime equivalent.
Parse(String,
to its DateTime equivalent using the specified culture-specific
IFormatProvider)
format information.
Parse(String, Converts the specified string representation of a date and time
IFormatProvider, to its DateTime equivalent using the specified culture-specific
DateTimeStyles) format information and formatting style.
ParseExact(String, to its DateTime equivalent using the specified format and

String, IFormatProvider) culture-specific format information. The format of the string
representation must match the specified format exactly.
ParseExact(String, to its DateTime equivalent using the specified format, culture-
String, IFormatProvider, specific format information, and style. The format of the string
DateTimeStyles) representation must match the specified format exactly or an
exception is thrown.
ParseExact(String, String Converts the specified string representation of a date and time
[], IFormatProvider, to its DateTime equivalent using the specified array of formats,
DateTimeStyles) culture-specific format information, and style. The format of
the string representation must match at least one of the
specified formats exactly or an exception is thrown.
Creates a new DateTime object that has the same number of
ticks as the specified DateTime, but is designated as either
SpecifyKind
local time, Coordinated Universal Time (UTC), or neither, as
indicated by the specified DateTimeKind value.
Subtract(DateTime) Subtracts the specified date and time from this instance.
Subtract(TimeSpan) Subtracts the specified duration from this instance.
Serializes the current DateTime object to a 64-bit binary value
ToBinary
that subsequently can be used to recreate the DateTimeobject.
Converts the value of the current DateTime object to a
ToFileTime
Windows file time.
Converts the value of the current DateTime object to a
ToFileTimeUtc
Windows file time.
Converts the value of the current DateTime object to local
ToLocalTime
time.
Converts the value of the current DateTime object to its
ToLongDateString
equivalent long date string representation.
ToLongTimeString
equivalent long time string representation.
Converts the value of this instance to the equivalent OLE
ToOADate
Automation date.
ToShortDateString
equivalent short date string representation.
ToShortTimeString
equivalent short time string representation.
ToString() equivalent string
representation. (OverridesValueType.ToString().)
ToString(IFormatProvide
equivalent string representation using the specified culture-
r)
specific format information.
ToString(String)
equivalent string representation using the specified format.
ToString(String,
equivalent string representation using the specified format and
IFormatProvider)
culture-specific format information.
Converts the value of the current DateTime object to
ToUniversalTime
Coordinated Universal Time (UTC).
TryParse(String,
to its DateTime equivalent and returns a value that indicates
DateTime)
whether the conversion succeeded.
TryParse(String, Converts the specified string representation of a date and time
IFormatProvider, to its DateTime equivalent using the specified culture-specific

DateTimeStyles, format information and formatting style, and returns a value
DateTime) that indicates whether the conversion succeeded.
TryParseExact(String, to its DateTime equivalent using the specified format, culture-
String, IFormatProvider, specific format information, and style. The format of the string

DateTimeStyles, representation must match the specified format exactly. The
DateTime) method returns a value that indicates whether the conversion
succeeded.
TryParseExact(String, St to its DateTime equivalent using the specified array of formats,
ring[], IFormatProvider, culture-specific format information, and style. The format of

DateTimeStyles, the string representation must match at least one of the
DateTime) specified formats exactly. The method returns a value that
indicates whether the conversion succeeded.
Top
Operators
Name Description
Adds a specified time interval to a specified date and time,
Addition
yielding a new date and time.
Determines whether two specified instances of DateTime are
Equality
equal.
Determines whether one specified DateTime is greater than
GreaterThan
another specified DateTime.
Determines whether one specified DateTime is greater than
GreaterThanOrEqual
or equal to another specified DateTime.
Determines whether two specified instances of DateTime are
Inequality
not equal.
Determines whether one specified DateTime is less than
LessThan
another specified DateTime.
Determines whether one specified DateTime is less than or
LessThanOrEqual
equal to another specified DateTime.
Subtraction(DateTime, Subtracts a specified date and time from another specified

DateTime) date and time and returns a time interval.
Subtraction(DateTime, Subtracts a specified time interval from a specified date and

TimeSpan) time and returns a new date and time.
Top
Fields
Name Description
MaxValue Represents the largest possible value of DateTime. This field is read-only.
MinValue Represents the smallest possible value of DateTime. This field is read-only.
Top
Explicit Interface Implementations
Name Description
Infrastructure. This conversion is not supported. Attempting
IConvertible.ToBoolean
to use this method throws an InvalidCastException.
IConvertible.ToByte
IConvertible.ToChar
IConvertible.ToDateTime Infrastructure. Returns the current DateTime object.
IConvertible.ToDecimal
IConvertible.ToDouble
IConvertible.ToInt16
IConvertible.ToSByte
IConvertible.ToSingle
Infrastructure. Converts the current DateTime object to an
IConvertible.ToType
object of a specified type.
IConvertible.ToUInt16
Populates a SerializationInfo object with the data needed to
ISerializable.GetObjectData
serialize the current DateTime object.
Top
Remarks
The DateTime value type represents dates and times with values ranging from 12:00:00 midnight,
January 1, 0001 Anno Domini (Common Era) through 11:59:59 P.M., December 31, 9999 A.D.
(C.E.).
Time values are measured in 100-nanosecond units called ticks, and a particular date is the number of ticks
since 12:00 midnight, January 1, 0001 A.D. (C.E.) in theGregorianCalendar calendar (excluding ticks that would
be added by leap seconds). For example, a ticks value of 31241376000000000L represents the date, Friday,
January 01, 0100 12:00:00 midnight. A DateTime value is always expressed in the context of an explicit or default
calendar.
Note
If you are working with a ticks value that you want to convert to some other time interval, such
as minutes or seconds, you should use
the TimeSpan.TicksPerDay,TimeSpan.TicksPerHour, TimeSpan.TicksPerMinute, TimeSpan.Ticks
PerSecond, or TimeSpan.TicksPerMillisecond constant to perform the conversion. For example, to
add the number of seconds represented by a specified number of ticks to the Second component of
a DateTime value, you can use the expression dateValue.Second +
nTicks/Timespan.TicksPerSecond.
Instantiating a DateTime Object

You can create a new DateTime value in any of the following ways:
• By calling any of the overloads of the DateTime constructor that allow you to specify specific elements of
the date and time value (such as the year, month, and day, or the number of ticks). The following
statement illustrates a call to one of the DateTime constructors to create a date with a specific year,
month, day, hour, minute, and second.
VB
C#
C++
F#
JScript
Copy
• By using any compiler-specific syntax for declaring date and time values. For example, the following
Visual Basic statement initializes a new DateTime value.
VB
C#
C++
F#
JScript
Copy
This language is not supported or no code example is available.

• By assigning the DateTime object a date and time value returned by a property or method. The following
example assigns the current date and time, the current Coordinated Universal Time (UTC) date and time,
and the current date to three new DateTime variables.
VB
C#
C++
F#
JScript
Copy
DateTime date1 = DateTime.Now;
DateTime date2 = DateTime.UtcNow;
DateTime date3 = DateTime.Today;
• By parsing the string representation of a date and time value. The Parse, ParseExact, TryParse,

and TryParseExact methods all convert a string to its equivalent date and time value. The following
example uses the Parse method to parse a string and convert it to a DateTime value.
VB
C#
C++
F#
JScript
Copy
string dateString = "5/1/2008 8:30:52 AM";

DateTime date1 = DateTime.Parse(dateString,
System.Globalization.CultureInfo.InvariantCulture);
Note that the TryParse and TryParseExact methods indicate whether a particular string contains a valid

representation of a DateTime value in addition to performing the conversion.
• By calling the DateTime structure's implicit default constructor. (For details on the implicit default
constructor of a value type, see Value Types (C# Reference).) An approximate equivalent, for compilers
that support it, is declaring a DateTime value without explicitly assigning a date and time to it. The
following example illustrates a call to the DateTime implicit default constructor in C# and Visual Basic, as
well as a DateTime variable declaration with no assignment in Visual Basic.
VB
C#
C++
F#
JScript
Copy
DateTime dat1 = new DateTime();

// The following method call displays 1/1/0001 12:00:00 AM.
Console.WriteLine(dat1.ToString(System.Globalization.CultureInfo.InvariantCulture));
// The following method call displays True.
Console.WriteLine(dat1.Equals(DateTime.MinValue));
DateTime Values and Their String Representations

Internally, all DateTime values are represented as the number of ticks (the number of 100-nanosecond intervals)
that have elapsed since 12:00:00 midnight, January 1, 0001. The actual DateTime value is independent of the
way in which that value appears when displayed in a user interface element or when written to a file. The
appearance of a DateTimevalue is the result of a formatting operation. Formatting is the process of converting a
value to its string representation.
Because the appearance of date and time values is dependent on such factors as culture, international
standards, application requirements, and personal preference, theDateTime structure offers a great deal of
flexibility in formatting date and time values through the overloads of its ToString method. The
default DateTime.ToString() method returns the string representation of a date and time value using the current
culture's short date and long time pattern. The following example uses the defaultDateTime.ToString() method
to display the date and time using the short date and long time pattern for the en-US culture, the current
culture on the computer on which the example was run.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString());
// For en-US culture, displays 3/1/2008 7:00:00 AM
The DateTime.ToString(IFormatProvider) method returns the string representation of a date and time value

using the short date and long time pattern of a specific culture. The following example uses
the DateTime.ToString(IFormatProvider) method to display the date and time using the short date and long
time pattern for the fr-FR culture.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("
fr-FR")));
// Displays 01/03/2008 07:00:00
The DateTime.ToString(String) method returns the string representation of the date and time in a format
defined by a standard or custom format specifier and using the formatting conventions of the current culture.
The following example uses the DateTime.ToString(String) method to display the full date and time pattern for
the en-US culture, the current culture on the computer on which the example was run.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("F"));
// Displays Saturday, March 01, 2008 7:00:00 AM
The DateTime.ToString(String, IFormatProvider) method returns the string representation of the date and time
in a format defined by a specific format specifier and using the formatting conventions of a specific culture. The
following example uses the DateTime.ToString(String, IFormatProvider) method to display the full date and time
pattern for the fr-FR culture.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("F", new System.Globalization.CultureInfo("fr-FR")));
// Displays samedi 1 mars 2008 07:00:00
Version Considerations
Prior to the .NET Framework version 2.0, the DateTime structure contains a 64-bit field composed of an unused
2-bit field concatenated with a private Ticks field, which is a 62-bit unsigned field that contains the number of
ticks that represent the date and time. The value of the Ticks field can be obtained with the Ticks property.
Starting with the .NET Framework 2.0, the DateTime structure contains a 64-bit field composed of a private Kind
field concatenated with the Ticks field. The Kind field is a 2-bit field that indicates whether
the DateTime structure represents a local time, a Coordinated Universal Time (UTC), or the time in an
unspecified time zone. The Kind field is used when performing time conversions between time zones, but not
for time comparisons or arithmetic. The value of the Kind field can be obtained with the Kind property.
Note
An alternative to the DateTime structure for working with date and time values in particular time
zones is the DateTimeOffset structure. The DateTimeOffset structure stores date and time
information in a private DateTime field and the number of minutes by which that date and time
differs from UTC in a private Int16 field. This makes it possible for a DateTimeOffset value to
reflect the time in a particular time zone, whereas a DateTime value can unambiguously reflect
only UTC and the local time zone's time. For a discussion about when to use
the DateTime structure or the DateTimeOffset structure when working with date and time values,
see Choosing Between DateTime, DateTimeOffset, and TimeZoneInfo.
DateTime Values
Descriptions of time values in the DateTime type are often expressed using the Coordinated Universal Time
(UTC) standard, which is the internationally recognized name for Greenwich Mean Time (GMT). Coordinated
Universal Time is the time as measured at zero degrees longitude, the UTC origin point. Daylight saving time is
not applicable to UTC.
Local time is relative to a particular time zone. A time zone is associated with a time zone offset, which is the
displacement of the time zone measured in hours from the UTC origin point. In addition, local time is optionally
affected by daylight saving time, which adds or subtracts an hour from the length of a day. Consequently, local
time is calculated by adding the time zone offset to UTC and adjusting for daylight saving time if necessary. The
time zone offset at the UTC origin point is zero.
UTC time is suitable for calculations, comparisons, and storing dates and time in files. Local time is appropriate
for display in user interfaces of desktop applications. Time zone-aware applications (such as many Web
applications) also need to work with a number of other time zones.
If the Kind property of a DateTime object is DateTimeKind.Unspecified, it is unspecified whether the time
represented is local time, UTC time, or a time in some other time zone.
DateTime Operations
A calculation using a DateTime structure, such as Add or Subtract, does not modify the value of the structure.
Instead, the calculation returns a new DateTime structure whose value is the result of the calculation.
Conversion operations between time zones (such as between UTC and local time, or between one time zone
and another) take daylight saving time into account, but arithmetic and comparison operations do not.
The DateTime structure itself offers limited support for converting from one time zone to another. You can use
the ToLocalTime method to convert UTC to local time, or you can use the ToUniversalTime method to convert
from local time to UTC. However, a full set of time zone conversion methods is available in
the TimeZoneInfo class. Using these methods, you can convert the time in any one of the world's time zones to
the time in any other time zone.
Calculations and comparisons of DateTime objects are meaningful only if the objects represent times in the
same time zone. You can use a TimeZoneInfo object to represent aDateTime value's time zone, although the
two are loosely coupled. (That is, a DateTime object does not have a property that returns an object that
represents that date and time value's time zone other than the Kind property.) For this reason, in a time zone-
aware application, you must rely on some external mechanism to determine the time zone in which
a DateTime object was created. For example, you could use a structure that wraps both the DateTime value and
the TimeZoneInfo object that represents the DateTimevalue's time zone. For details on using UTC in calculations
and comparisons with DateTime values, see Performing Arithmetic Operations with Dates and Times.
Each DateTime member implicitly uses the Gregorian calendar to perform its operation, with the exception of
constructors that specify a calendar, and methods with a parameter derived from IFormatProvider, such
as System.Globalization.DateTimeFormatInfo, that implicitly specifies a calendar.
Operations by members of the DateTime type take into account details such as leap years and the number of
days in a month.
DateTime vs. TimeSpan

The DateTime and TimeSpan value types differ in that a DateTime represents an instant in time whereas
a TimeSpan represents a time interval. This means, for example, that you can subtract one instance
of DateTime from another to obtain a TimeSpan object that represents the time interval between them. Or you
could add a positive TimeSpan to the current DateTime to obtain a DateTime value that represents a future
date.
You can add or subtract a time interval from a DateTime object. Time intervals can be negative or positive, can
be expressed in units such as ticks or seconds, or can be expressed as a TimeSpan object.
COM Interop Considerations

A DateTime value that is transferred to a COM application, then is transferred back to a managed application, is
said to round-trip. However, a DateTime value that specifies only a time does not round-trip as you might
expect.
If you round-trip only a time, such as 3 P.M., the final date and time is December 30, 1899 C.E. at 3:00 P.M.,
instead of January, 1, 0001 C.E. at 3:00 P.M. This happens because the .NET Framework and COM assume a
default date when only a time is specified. However, the COM system assumes a base date of December 30,
1899 C.E. while the .NET Framework assumes a base date of January, 1, 0001 C.E.
When only a time is passed from the .NET Framework to COM, special processing is performed that converts the
time to the format used by COM. When only a time is passed from COM to the .NET Framework, no special
processing is performed because that would corrupt legitimate dates and times on or before December 30,
1899. This also means if a date starts its round-trip from COM, the .NET Framework and COM preserve the date.
The behavior of the .NET Framework and COM means that if your application round-trips a DateTime that only
specifies a time, your application must remember to modify or ignore the erroneous date from the
final DateTime object.
Examples
The following example demonstrates how to compare roughly equivalent DateTime values,

accepting a small margin of difference when declaring them equal.
VB
C#
C++
F#
JScript
Copy
using System;
class DateTimeTester
{
static bool RoughlyEquals(DateTime time, DateTime timeWithWindow, int windowInSeconds,
int frequencyInSeconds)
{
long delta = (long)((TimeSpan)(timeWithWindow - time)).TotalSeconds
% frequencyInSeconds;
delta = delta > windowInSeconds ? frequencyInSeconds - delta : delta;
return Math.Abs(delta) < windowInSeconds;

}

{
int window = 10;
int freq = 60 * 60 * 2; // 2 hours;
DateTime d1 = DateTime.Now;
DateTime d2 = d1.AddSeconds(2 * window);

DateTime d3 = d1.AddSeconds(-2 * window);
DateTime d4 = d1.AddSeconds(window / 2);
DateTime d5 = d1.AddSeconds(-window / 2);
DateTime d6 = (d1.AddHours(2)).AddSeconds(2 * window);

DateTime d7 = (d1.AddHours(2)).AddSeconds(-2 * window);
DateTime d8 = (d1.AddHours(2)).AddSeconds(window / 2);
DateTime d9 = (d1.AddHours(2)).AddSeconds(-window / 2);
Console.WriteLine("d1 ({0}) ~= d1 ({1}): {2}",

d1, d1, RoughlyEquals(d1, d1, window, freq));

}
}
// The example displays output similar to the following:
// d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
// d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
// d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
Version Information
.NET Framework
Supported in: 4, 3.5, 3.0, 2.0, 1.1, 1.0
Custom Date and Time Format Strings
.NET Framework 4
Other Versions
Updated: July 2010

A date and time format string defines the text representation of a DateTime or DateTimeOffset value that results
from a formatting operation . It can also define the representation of a date and time value that is required in a
parsing operation in order to successfully convert the string to a date and time. A custom format string consists
of one or more custom date and time format specifiers. Any string that is not a standard date and time format
string is interpreted as a custom date and time format string.
Note
Custom date and time format strings can be used with
both DateTime and DateTimeOffset values.
In formatting operations, custom date and time format strings can be used either with
the ToString method of a date and time instance or with a method that supports composite
formatting. The following example illustrates both uses.
VB
C#
C++
F#
JScript
Copy
DateTime thisDate1 = new DateTime(2011, 6, 10);

Console.WriteLine("Today is " + thisDate1.ToString("MMMM dd, yyyy") + ".");
DateTimeOffset thisDate2 = new DateTimeOffset(2011, 6, 10, 15, 24, 16,

TimeSpan.Zero);
Console.WriteLine("The current date and time: {0:MM/dd/yy H:mm:ss zzz}",
thisDate2);
// Today is June 10, 2011.
// The current date and time: 06/10/11 15:24:16 +00:00
In parsing operations, custom date and time format strings can be used with
the DateTime.ParseExact, DateTime.TryParseExact, DateTimeOffset.ParseExact,
andDateTimeOffset.TryParseExact methods. These methods require that an input string conform exactly to a
particular pattern for the parse operation to succeed. The following example illustrates a call to
the DateTimeOffset.ParseExact(String, String, IFormatProvider) method to parse a date that must include a day,
a month, and a two-digit year.
VB
C#
C++
F#
JScript
Copy
using System;
using System.Globalization;
public class Example

{
{
string[] dateValues = { "30-12-2011", "12-30-2011",
"30-12-11", "12-30-11" };
string pattern = "MM-dd-yy";
DateTime parsedDate;
foreach (var dateValue in dateValues) {

if (DateTime.TryParseExact(dateValue, pattern, null,
DateTimeStyles.None, out parsedDate))
Console.WriteLine("Converted '{0}' to {1:d}.",
dateValue, parsedDate);
else
Console.WriteLine("Unable to convert '{0}' to a date and time.",
dateValue);
}
}
}
// Unable to convert '30-12-2011' to a date and time.
// Converted '12-30-11' to 12/30/2011.
The following table describes the custom date and time format specifiers and displays a result string produced
by each format specifier. If a particular format specifier produces a localized result string, the example also notes
the culture to which the result string applies. See the Notes section for additional information about using
custom date and time format strings.
Format
Description Examples
specifier
"d" The day of the month, from 1 6/1/2009 1:45:30 PM -> 1

through 31.
More information: The "d" Custom 6/15/2009 1:45:30 PM -> 15
Format Specifier.
The day of the month, from 01
through 31. 6/1/2009 1:45:30 PM -> 01
"dd"
More information: The "dd" Custom 6/15/2009 1:45:30 PM -> 15
Format Specifier.
The abbreviated name of the day of
6/15/2009 1:45:30 PM -> Mon (en-US)
the week.
"ddd" 6/15/2009 1:45:30 PM -> Пн (ru-RU)
More information: The "ddd"
6/15/2009 1:45:30 PM -> lun. (fr-FR)
Custom Format Specifier.
The full name of the day of the 6/15/2009 1:45:30 PM -> Monday (en-US)
week. 6/15/2009 1:45:30 PM -> понедельник (ru-
"dddd"
More information: The "dddd" RU)
Custom Format Specifier. 6/15/2009 1:45:30 PM -> lundi (fr-FR)
The tenths of a second in a date and
time value. 6/15/2009 13:45:30.617 -> 6
"f"
More information: The "f" Custom 6/15/2009 13:45:30.050 -> 0
Format Specifier.
The hundredths of a second in a date
and time value. 6/15/2009 13:45:30.617 -> 61
"ff"
More information: The "ff" Custom 6/15/2009 13:45:30.005 -> 00
Format Specifier.
The milliseconds in a date and time
value. 6/15/2009 13:45:30.617 -> 617
"fff"
More information: The "fff" Custom 6/15/2009 13:45:30.0005 -> 000
Format Specifier.
The ten thousandths of a second in a
date and time value. 6/15/2009 13:45:30.6175 -> 6175
"ffff"
More information: The "ffff" 6/15/2009 13:45:30.00005 -> 0000
The hundred thousandths of a
second in a date and time value. 6/15/2009 13:45:30.61754 -> 61754
"fffff"
More information: The "fffff" 6/15/2009 13:45:30.000005 -> 00000
The millionths of a second in a date
and time value. 6/15/2009 13:45:30.617542 -> 617542
"ffffff"
More information: The "ffffff" 6/15/2009 13:45:30.0000005 -> 000000
The ten millionths of a second in a
date and time value. 6/15/2009 13:45:30.6175425 -> 6175425
"fffffff"
More information: The "fffffff" 6/15/2009 13:45:30.0001150 -> 0001150
If non-zero, the tenths of a second in
a date and time value. 6/15/2009 13:45:30.617 -> 6
"F"
More information: The "F" Custom 6/15/2009 13:45:30.050 -> (no output)
Format Specifier.
If non-zero, the hundredths of a
"FF"
More information: The "FF" 6/15/2009 13:45:30.005 -> (no output)
If non-zero, the milliseconds in a 6/15/2009 13:45:30.617 -> 617
date and time value. 6/15/2009 13:45:30.0005 -> (no output)
"FFF"
More information: The "FFF"
If non-zero, the ten thousandths of a 6/1/2009 13:45:30.5275 -> 5275
second in a date and time value. 6/15/2009 13:45:30.00005 -> (no output)
"FFFF"
More information: The "FFFF"
If non-zero, the hundred
thousandths of a second in a date
6/15/2009 13:45:30.61754 -> 61754
"FFFFF" and time value.
6/15/2009 13:45:30.000005 -> (no output)
More information: The "FFFFF"
If non-zero, the millionths of a 6/15/2009 13:45:30.617542 -> 617542
second in a date and time value. 6/15/2009 13:45:30.0000005 -> (no output)
"FFFFFF"
More information: The "FFFFFF"
If non-zero, the ten millionths of a 6/15/2009 13:45:30.6175425 -> 6175425
"FFFFFFF"
More information: The "FFFFFFF"
The period or era.
"g", "gg" More information: The "g" or "gg" 6/15/2009 1:45:30 PM -> A.D.
The hour, using a 12-hour clock 6/15/2009 1:45:30 AM -> 1
from 1 to 12. 6/15/2009 1:45:30 PM -> 1
"h"
More information: The "h" Custom
Format Specifier.
from 01 to 12. 6/15/2009 1:45:30 PM -> 01
"hh"
More information: The "hh" Custom
Format Specifier.
from 0 to 23. 6/15/2009 1:45:30 PM -> 13
"H"
More information: The "H" Custom
Format Specifier.
from 00 to 23. 6/15/2009 1:45:30 PM -> 13
"HH"
More information: The "HH"
"K" Time zone information. With DateTime values:
More information: The "K" Custom 6/15/2009 1:45:30 PM, Kind Unspecified ->
Format Specifier. 6/15/2009 1:45:30 PM, Kind Utc -> Z
6/15/2009 1:45:30 PM, Kind Local -> -07:00
(depends on local computer settings)
With DateTimeOffset values:
6/15/2009 1:45:30 AM -07:00 --> -07:00
6/15/2009 8:45:30 AM +00:00 --> +00:00
The minute, from 0 through 59.
6/15/2009 1:09:30 AM -> 9
"m" More information: The "m" Custom
6/15/2009 1:09:30 PM -> 9
Format Specifier.
The minute, from 00 through 59.
6/15/2009 1:09:30 AM -> 09
"mm" More information: The "mm"
6/15/2009 1:09:30 PM -> 09
The month, from 1 through 12.
"M" More information: The "M" Custom 6/15/2009 1:45:30 PM -> 6
Format Specifier.
The month, from 01 through 12.
"MM" More information: The "MM" 6/15/2009 1:45:30 PM -> 06
The abbreviated name of the month. 6/15/2009 1:45:30 PM -> Jun (en-US)
"MMM" More information: The "MMM" 6/15/2009 1:45:30 PM -> juin (fr-FR)
Custom Format Specifier. 6/15/2009 1:45:30 PM -> Jun (zu-ZA)
The full name of the month. 6/15/2009 1:45:30 PM -> June (en-US)
"MMMM" More information: The "MMMM" 6/15/2009 1:45:30 PM -> juni (da-DK)
Custom Format Specifier. 6/15/2009 1:45:30 PM -> uJuni (zu-ZA)
The second, from 0 through 59.
"s" More information: The "s" Custom 6/15/2009 1:45:09 PM -> 9
Format Specifier.
The second, from 00 through 59.
"ss" More information: The "ss" Custom 6/15/2009 1:45:09 PM -> 09
Format Specifier.
The first character of the AM/PM 6/15/2009 1:45:30 PM -> P (en-US)
designator.
"t" 6/15/2009 1:45:30 PM -> 午 (ja-JP)
More information: The "t" Custom
Format Specifier. 6/15/2009 1:45:30 PM -> (fr-FR)
The AM/PM designator. 6/15/2009 1:45:30 PM -> PM (en-US)

"tt" More information: The "tt" Custom 6/15/2009 1:45:30 PM -> 午後 (ja-JP)
Format Specifier. 6/15/2009 1:45:30 PM -> (fr-FR)
1/1/0001 12:00:00 AM -> 1
The year, from 0 to 99.
1/1/0900 12:00:00 AM -> 0
"y" More information: The "y" Custom
1/1/1900 12:00:00 AM -> 0
Format Specifier.
6/15/2009 1:45:30 PM -> 9
1/1/0001 12:00:00 AM -> 01
The year, from 00 to 99.
1/1/0900 12:00:00 AM -> 00
"yy" More information: The "yy" Custom
1/1/1900 12:00:00 AM -> 00
Format Specifier.
6/15/2009 1:45:30 PM -> 09
"yyy" The year, with a minimum of three 1/1/0001 12:00:00 AM -> 001
digits. 1/1/0900 12:00:00 AM -> 900
More information: The "yyy" 1/1/1900 12:00:00 AM -> 1900
Custom Format Specifier. 6/15/2009 1:45:30 PM -> 2009
1/1/0001 12:00:00 AM -> 0001
The year as a four-digit number.
1/1/0900 12:00:00 AM -> 0900
"yyyy" More information: The "yyyy"
1/1/1900 12:00:00 AM -> 1900
6/15/2009 1:45:30 PM -> 2009
The year as a five-digit number.
1/1/0001 12:00:00 AM -> 00001
"yyyyy" More information: The "yyyyy"
6/15/2009 1:45:30 PM -> 02009
Hours offset from UTC, with no
leading zeros.
"z" 6/15/2009 1:45:30 PM -07:00 -> -7
More information: The "z" Custom
Format Specifier.
Hours offset from UTC, with a
leading zero for a single-digit value.
"zz" 6/15/2009 1:45:30 PM -07:00 -> -07
More information: The "zz" Custom
Format Specifier.
Hours and minutes offset from
UTC.
"zzz" 6/15/2009 1:45:30 PM -07:00 -> -07:00
More information: The "zzz"
The time separator. 6/15/2009 1:45:30 PM -> : (en-US)
":" More information: The ":" Custom 6/15/2009 1:45:30 PM -> . (it-IT)
Format Specifier. 6/15/2009 1:45:30 PM -> : (ja-JP)
The date separator. 6/15/2009 1:45:30 PM -> / (en-US)
"/" More Information: The "/" Custom 6/15/2009 1:45:30 PM -> - (ar-DZ)
Format Specifier. 6/15/2009 1:45:30 PM -> . (tr-TR)
6/15/2009 1:45:30 PM ("arr:" h:m t) -> arr:
"string" 1:45 P
Literal string delimiter.
'string' 6/15/2009 1:45:30 PM ('arr:' h:m t) -> arr:
1:45 P
Defines the following character as a
custom format specifier.
% 6/15/2009 1:45:30 PM (%h) -> 1
More information: Using Single
Custom Format Specifiers.
\ The escape character. 6/15/2009 1:45:30 PM (h \h) -> 1 h
The character is copied to the result
Any other string unchanged. 6/15/2009 1:45:30 AM (arr hh:mm t) -> arr
character More information: Using the Escape 01:45 A
Character.
The following sections provide additional information about each custom date and time format specifier. Unless
otherwise noted, each specifier produces an identical string representation regardless of whether it is used with
a DateTime value or a DateTimeOffset value.
The "d" Custom Format Specifier

The "d" custom format specifier represents the day of the month as a number from 1 through 31. A
single-digit day is formatted without a leading zero.
If the "d" format specifier is used without other custom format specifiers, it is interpreted as the "d" standard
date and time format specifier. For more information about using a single format specifier, see Using Single
Custom Format Specifiers later in this topic.
The following example includes the "d" custom format specifier in several format strings.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(date1.ToString("d, M",
CultureInfo.InvariantCulture));
// Displays 29, 8
Console.WriteLine(date1.ToString("d MMMM",
// Displays 29 August
Console.WriteLine(date1.ToString("d MMMM",
CultureInfo.CreateSpecificCulture("es-MX")));
// Displays 29 agosto
Back to table
The "dd" Custom Format Specifier
The "dd" custom format string represents the day of the month as a number from 01 through 31. A
single-digit day is formatted with a leading zero.
The following example includes the "dd" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(date1.ToString("dd, MM",
// 02, 01
Back to table
The "ddd" Custom Format Specifier
The "ddd" custom format specifier represents the abbreviated name of the day of the week. The
localized abbreviated name of the day of the week is retrieved from
theDateTimeFormatInfo.AbbreviatedDayNames property of the current or specified culture.
The following example includes the "ddd" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(date1.ToString("ddd d MMM",
// Displays Fri 29 Aug
// Displays ven. 29 août
Back to table
The "dddd" Custom Format Specifier
The "dddd" custom format specifier (plus any number of additional "d" specifiers) represents the
full name of the day of the week. The localized name of the day of the week is retrieved from
the DateTimeFormatInfo.DayNames property of the current or specified culture.
The following example includes the "dddd" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(date1.ToString("dddd dd MMMM",
// Displays Friday 29 August
CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Back to table
The "f" Custom Format Specifier
The "f" custom format specifier represents the most significant digit of the seconds fraction; that is,
it represents the tenths of a second in a date and time value.
If the "f" format specifier is used without other format specifiers, it is interpreted as the "f" standard date and
time format specifier. For more information about using a single format specifier, see Using Single Custom
Format Specifiers later in this topic.
When you use "f" format specifiers as part of a format string supplied to
the ParseExact, TryParseExact, ParseExact, or TryParseExact method, the number of "f" format specifiers indicates
the number of most significant digits of the seconds fraction that must be present to successfully parse the
string.
The following example includes the "f" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1 = new DateTime(2008, 8, 29, 19, 27, 15, 18);

CultureInfo ci = CultureInfo.InvariantCulture;
Console.WriteLine(date1.ToString("hh:mm:ss.f", ci));
// Displays 07:27:15.0
Console.WriteLine(date1.ToString("hh:mm:ss.F", ci));
// Displays 07:27:15
Console.WriteLine(date1.ToString("hh:mm:ss.ff", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.FF", ci));
// Displays 07:27:15.01
Console.WriteLine(date1.ToString("hh:mm:ss.fff", ci));
// Displays 07:27:15.018
Console.WriteLine(date1.ToString("hh:mm:ss.FFF", ci));
// Displays 07:27:15.018
Back to table
The "ff" Custom Format Specifier
The "ff" custom format specifier represents the two most significant digits of the seconds fraction;
that is, it represents the hundredths of a second in a date and time value.
following example includes the "ff" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 07:27:15.0
// Displays 07:27:15.01
// Displays 07:27:15.01
// Displays 07:27:15.018
// Displays 07:27:15.018
Back to table
The "fff" Custom Format Specifier
The "fff" custom format specifier represents the three most significant digits of the seconds fraction;
that is, it represents the milliseconds in a date and time value.
The following example includes the "fff" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 07:27:15.0
// Displays 07:27:15.01
// Displays 07:27:15.01
// Displays 07:27:15.018
// Displays 07:27:15.018
Back to table
The "ffff" Custom Format Specifier

The "ffff" custom format specifier represents the four most significant digits of the seconds fraction;
that is, it represents the ten thousandths of a second in a date and time value.
Although it is possible to display the ten thousandths of a second component of a time value, that value may
not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the
Windows NT version 3.5 (and later) and Windows Vista operating systems, the clock's resolution is
approximately 10-15 milliseconds.
Back to table
The "fffff" Custom Format Specifier
The "fffff" custom format specifier represents the five most significant digits of the seconds
fraction; that is, it represents the hundred thousandths of a second in a date and time value.
Although it is possible to display the hundred thousandths of a second component of a time value, that value
may not be meaningful. The precision of date and time values depends on the resolution of the system clock.
On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is
Back to table
The "ffffff" Custom Format Specifier
The "ffffff" custom format specifier represents the six most significant digits of the seconds
fraction; that is, it represents the millionths of a second in a date and time value.
Although it is possible to display the millionths of a second component of a time value, that value may not be
meaningful. The precision of date and time values depends on the resolution of the system clock. On the
Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is approximately 10-15
milliseconds.
Back to table
The "fffffff" Custom Format Specifier
The "fffffff" custom format specifier represents the seven most significant digits of the seconds
fraction; that is, it represents the ten millionths of a second in a date and time value.
Although it is possible to display the ten millionths of a second component of a time value, that value may not
be meaningful. The precision of date and time values depends on the resolution of the system clock. On the
milliseconds.
Back to table
The "F" Custom Format Specifier

The "F" custom format specifier represents the most significant digit of the seconds fraction; that is,
it represents the tenths of a second in a date and time value. Nothing is displayed if the digit is zero.
If the "F" format specifier is used without other format specifiers, it is interpreted as the "F" standard date and
time format specifier. For more information about using a single format specifier, see Using Single Custom
The number of "F" format specifiers used with the ParseExact, TryParseExact, ParseExact,
or TryParseExact method indicates the maximum number of most significant digits of the seconds fraction that
can be present to successfully parse the string.
The following example includes the "F" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 07:27:15.0
// Displays 07:27:15.01
// Displays 07:27:15.01
// Displays 07:27:15.018
// Displays 07:27:15.018
Back to table
The "FF" Custom Format Specifier
The "FF" custom format specifier represents the two most significant digits of the seconds fraction;
that is, it represents the hundredths of a second in a date and time value. However, trailing zeros or
two zero digits are not displayed.
The following example includes the "FF" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 07:27:15.0
// Displays 07:27:15.01
// Displays 07:27:15.01
// Displays 07:27:15.018
// Displays 07:27:15.018
Back to table
The "FFF" Custom Format Specifier
The "FFF" custom format specifier represents the three most significant digits of the seconds
fraction; that is, it represents the milliseconds in a date and time value. However, trailing zeros or
three zero digits are not displayed.
The following example includes the "FFF" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 07:27:15.0
// Displays 07:27:15.01
// Displays 07:27:15.01
// Displays 07:27:15.018
// Displays 07:27:15.018
Back to table
The "FFFF" Custom Format Specifier

The "FFFF" custom format specifier represents the four most significant digits of the seconds
fraction; that is, it represents the ten thousandths of a second in a date and time value. However,
trailing zeros or four zero digits are not displayed.
Although it is possible to display the ten thousandths of a second component of a time value, that value may
not be meaningful. The precision of date and time values depends on the resolution of the system clock. On the
milliseconds.
Back to table
The "FFFFF" Custom Format Specifier
The "FFFFF" custom format specifier represents the five most significant digits of the seconds
fraction; that is, it represents the hundred thousandths of a second in a date and time value.
However, trailing zeros or five zero digits are not displayed.
Although it is possible to display the hundred thousandths of a second component of a time value, that value
may not be meaningful. The precision of date and time values depends on the resolution of the system clock.
On the Windows NT 3.5 (and later) and Windows Vista operating systems, the clock's resolution is
Back to table
The "FFFFFF" Custom Format Specifier
The "FFFFFF" custom format specifier represents the six most significant digits of the seconds
fraction; that is, it represents the millionths of a second in a date and time value. However, trailing
zeros or six zero digits are not displayed.
Although it is possible to display the millionths of a second component of a time value, that value may not be
meaningful. The precision of date and time values depends on the resolution of the system clock. On tfhe
milliseconds.
Back to table
The "FFFFFFF" Custom Format Specifier
The "FFFFFFF" custom format specifier represents the seven most significant digits of the seconds
fraction; that is, it represents the ten millionths of a second in a date and time value. However,
trailing zeros or seven zero digits are not displayed.
Although it is possible to display the ten millionths of a second component of a time value, that value may not
be meaningful. The precision of date and time values depends on the resolution of the system clock. On the
milliseconds.
Back to table
The "g" or "gg" Custom Format Specifier
The "g" or "gg" custom format specifiers (plus any number of additional "g" specifiers) represents
the period or era, such as A.D. The formatting operation ignores this specifier if the date to be
formatted does not have an associated period or era string.
If the "g" format specifier is used without other custom format specifiers, it is interpreted as the "g" standard
The following example includes the "g" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(date1.ToString("MM/dd/yyyy g",
// Displays 08/04/0070 A.D.
Console.WriteLine(date1.ToString("MM/dd/yyyy g",
// Displays 08/04/0070 ap. J.-C.
Back to table
The "h" Custom Format Specifier
The "h" custom format specifier represents the hour as a number from 1 through 12; that is, the hour
is represented by a 12-hour clock that counts the whole hours since midnight or noon. A particular
hour after midnight is indistinguishable from the same hour after noon. The hour is not rounded,
and a single-digit hour is formatted without a leading zero. For example, given a time of 5:43 in the
morning or afternoon, this custom format specifier displays "5".
If the "h" format specifier is used without other custom format specifiers, it is interpreted as a standard date and
time format specifier and throws a FormatException. For more information about using a single format specifier,
see Using Single Custom Format Specifiers later in this topic.
The following example includes the "h" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
date1 = new DateTime(2008, 1, 1, 18, 9, 1);
Console.WriteLine(date1.ToString("h:m:s.F t",
// Displays 6:9:1 P
CultureInfo.CreateSpecificCulture("el-GR")));
// Displays 6:9:1 µ
date1 = new DateTime(2008, 1, 1, 18, 9, 1, 500);
// Displays 6:9:1.5 P
// Displays 6:9:1.5 µ
Back to table
The "hh" Custom Format Specifier
The "hh" custom format specifier (plus any number of additional "h" specifiers) represents the hour
as a number from 01 through 12; that is, the hour is represented by a 12-hour clock that counts the
whole hours since midnight or noon. A particular hour after midnight is indistinguishable from the
same hour after noon. The hour is not rounded, and a single-digit hour is formatted with a leading
zero. For example, given a time of 5:43 in the morning or afternoon, this format specifier displays
"05".
The following example includes the "hh" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
Console.WriteLine(date1.ToString("hh:mm:ss tt",
// Displays 06:09:01 PM
CultureInfo.CreateSpecificCulture("hu-HU")));
// Displays 06:09:01 du.
Console.WriteLine(date1.ToString("hh:mm:ss.ff tt",
// Displays 06:09:01.50 PM
// Displays 06:09:01.50 du.
Back to table
The "H" Custom Format Specifier

The "H" custom format specifier represents the hour as a number from 0 through 23; that is, the
hour is represented by a zero-based 24-hour clock that counts the hours since midnight. A single-
digit hour is formatted without a leading zero.
If the "H" format specifier is used without other custom format specifiers, it is interpreted as a standard date and
The following example includes the "H" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("H:mm:ss",
// Displays 6:09:01
Back to table
The "HH" Custom Format Specifier
The "HH" custom format specifier (plus any number of additional "H" specifiers) represents the
hour as a number from 00 through 23; that is, the hour is represented by a zero-based 24-hour clock
that counts the hours since midnight. A single-digit hour is formatted with a leading zero.
The following example includes the "HH" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("HH:mm:ss",
Back to table
The "K" Custom Format Specifier

The "K" custom format specifier represents the time zone information of a date and time value.
When this format specifier is used with DateTime values, the result string is defined by the value of
the DateTime.Kind property:
• For the local time zone (a DateTime.Kind property value of DateTimeKind.Local), this specifier is
equivalent to the "zzz" specifier and produces a result string containing the local offset from Coordinated
Universal Time (UTC); for example, "-07:00".
• For a UTC time (a DateTime.Kind property value of DateTimeKind.Utc), the result string includes a "Z"
character to represent a UTC date.
• For a time from an unspecified time zone (a time whose DateTime.Kind property
equals DateTimeKind.Unspecified), the result is equivalent to String.Empty.
For DateTimeOffset values, the "K" format specifier is equivalent to the "zz" format specifier, and produces a
result string containing the DateTimeOffset value's offset from UTC.
If the "K" format specifier is used without other custom format specifiers, it is interpreted as a standard date and
The following example displays the string that results from using the "K" custom format specifier with
various DateTime and DateTimeOffset values on a system in the U.S. Pacific Time zone.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(DateTime.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTime.UtcNow.ToString("%K"));
// Displays Z
Console.WriteLine("'{0}'",
DateTime.SpecifyKind(DateTime.Now,
DateTimeKind.Unspecified).ToString("%K"));
// Displays ''
Console.WriteLine(DateTimeOffset.Now.ToString("%K"));
// Displays -07:00
Console.WriteLine(DateTimeOffset.UtcNow.ToString("%K"));
// Displays +00:00
Console.WriteLine(new DateTimeOffset(2008, 5, 1, 6, 30, 0,
new TimeSpan(5, 0, 0)).ToString("%K"));
// Displays +05:00
Back to table
The "m" Custom Format Specifier
The "m" custom format specifier represents the minute as a number from 0 through 59. The minute
represents whole minutes that have passed since the last hour. A single-digit minute is formatted
without a leading zero.
If the "m" format specifier is used without other custom format specifiers, it is interpreted as the "m" standard
The following example includes the "m" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
// Displays 6:9:1 P
Back to table
The "mm" Custom Format Specifier
The "mm" custom format specifier (plus any number of additional "m" specifiers) represents the
minute as a number from 00 through 59. The minute represents whole minutes that have passed
since the last hour. A single-digit minute is formatted with a leading zero.
The following example includes the "mm" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
// Displays 06:09:01.50 PM
// Displays 06:09:01.50 du.
Back to table
The "M" Custom Format Specifier
The "M" custom format specifier represents the month as a number from 1 through 12 (or from 1
through 13 for calendars that have 13 months). A single-digit month is formatted without a leading
zero.
If the "M" format specifier is used without other custom format specifiers, it is interpreted as the "M" standard
The following example includes the "M" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("(M) MMM, MMMM",
// Displays (8) Aug, August
CultureInfo.CreateSpecificCulture("nl-NL")));
// Displays (8) aug, augustus
CultureInfo.CreateSpecificCulture("lv-LV")));
// Displays (8) Aug, augusts
Back to table
The "MM" Custom Format Specifier
The "MM" custom format specifier represents the month as a number from 01 through 12 (or from
1 through 13 for calendars that have 13 months). A single-digit month is formatted with a leading
zero.
The following example includes the "MM" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
Console.WriteLine(date1.ToString("dd, MM",
// 02, 01
Back to table
The "MMM" Custom Format Specifier
The "MMM" custom format specifier represents the abbreviated name of the month. The localized
abbreviated name of the month is retrieved from
theDateTimeFormatInfo.AbbreviatedMonthNames property of the current or specified culture.
The following example includes the "MMM" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
// Displays Fri 29 Aug
// Displays ven. 29 août
Back to table
The "MMMM" Custom Format Specifier
The "MMMM" custom format specifier represents the full name of the month. The localized name
of the month is retrieved from the DateTimeFormatInfo.MonthNamesproperty of the current or
specified culture.
The following example includes the "MMMM" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
// Displays Friday 29 August
CultureInfo.CreateSpecificCulture("it-IT")));
// Displays venerdì 29 agosto
Back to table
The "s" Custom Format Specifier
The "s" custom format specifier represents the seconds as a number from 0 through 59. The result
represents whole seconds that have passed since the last minute. A single-digit second is formatted
without a leading zero.
If the "s" format specifier is used without other custom format specifiers, it is interpreted as the "s" standard
The following example includes the "s" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
// Displays 6:9:1 P
Back to table
The "ss" Custom Format Specifier

The "ss" custom format specifier (plus any number of additional "s" specifiers) represents the
seconds as a number from 00 through 59. The result represents whole seconds that have passed
since the last minute. A single-digit second is formatted with a leading zero.
The following example includes the "ss" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
// Displays 06:09:01.50 PM
// Displays 06:09:01.50 du.
Back to table
The "t" Custom Format Specifier
The "t" custom format specifier represents the first character of the AM/PM designator. The
appropriate localized designator is retrieved from
theDateTimeFormatInfo.AMDesignator or DateTimeFormatInfo.PMDesignator property of the
current or specific culture. The AM designator is used for all times from 0:00:00 (midnight) to
11:59:59.999. The PM designator is used for all times from 12:00:00 (noon) to 23:59:59.99.
If the "t" format specifier is used without other custom format specifiers, it is interpreted as the "t" standard date
and time format specifier. For more information about using a single format specifier, see Using Single Custom
The following example includes the "t" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
// Displays 6:9:1 P
Back to table
The "tt" Custom Format Specifier
The "tt" custom format specifier (plus any number of additional "t" specifiers) represents the entire
AM/PM designator. The appropriate localized designator is retrieved from
the DateTimeFormatInfo.AMDesignator or DateTimeFormatInfo.PMDesignator property of the
current or specific culture. The AM designator is used for all times from 0:00:00 (midnight) to
11:59:59.999. The PM designator is used for all times from 12:00:00 (noon) to 23:59:59.99.
Make sure to use the "tt" specifier for languages for which it is necessary to maintain the distinction between
AM and PM. An example is Japanese, for which the AM and PM designators differ in the second character
instead of the first character.
The following example includes the "tt" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
DateTime date1;
// Displays 06:09:01.50 PM
// Displays 06:09:01.50 du.
Back to table
The "y" Custom Format Specifier

The "y" custom format specifier represents the year as a one-digit or two-digit number. If the year
has more than two digits, only the two low-order digits appear in the result. If the first digit of a
two-digit year begins with a zero (for example, 2008), the number is formatted without a leading
zero.
If the "y" format specifier is used without other custom format specifiers, it is interpreted as the "y" standard
The following example includes the "y" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(date1.ToString("%y"));
// Displays 1
Console.WriteLine(date1.ToString("yy"));
// Displays 01
Console.WriteLine(date1.ToString("yyy"));
// Displays 001
Console.WriteLine(date1.ToString("yyyy"));
// Displays 0001
Console.WriteLine(date1.ToString("yyyyy"));
// Displays 00001
// Displays 10
// Displays 10
// Displays 2010
// Displays 2010
// Displays 02010
Back to table
The "yy" Custom Format Specifier
The "yy" custom format specifier represents the year as a two-digit number. If the year has more
than two digits, only the two low-order digits appear in the result. If the two-digit year has fewer
than two significant digits, the number is padded with leading zeros to produce two digits.
The following example includes the "yy" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 1
// Displays 01
// Displays 001
// Displays 0001
// Displays 00001
// Displays 10
// Displays 10
// Displays 2010
// Displays 2010
// Displays 02010
Back to table
The "yyy" Custom Format Specifier
The "yyy" custom format specifier represents the year with a minimum of three digits. If the year
has more than three significant digits, they are included in the result string. If the year has fewer
than three digits, the number is padded with leading zeros to produce three digits.
Note
For the Thai Buddhist calendar, which can have five-digit years, this format specifier displays all
significant digits.
The following example includes the "yyy" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 1
// Displays 01
// Displays 001
// Displays 0001
// Displays 00001
// Displays 10
// Displays 10
// Displays 2010
// Displays 2010
// Displays 02010
Back to table
The "yyyy" Custom Format Specifier
The "yyyy" custom format specifier represents the year with a minimum of four digits. If the year
has more than four significant digits, they are included in the result string. If the year has fewer than
four digits, the number is padded with leading zeros to produce four digits.
Note
For the Thai Buddhist calendar, which can have five-digit years, this format specifier displays a
minimum of four digits.
The following example includes the "yyyy" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 1
// Displays 01
// Displays 001
// Displays 0001
// Displays 00001
// Displays 10
// Displays 10
// Displays 2010
// Displays 2010
// Displays 02010
Back to table
The "yyyyy" Custom Format Specifier
The "yyyyy" custom format specifier (plus any number of additional "y" specifiers) represents the
year with a minimum of five digits. If the year has more than five significant digits, they are
included in the result string. If the year has fewer than five digits, the number is padded with
leading zeros to produce five digits.
If there are additional "y" specifiers, the number is padded with as many leading zeros as necessary to produce
the number of "y" specifiers.
The following example includes the "yyyyy" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

// Displays 1
// Displays 01
// Displays 001
// Displays 0001
// Displays 00001
// Displays 10
// Displays 10
// Displays 2010
// Displays 2010
// Displays 02010
Back to table
The "z" Custom Format Specifier
With DateTime values, the "z" custom format specifier represents the signed offset of the local
operating system's time zone from Coordinated Universal Time (UTC), measured in hours. It does
not reflect the value of an instance's DateTime.Kind property. For this reason, the "z" format
specifier is not recommended for use with DateTime values.
With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in
hours.
The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus
sign (-) indicates hours behind UTC. A single-digit offset is formatted without a leading zero.
If the "z" format specifier is used without other custom format specifiers, it is interpreted as a standard date and
The following example includes the "z" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy

Console.WriteLine(String.Format("{0:%z}, {0:zz}, {0:zzz}",
date1));
// Displays -7, -07, -07:00
DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,

new TimeSpan(6, 0, 0));
date2));
// Displays +6, +06, +06:00
Back to table
The "zz" Custom Format Specifier
With DateTime values, the "zz" custom format specifier represents the signed offset of the local
operating system's time zone from UTC, measured in hours. It does not reflect the value of an
instance's DateTime.Kind property. For this reason, the "zz" format specifier is not recommended
for use with DateTime values.
With DateTimeOffset values, this format specifier represents the DateTimeOffset value's offset from UTC in
hours.
The offset is always displayed with a leading sign. A plus sign (+) indicates hours ahead of UTC, and a minus
sign (-) indicates hours behind UTC. A single-digit offset is formatted with a leading zero.
The following example includes the "zz" custom format specifier in a custom format string.
VB
C#
C++
F#
JScript
Copy
date1));
// Displays -7, -07, -07:00
DateTimeOffset date2 = new DateTimeOffset(2008, 8, 1, 0, 0, 0,

new TimeSpan(6, 0, 0));
date2));
// Displays +6, +06, +06:00
Back to table
C# DateTime Examples
You want to use
the DateTime t
ype in the C#
programming
language, and
also need
various methods
to find important
days, such as yesterday, tomorrow,
the first of the year, and the last
day. The DateTime type in the C#
language provides useful methods
and properties for computing these
values. This document introduces
several useful methods and shows
their output.
Use DateTime to
compute relative dates.
Create new DateTimes
with overloaded
constructors.
Review other DateTime
properties.
Constructor
For the DateTime type in the C#
programming language and .NET
Framework, you can use the instance
constructor with the 'new' operator
to instantiate a new DateTime
instance. Please note that the
arguments to the constructor must
match to a real date that occurred.
This example also shows how you
can write a DateTime to the console,
and also to how you can compare a
DateTime against the Today value.
--- Program that uses DateTime

constructor [C#] ---
using System;
class Program
static void Main()
// This DateTime is constructed

with an instance constructor.
// ... We write it to the console.
// ... If this is today, the second

line will be "True".
DateTime value = new

DateTime(2010, 1, 18);
Console.WriteLine(value);
Console.WriteLine(value ==
DateTime.Today);
}
--- Output of the program ---
The second line depends on the local

date on your computer.
1/18/2010 12:00:00 AM
True
Finding yesterday
Here we see how to subtract one day
from the current day. We do this by
adding -1 to the current day, which
is necessary because no "Subtract
Days" method is provided. An
extension method could help
depending on your style.
--- Program that uses DateTime [C#]

---
using System;
class Program
static void Main()
Console.WriteLine("Today: {0}",
DateTime.Today);
DateTime y = GetYesterday();
Console.WriteLine("Yesterday:
{0}", y);
}
/// <summary>
/// Gets the previous day to the

current day.
/// </summary>
static DateTime GetYesterday()
// Add -1 to now
return
DateTime.Today.AddDays(-1);
Today: 11/30/2008 12:00:00 AM
Yesterday: 11/29/2008 12:00:00 AM
Description. What the example

displays is the current day. Note that
the Console.WriteLine implicitly
converts the DateTime.Today
argument using its ToString()
method. XML comments are very
useful here because you may want to
put these methods in a helper class,
which would make them reusable
across projects. The example was
run on November 30, 2008. The
output will naturally vary depending
on the day you run it.
DateTime.Today is always set to the
machine's local time.
See DateTime Subtract Method.
Finding tomorrow
Here we see how you can add one
using the DateTime Add method to
figure out tomorrow. This is useful
for using date queries in databases,
as you usually have to select a range
of dates.
--- Program that uses AddDays [C#]

---
using System;
class Program
static void Main()
Console.WriteLine("Today: {0}",
DateTime.Today);
DateTime d = GetTomorrow();
Console.WriteLine("Tomorrow:
{0}", d);
/// <summary>
/// Gets the next day, tomorrow.
/// </summary>
static DateTime GetTomorrow()
return
DateTime.Today.AddDays(1);
Today: 11/30/2008 12:00:00 AM
Tomorrow: 12/1/2008 12:00:00 AM
Description. This method and the

previous ones are static methods
because they do not require state to
be saved. DateTime.Today is not an
instance of the class. DateTime.Add
uses offsets, meaning it accepts both
negative and positive numbers. Here
we literally go back in time.
Using XML comments. The XML

comments here again will be useful if
you need to use this method in many
places. XML comments are not
always useful for private methods.
First day in year

Here we see how you can use a
simple helper method to find the first
day in a year. We use an overloaded
method here, which can make usage
of the methods easier as there are
fewer method names. If you want
the current year, don't call the above
method with a parameter. The
DateTime parameter of the second
DateTime method above can be any
time in the required year. It could be
a better design to simply pass it the
year as an int.
--- Program that uses new DateTime

[C#] ---
using System;
class Program
static void Main()
Console.WriteLine("First day:
{0}",
FirstDayOfYear());
DateTime d = new
DateTime(1999, 6, 1);
Console.WriteLine("First day of
1999: {0}",
FirstDayOfYear(d));
/// <summary>
/// Gets the first day of the current

year.
/// </summary>
static DateTime FirstDayOfYear()

{
return
FirstDayOfYear(DateTime.Today);
/// <summary>
/// Finds the first day of year of the

specified day.
/// </summary>
static DateTime
FirstDayOfYear(DateTime y)
return new DateTime(y.Year, 1,

1);
First day: 1/1/2008 12:00:00 AM
First day of 1999: 1/1/1999 12:00:00 AM
Last day in year

Here we see how to find the last day
in any year. Note that leap years
make this more complicated, as
February may have 28 or 29 days.
Because of leap year, you cannot use
the length of the year as a constant.
We can find it programmatically
using the new DateTime constructor.
This method is ideal for when you
want to count days, as for a
database range query for a certain
year.
--- Program that uses new DateTime

[C#] ---
using System;
class Program
static void Main()
Console.WriteLine("Last day:
{0}",
LastDayOfYear());
DateTime d = new
DateTime(1999, 6, 1);
Console.WriteLine("Last day of
1999: {0}",
LastDayOfYear(d));
/// <summary>
/// Finds the last day of the year for

today.
/// </summary>
static DateTime LastDayOfYear()
{
return
LastDayOfYear(DateTime.Today);
/// <summary>
/// Finds the last day of the year for

the selected day's year.
/// </summary>
static DateTime
LastDayOfYear(DateTime d)
// 1
// Get first of next year
DateTime n = new
DateTime(d.Year + 1, 1, 1);
// 2
// Subtract 1 from it
return n.AddDays(-1);
Last day: 12/31/2008 12:00:00 AM
Last day of 1999: 12/31/1999 12:00:00

AM
Description. We see two overloaded

methods here, which can make the
calling conventions more natural and
easier to remember. Recall that
overloaded methods are inferred at
compile time, not runtime. It is much
better to use the new DateTime
constructor, rather than
DateTime.Parse to create new
DateTimes. This is both for
performance and for simplicity of
syntax.
Find time elapsed since

date
Here we mention that you can find
the "age" of a certain date, and how
long ago it was in time. You can do
this with DateTime.Subtract, which
will return a TimeSpan.
See Days Elapsed From DateTime.
DateTime methods
In this section, we look at methods
on the DateTime type specifically.
Here are my notes on the DateTime
methods that are useful. This is not
exhaustive, but complementary to
MSDN.
See FromOADate and Excel Dates.
See DateTime.Parse String Method.
See DateTime.ParseExact Usage.
See DateTime Format.
DateTime.Add
This requires a TimeSpan
to be received. You will
need to use the TimeSpan
constructor first.
DateTime.AddDays
Receives a positive or
negative double integer,
which adds or subtracts
days. We see examples in
this document.
DateTime.AddHours
DateTime.AddMilliseconds
DateTime.AddMinutes
DateTime.AddMonths
DateTime.AddSeconds
DateTime.AddYears
These are self-explanatory
and receive a positive or
negative double, for
adding or subtracting the
specified part of the
DateTime.
DateTime.AddTicks
One tick is considered one
millisecond. This method
might be useful when
used with
Environment.AddTicks.
DateTime.Compare
DateTime.CompareTo
These tell you whether
one date is bigger or
smaller than another.
Mainly used for sorting.
However, you don't need
to implement a custom
sort for DateTime
normally.
DateTime.DaysInMonth
Helper method that will
tell you how many days
are in a month. I haven't
used it but it is useful to
know about.
DateTime.Equals
This is the sample as
op_Equality, the ==
operator.
DateTime.FromBinary
DateTime.ToBinary
Parses or creates a binary
date. You may have a
binary date if you have
serialized a date to a file.
I haven't used these.
DateTime.FromFileTime
DateTime.FromFileTimeUt
c
DateTime.ToFileTime
DateTime.ToFileTimeUtc
Use these for when you
have file times you need
to convert. I haven't used
this.
DateTime.FromOADate
DateTime.ToOADate
Useful for converting Excel
dates to C# dates. May
also be useful for Visual
FoxPro or Microsoft
Access. I have used this
for
Microsoft.Office.Excel.Inte
rop.
DateTime.GetDateTimeFor
mats
This provides functionality
related to formatting. It is
overloaded and may be
helpful rarely.
DateTime.GetDaylightSavi
ngTime
Daylight saving time is
what we get for letting
our politicians pretend to
be scientists. Not useful in
Arizona.
DateTime.IsLeapYear
Leap years have 29 days
in February. Leap year is
here to make
programmers' lives hard
and has very little other
impact.
DateTime.Subtract
Takes away one DateTime
or TimeSpan from the first
one. This isn't as useful as
the Add methods, as you
must provide a more
complex parameter.
DateTime.ToLocalTime
Normally your dates will
be in the local time, but if
you acquire an external
DateTime, you can
convert it to the local
timezone with this.
DateTime.Parse
DateTime.ParseExact
DateTime.TryParse
DateTime.TryParseExact
You will need to consult
MSDN for information on
exactly what formats can
be parsed. If you have
lots of invalid data, use
TryParse, as it will capture
its exceptions and
improve performance.
DateTime.ToString
DateTime.ToLongDateStri
ng
DateTime.ToLongTimeStri
ng
DateTime.ToShortDateStri
ng
DateTime.ToLongTimeStri
ng
For these ToString
methods, it is best to
simply experiment to find
the one you like best or
that is most compatible. I
also recommend checking
MSDN's articles on
DateTime format strings.
Description of method
signatures. Many of the methods
above receive a double type, which is
a numeric type used similarly to int.
Double values can store decimal
places.
See Numeric Casts and Numbers.
DayOfWeek property
You can find more detailed
information on the DayOfWeek
property on the DateTime instance,
which allows you to determine if a
date is a Monday, Tuesday,
Wednesday, Thursday, Friday,
Saturday, or Sunday. Please see the
specific article.
See DayOfWeek Enum.
Properties
In this section, we look at properties
on the DateTime type. These
properties, also listed at the link to
MSDN above, are useful abstractions
for getting specific aspects of your
DateTime. This table contains my
notes and a few hints.
See DateTime.Now for Getting

Current Time.
DateTime.Date
This returns only the date
component of the
DateTime. It has the
"time value set to
12:00:00 midnight
(00:00:00)." From
DateTime.Date Property
(System) at MSDN.
DateTime.Day
DateTime.DayOfWeek
DateTime.DayOfYear
DateTime.Hour
DateTime.Millisecond
DateTime.Minute
DateTime.Month
DateTime.Second
DateTime.Ticks
DateTime.TimeOfDay
DateTime.Year
These return a component
of the time. Note that this
is not the interval since
any other date. They just
return the single part of
the date. For example,
Day returns "the day
component, expressed as
a value between 1 and
31." From DateTime.Day
Property (System) at
MSDN.
DateTime.Today
This returns "a DateTime
set to today's date, with
the time component set to
00:00:00." From
DateTime.Today Property
(System) at MSDN.
DateTime.Now
DateTime.UtcNow
These return the current
DateTime, with all of the
fields correctly filled in.
DateTime.Now is one of
the most common
properties to use.
DateTime.Kind
Returns a DateTimeKind. I
recommend checking
MSDN for all the specifics,
as they are not useful for
me to repeat here.
Null DateTime structs

The DateTime struct in the C#
programming language is a value
type and not a reference type and for
this reason you cannot use a null
DateTime. You can either use a
nullable DateTime class or simply use
the DateTime.MinValue value to
indicate an empty DateTime. You can
find more information on DateTime
structs and the null value here.
See DateTime.MinValue (Null).

C# DateTime Format

Încărcat de

Informații document

Descriere originală:

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

C# DateTime Format

Încărcat de

Drepturi de autor:

Formate disponibile

C# DateTime Format

String Format for DateTime [C#]

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

Custom DateTime Formatting

// create date time 2008-03-09 16:05:07.123

String.Format("{0:y yy yyy yyyy}", dt); // "8 08 008 2008" year

// date separator in german culture is "." (so "/" changes to ".")

Here are some examples of custom date and time formatting:

// month/day numbers without/with leading zeroes

Standard DateTime Formatting

Specifier DateTimeFormatInfo property Pattern value (for en-US culture)

String.Format("{0:t}", dt); // "4:05 PM" ShortTime

Format your DateTimes for your application.

DateTime format string

=== Program that uses DateTime format [C#] ===

static void Main()

DateTime time = DateTime.Now; // Use current time

string format = "MMM ddd d HH:mm yyyy"; // Use this format

Console.WriteLine(time.ToString(format)); // Write to console

=== Output of the program ===

=== Format string pattern ===

MMM display three-letter month

ddd display three-letter day of the WEEK

d display day of the MONTH

HH display two-digit hours on 24-hour scale

mm display two-digit minutes

yyyy display four-digit year

Notes on the letters. The letters in the format string above specify

=== Program that uses different format [C#] ===

static void Main()

DateTime time = DateTime.Now; // Use current time

string format = "M d h:mm yy"; // Use this format

Console.WriteLine(time.ToString(format)); // Write to console

=== Output of the program ===

=== Format string pattern ===

M display one-digit month number [changed]

d display one-digit day of the MONTH [changed]

h display one-digit hour on 12-hour scale [changed]

mm display two-digit minutes

yy display two-digit year [changed]

Note on format string usages. You will also need to specify a format

=== Program that tests formats [C#] ===

static void Main()

DateTime now = DateTime.Now;

=== Output of the program ===

D Friday, February 27, 2009

f Friday, February 27, 2009 12:11 PM

U Friday, February 27, 2009 8:12:22 PM

=== Program that uses ToString methods [C#] ===

static void Main()

DateTime now = DateTime.Now;

=== Output of the program ===

ToLongDateString Friday, February 27, 2009

ToString 2/27/2009 12:16:59 PM

Note on default ToString method. The default ToString method on

See 24-Hour and Military Time Formats.

Difference between d and dd, ddd and dddd. It is important to note

=== Program that tests days [C#] ===

static void Main()

DateTime now = DateTime.Today;

for (int i = 0; i < 7; i++)

=== Output of the program ===

Display complete day