DateTimeOffset.ToString Method

Reference

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Converts the value of the current DateTimeOffset object to its equivalent string representation.

Overloads

ToString()	Converts the value of the current DateTimeOffset object to its equivalent string representation.
ToString(IFormatProvider)	Converts the value of the current DateTimeOffset object to its equivalent string representation using the specified culture-specific formatting information.
ToString(String)	Converts the value of the current DateTimeOffset object to its equivalent string representation using the specified format.
ToString(String, IFormatProvider)	Converts the value of the current DateTimeOffset object to its equivalent string representation using the specified format and culture-specific format information.

ToString()

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Converts the value of the current DateTimeOffset object to its equivalent string representation.

public:
 override System::String ^ ToString();

public override string ToString ();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Returns

String

A string representation of a DateTimeOffset object that includes the offset appended at the end of the string.

Exceptions

ArgumentOutOfRangeException

The date and time is outside the range of dates supported by the calendar used by the current culture.

Examples

The following example illustrates calls to the ToString() method and displays its output on a system whose current culture is en-us.

DateTimeOffset thisDate;

// Show output for UTC time
thisDate = DateTimeOffset.UtcNow;
Console.WriteLine(thisDate.ToString());  // Displays 3/28/2007 7:13:50 PM +00:00

// Show output for local time
thisDate = DateTimeOffset.Now;
Console.WriteLine(thisDate.ToString());  // Displays 3/28/2007 12:13:50 PM -07:00

// Show output for arbitrary time offset
thisDate = thisDate.ToOffset(new TimeSpan(-5, 0, 0));
Console.WriteLine(thisDate.ToString());  // Displays 3/28/2007 2:13:50 PM -05:00

// Show output for UTC time
let thisDate = DateTimeOffset.UtcNow
printfn $"{thisDate.ToString()}"  // Displays 3/28/2007 7:13:50 PM +00:00

// Show output for local time
let thisDate = DateTimeOffset.Now
printfn $"{thisDate.ToString()}"  // Displays 3/28/2007 12:13:50 PM -07:00

// Show output for arbitrary time offset
let thisDate = thisDate.ToOffset(TimeSpan(-5, 0, 0))
printfn $"{thisDate.ToString()}"  // Displays 3/28/2007 2:13:50 PM -05:00

Dim thisDate As DateTimeOffset

' Show output for UTC time
thisDate = DateTimeOffset.UtcNow
Console.WriteLine(thisDate.ToString())  ' Displays 3/28/2007 7:13:50 PM +00:00

' Show output for local time 
thisDate = DateTimeOffset.Now
Console.WriteLine(thisDate.ToString())  ' Displays 3/28/2007 12:13:50 PM -07:00

' Show output for arbitrary time offset
thisDate = thisDate.ToOffset(new TimeSpan(-5, 0, 0))
Console.WriteLine(thisDate.ToString())  ' Displays 3/28/2007 2:13:50 PM -05:00

Remarks

The return value of this method is identical to that of the DateTime.ToString() method, except that it includes a space followed by the offset appended at the end of the string. In other words, it formats output using the short date pattern, the long time pattern, and the zzz custom format string, with each element separated from the previous element by a space. For example, if DateTime.ToString() returns a value of 1/12/2008 6:15:50 PM, ToString() returns a value of 1/12/2008 6:15:50 PM -08:00 for a time that is eight hours behind Coordinated Universal Time (UTC).

This method uses formatting information derived from the current culture. For more information, see CurrentCulture. Other overloads of the ToString method enable you to specify the culture whose formatting to use, and to define the output pattern of the DateTimeOffset value.

Notes to Callers

The ToString() method returns the string representation of the date and time in the calendar used by the current culture. If the value of the current DateTimeOffset instance is earlier than MinSupportedDateTime or later than MaxSupportedDateTime, the method throws an ArgumentOutOfRangeException. The following example provides an illustration. It attempts to format a date that is outside the range of the HijriCalendar class when the current culture is Arabic (Syria).

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      DateTimeOffset date1 = new DateTimeOffset(new DateTime(550, 1, 1),
                                                TimeSpan.Zero);
      CultureInfo dft;
      CultureInfo arSY = new CultureInfo("ar-SY");
      arSY.DateTimeFormat.Calendar = new HijriCalendar();

      // Change current culture to ar-SY.
      dft = Thread.CurrentThread.CurrentCulture;
      Thread.CurrentThread.CurrentCulture = arSY;

      // Display the date using the current culture's calendar.
      try {
         Console.WriteLine(date1.ToString());
      }
      catch (ArgumentOutOfRangeException) {
         Console.WriteLine("{0} is earlier than {1} or later than {2}",
                           date1.ToString("d", CultureInfo.InvariantCulture),
                           arSY.DateTimeFormat.Calendar.MinSupportedDateTime.ToString("d", CultureInfo.InvariantCulture),
                           arSY.DateTimeFormat.Calendar.MaxSupportedDateTime.ToString("d", CultureInfo.InvariantCulture));
      }

      // Restore the default culture.
      Thread.CurrentThread.CurrentCulture = dft;
   }
}
// The example displays the following output:
//    01/01/0550 is earlier than 07/18/0622 or later than 12/31/9999

open System
open System.Globalization
open System.Threading

let date1 = DateTimeOffset(DateTime(550, 1, 1), TimeSpan.Zero)

let arSY = CultureInfo "ar-SY"
arSY.DateTimeFormat.Calendar <- HijriCalendar()

// Change current culture to ar-SY.
let dft = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture <- arSY

// Display the date using the current culture's calendar.
try
    printfn $"{date1}"
with :? ArgumentOutOfRangeException ->
    printfn $"""{date1.ToString("d", CultureInfo.InvariantCulture)} is earlier than {arSY.DateTimeFormat.Calendar.MinSupportedDateTime.ToString("d", CultureInfo.InvariantCulture)} or later than {arSY.DateTimeFormat.Calendar.MaxSupportedDateTime.ToString("d", CultureInfo.InvariantCulture)}"""

// Restore the default culture.
Thread.CurrentThread.CurrentCulture <- dft

// The example displays the following output:
//    01/01/0550 is earlier than 07/18/0622 or later than 12/31/9999

Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim date1 As New DateTimeOffset(#1/1/550#, TimeSpan.Zero)
      Dim dft As CultureInfo
      Dim arSY As New CultureInfo("ar-SY")
      arSY.DateTimeFormat.Calendar = New HijriCalendar()
      
      ' Change current culture to ar-SY.
      dft = Thread.CurrentThread.CurrentCulture
      Thread.CurrentThread.CurrentCulture = arSY
      
      ' Display the date using the current culture's calendar.            
      Try
         Console.WriteLine(date1.ToString())
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine("{0} is earlier than {1:d} or later than {2:d}", _
                           date1.ToString("d", CultureInfo.InvariantCulture), _
                           arSY.DateTimeFormat.Calendar.MinSupportedDateTime.ToString("d", CultureInfo.InvariantCulture), _ 
                           arSY.DateTimeFormat.Calendar.MaxSupportedDateTime.ToString("d", CultureInfo.InvariantCulture)) 
      End Try
      
      ' Restore the default culture.
      Thread.CurrentThread.CurrentCulture = dft
   End Sub
End Module
' The example displays the following output:
'    01/01/0550 is earlier than 07/18/0622 or later than 12/31/9999

Applies to

ToString(IFormatProvider)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Converts the value of the current DateTimeOffset object to its equivalent string representation using the specified culture-specific formatting information.

public:
 System::String ^ ToString(IFormatProvider ^ formatProvider);

public string ToString (IFormatProvider formatProvider);

public string ToString (IFormatProvider? formatProvider);

override this.ToString : IFormatProvider -> string

Public Function ToString (formatProvider As IFormatProvider) As String

Parameters

formatProvider: IFormatProvider

An object that supplies culture-specific formatting information.

Returns

String

A string representation of the value of the current DateTimeOffset object, as specified by formatProvider.

Exceptions

ArgumentOutOfRangeException

The date and time is outside the range of dates supported by the calendar used by formatProvider.

Examples

The following example displays a DateTimeOffset object using CultureInfo objects that represent the invariant culture, as well as four other cultures.

CultureInfo[] cultures = new CultureInfo[] {CultureInfo.InvariantCulture,
                                           new CultureInfo("en-us"),
                                           new CultureInfo("fr-fr"),
                                           new CultureInfo("de-DE"),
                                           new CultureInfo("es-ES")};

DateTimeOffset thisDate = new DateTimeOffset(2007, 5, 1, 9, 0, 0,
                                             TimeSpan.Zero);

foreach (CultureInfo culture in cultures)
{
   string cultureName;
   if (string.IsNullOrEmpty(culture.Name))
      cultureName = culture.NativeName;
   else
      cultureName = culture.Name;

   Console.WriteLine("In {0}, {1}",
                     cultureName, thisDate.ToString(culture));
}
// The example produces the following output:
//    In Invariant Language (Invariant Country), 05/01/2007 09:00:00 +00:00
//    In en-US, 5/1/2007 9:00:00 AM +00:00
//    In fr-FR, 01/05/2007 09:00:00 +00:00
//    In de-DE, 01.05.2007 09:00:00 +00:00
//    In es-ES, 01/05/2007 9:00:00 +00:00

let cultures = 
    [| CultureInfo.InvariantCulture
       CultureInfo "en-us"
       CultureInfo "fr-fr"
       CultureInfo "de-DE"
       CultureInfo "es-ES" |]

let thisDate = DateTimeOffset(2007, 5, 1, 9, 0, 0, TimeSpan.Zero)

for culture in cultures do
    let cultureName = 
        if String.IsNullOrEmpty culture.Name then
            culture.NativeName
        else
            culture.Name
    printfn $"In {cultureName}, {thisDate.ToString culture}"

// The example produces the following output:
//    In Invariant Language (Invariant Country), 05/01/2007 09:00:00 +00:00
//    In en-US, 5/1/2007 9:00:00 AM +00:00
//    In fr-FR, 01/05/2007 09:00:00 +00:00
//    In de-DE, 01.05.2007 09:00:00 +00:00
//    In es-ES, 01/05/2007 9:00:00 +00:00

     Dim cultures() As CultureInfo = {CultureInfo.InvariantCulture, _
                                      New CultureInfo("en-us"), _
                                      New CultureInfo("fr-fr"), _
                                      New CultureInfo("de-DE"), _
                                      New CultureInfo("es-ES")}

     Dim thisDate As New DateTimeOffset(#5/1/2007 9:00AM#, TimeSpan.Zero)                                            

     For Each culture As CultureInfo In cultures
        Dim cultureName As String 
        If String.IsNullOrEmpty(culture.Name) Then
           cultureName = culture.NativeName
        Else
           cultureName = culture.Name
        End If
        Console.WriteLine("In {0}, {1}", _
                          cultureName, thisDate.ToString(culture))
     Next                                            
     ' The example produces the following output:
     '    In Invariant Language (Invariant Country), 05/01/2007 09:00:00 +00:00
     '    In en-US, 5/1/2007 9:00:00 AM +00:00
     '    In fr-FR, 01/05/2007 09:00:00 +00:00
     '    In de-DE, 01.05.2007 09:00:00 +00:00
     '    In es-ES, 01/05/2007 9:00:00 +00:00

Remarks

The return value of this method is identical to that of its equivalent overload of the DateTime.ToString method, except that it includes a space followed by the offset appended at the end of the string. In other words, it formats output using the short date pattern, the long time pattern, and the zzz custom format string, with each element separated from the previous element by a space.

The format of these three elements is defined by the formatProvider parameter. The formatProvider parameter can be either of the following:

A CultureInfo object that represents the culture whose formatting conventions are applied to the returned string. The DateTimeFormatInfo object returned by the CultureInfo.DateTimeFormat property defines the formatting of the returned string.
A DateTimeFormatInfo object that defines the format of date and time data.

If formatProvider is null, the DateTimeFormatInfo object associated with the current culture is used (see CurrentCulture).

Notes to Callers

The ToString(IFormatProvider) method returns the string representation of the date and time in the calendar used by the culture represented by the formatProvider parameter. Its calendar is defined by the Calendar property. If the value of the current DateTimeOffset instance is earlier than MinSupportedDateTime or later than MaxSupportedDateTime, the method throws an ArgumentOutOfRangeException. The following example provides an illustration. It attempts to format a date that is outside the range of the JapaneseCalendar class.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo jaJP = new CultureInfo("ja-JP");
      jaJP.DateTimeFormat.Calendar = new JapaneseCalendar();
      DateTimeOffset date1 = new DateTimeOffset(new DateTime(1867, 1, 1),
                                                TimeSpan.Zero);

      try {
         Console.WriteLine(date1.ToString(jaJP));
      }
      catch (ArgumentOutOfRangeException) {
         Console.WriteLine("{0:d} is earlier than {1:d} or later than {2:d}",
                           date1,
                           jaJP.DateTimeFormat.Calendar.MinSupportedDateTime,
                           jaJP.DateTimeFormat.Calendar.MaxSupportedDateTime);
      }
   }
}
// The example displays the following output:
//    1/1/1867 is earlier than 9/8/1868 or later than 12/31/9999

open System
open System.Globalization

let jaJP = CultureInfo "ja-JP"
jaJP.DateTimeFormat.Calendar <- JapaneseCalendar()
let date1 = DateTimeOffset(DateTime(1867, 1, 1), TimeSpan.Zero)

try
    printfn $"{date1.ToString jaJP}"
with :? ArgumentOutOfRangeException ->
    printfn $"{date1:d} is earlier than {jaJP.DateTimeFormat.Calendar.MinSupportedDateTime:d} or later than {jaJP.DateTimeFormat.Calendar.MaxSupportedDateTime:d}"

// The example displays the following output:
//    1/1/1867 is earlier than 9/8/1868 or later than 12/31/9999

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim jaJP As New CultureInfo("ja-JP")
      jaJP.DateTimeFormat.Calendar = New JapaneseCalendar() 
      Dim date1 As New DateTimeOffset(#01/01/1867#, TimeSpan.Zero)

      Try
         Console.WriteLine(date1.ToString(jaJP))
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine("{0:d} is earlier than {1:d} or later than {2:d}", _
                           date1, _
                           jaJP.DateTimeFormat.Calendar.MinSupportedDateTime, _ 
                           jaJP.DateTimeFormat.Calendar.MaxSupportedDateTime) 
      End Try
   End Sub
End Module
' The example displays the following output:
'    1/1/1867 is earlier than 9/8/1868 or later than 12/31/9999

Applies to

ToString(String)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Converts the value of the current DateTimeOffset object to its equivalent string representation using the specified format.

public:
 System::String ^ ToString(System::String ^ format);

public string ToString (string format);

public string ToString (string? format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parameters

format: String

A format string.

Returns

String

A string representation of the value of the current DateTimeOffset object, as specified by format.

Exceptions

FormatException

The length of format is one, and it is not one of the standard format specifier characters defined for DateTimeFormatInfo.

-or-

format does not contain a valid custom format pattern.

ArgumentOutOfRangeException

The date and time is outside the range of dates supported by the calendar used by the current culture.

Examples

The following example displays a DateTimeOffset object to the console using each of the standard date and time format specifiers. The output is formatted by using the en-us culture.

DateTimeOffset outputDate = new DateTimeOffset(2007, 10, 31, 21, 0, 0,
                                     new TimeSpan(-8, 0, 0));
string specifier;

// Output date using each standard date/time format specifier
specifier = "d";
// Displays   d: 10/31/2007
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "D";
// Displays   D: Wednesday, October 31, 2007
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "t";
// Displays   t: 9:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "T";
// Displays   T: 9:00:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "f";
// Displays   f: Wednesday, October 31, 2007 9:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "F";
// Displays   F: Wednesday, October 31, 2007 9:00:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "g";
// Displays   g: 10/31/2007 9:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "G";
// Displays   G: 10/31/2007 9:00:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "M";           // 'm' is identical
// Displays   M: October 31
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "R";           // 'r' is identical
// Displays   R: Thu, 01 Nov 2007 05:00:00 GMT
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "s";
// Displays   s: 2007-10-31T21:00:00
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

specifier = "u";
// Displays   u: 2007-11-01 05:00:00Z
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

// Specifier is not supported
specifier = "U";
try
{
   Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));
}
catch (FormatException)
{
   Console.WriteLine("{0}: Not supported.", specifier);
}

specifier = "Y";         // 'y' is identical
// Displays   Y: October, 2007
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier));

let outputDate = DateTimeOffset(2007, 10, 31, 21, 0, 0, TimeSpan(-8, 0, 0))

// Output date using each standard date/time format specifier
let specifier = "d"
// Displays   d: 10/31/2007
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "D"
// Displays   D: Wednesday, October 31, 2007
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "t"
// Displays   t: 9:00 PM
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "T"
// Displays   T: 9:00:00 PM
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "f"
// Displays   f: Wednesday, October 31, 2007 9:00 PM
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "F"
// Displays   F: Wednesday, October 31, 2007 9:00:00 PM
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "g"
// Displays   g: 10/31/2007 9:00 PM
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "G"
// Displays   G: 10/31/2007 9:00:00 PM
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "M"           // 'm' is identical
// Displays   M: October 31
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "R"           // 'r' is identical
// Displays   R: Thu, 01 Nov 2007 05:00:00 GMT
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "s"
// Displays   s: 2007-10-31T21:00:00
printfn $"{specifier}: {outputDate.ToString specifier}"

let specifier = "u"
// Displays   u: 2007-11-01 05:00:00Z
printfn $"{specifier}: {outputDate.ToString specifier}"

// Specifier is not supported
let specifier = "U"
try
    printfn $"{specifier}: {outputDate.ToString specifier}"
with :? FormatException ->
    printfn $"{specifier}: Not supported."

let specifier = "Y"         // 'y' is identical
// Displays   Y: October, 2007
printfn $"{specifier}: {outputDate.ToString specifier}"

Dim outputDate As New DateTimeOffset(#10/31/2007 9:00PM#, _
                                     New TimeSpan(-8, 0, 0))
Dim specifier As String 
      
' Output date using each standard date/time format specifier
specifier = "d"
' Displays   d: 10/31/2007
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "D"
' Displays   D: Wednesday, October 31, 2007
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "t"
' Displays   t: 9:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "T"
' Displays   T: 9:00:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "f"
' Displays   f: Wednesday, October 31, 2007 9:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "F"
' Displays   F: Wednesday, October 31, 2007 9:00:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "g"
' Displays   g: 10/31/2007 9:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "G"
' Displays   G: 10/31/2007 9:00:00 PM
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "M"           ' 'm' is identical
' Displays   M: October 31
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "R"           ' 'r' is identical
' Displays   R: Thu, 01 Nov 2007 05:00:00 GMT
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "s"
' Displays   s: 2007-10-31T21:00:00
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

specifier = "u"
' Displays   u: 2007-11-01 05:00:00Z
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 

' Specifier is not supported
specifier = "U"
Try
   Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier)) 
Catch e As FormatException
   Console.WriteLine("{0}: Not supported.", specifier)   
End Try

specifier = "Y"         ' 'y' is identical
' Displays   Y: October, 2007
Console.WriteLine("{0}: {1}", specifier, outputDate.ToString(specifier))

Remarks

The format parameter should contain either a single format specifier character (see Standard Date and Time Format Strings) or a custom format pattern (see Custom Date and Time Format Strings) that defines the format of the returned string. If format is a null or empty string (""), the DateTimeOffset value is output using the default format.

The following table shows the exact operation of certain format specifiers when used with DateTimeOffset, which differs from their behavior when used with DateTime.

Existing format specifier	New behavior
"K"	Designed to round-trip a date and time. With DateTimeOffset, maps to "zzz" (the offset is always displayed with hours and minutes). Note that "K" is a custom format specifier; it cannot appear as the single character in `format`.
"U"	Not supported.
"r"	Converts the DateTimeOffset object to Coordinated Universal Time (UTC) and outputs it using the custom format string `ddd, dd MMM yyyy HH:mm:ss GMT`.
"u"	Converts the DateTimeOffset object to UTC and outputs it using the format `yyyy-MM-dd HH:mm:ssZ`.

The remaining standard date and time format specifiers behave the same with the ToString(String) method as they do with the ToString method.

This method uses formatting information derived from the current culture. For more information, see CurrentCulture.

Notes to Callers

The ToString(String) method returns the string representation of the date and time in the calendar used by the current culture. If the value of the current DateTimeOffset instance is earlier than MinSupportedDateTime or later than MaxSupportedDateTime, the method throws an ArgumentOutOfRangeException. The following example provides an illustration. It attempts to format a date that is outside the range of the HebrewCalendar class when the current culture is Hebrew (Israel).

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      DateTimeOffset date1 = new DateTimeOffset(new DateTime(1550, 7, 21),
                                                TimeSpan.Zero);
      CultureInfo dft;
      CultureInfo heIL = new CultureInfo("he-IL");
      heIL.DateTimeFormat.Calendar = new HebrewCalendar();

      // Change current culture to he-IL.
      dft = Thread.CurrentThread.CurrentCulture;
      Thread.CurrentThread.CurrentCulture = heIL;

      // Display the date using the current culture's calendar.
      try {
         Console.WriteLine(date1.ToString("G"));
      }
      catch (ArgumentOutOfRangeException) {
         Console.WriteLine("{0} is earlier than {1} or later than {2}",
                           date1.ToString("d", CultureInfo.InvariantCulture),
                           heIL.DateTimeFormat.Calendar.MinSupportedDateTime.ToString("d", CultureInfo.InvariantCulture),
                           heIL.DateTimeFormat.Calendar.MaxSupportedDateTime.ToString("d", CultureInfo.InvariantCulture));
      }

      // Restore the default culture.
      Thread.CurrentThread.CurrentCulture = dft;
   }
}
// The example displays the following output:
//    07/21/1550 is earlier than 01/01/1583 or later than 09/29/2239

open System
open System.Globalization
open System.Threading

let date1 = DateTimeOffset(DateTime(1550, 7, 21), TimeSpan.Zero)

let heIL = CultureInfo "he-IL"
heIL.DateTimeFormat.Calendar <- HebrewCalendar()

// Change current culture to he-IL.
let dft = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture <- heIL

// Display the date using the current culture's calendar.
try
    printfn $"{date1:G}"
with :? ArgumentOutOfRangeException ->
    printfn $"""{date1.ToString("d", CultureInfo.InvariantCulture)} is earlier than {heIL.DateTimeFormat.Calendar.MinSupportedDateTime.ToString("d", CultureInfo.InvariantCulture)} or later than {heIL.DateTimeFormat.Calendar.MaxSupportedDateTime.ToString("d", CultureInfo.InvariantCulture)}"""

// Restore the default culture.
Thread.CurrentThread.CurrentCulture <- dft

// The example displays the following output:
//    07/21/1550 is earlier than 01/01/1583 or later than 09/29/2239

Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim date1 As New DateTimeOffset(#7/21/1550#, TimeSpan.Zero)
      Dim dft As CultureInfo
      Dim heIL As New CultureInfo("he-IL")
      heIL.DateTimeFormat.Calendar = New HebrewCalendar()
      
      ' Change current culture to he-IL.
      dft = Thread.CurrentThread.CurrentCulture
      Thread.CurrentThread.CurrentCulture = heIL
      
      ' Display the date using the current culture's calendar.            
      Try
         Console.WriteLine(date1.ToString("G"))
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine("{0} is earlier than {1} or later than {2}", _
                           date1.ToString("d", CultureInfo.InvariantCulture), _
                           heIL.DateTimeFormat.Calendar.MinSupportedDateTime.ToString("d", CultureInfo.InvariantCulture), _ 
                           heIL.DateTimeFormat.Calendar.MaxSupportedDateTime.ToString("d", CultureInfo.InvariantCulture)) 
      End Try
      
      ' Restore the default culture.
      Thread.CurrentThread.CurrentCulture = dft
   End Sub
End Module
' The example displays the following output:
'    07/21/1550 is earlier than 01/01/1583 or later than 09/29/2239

Applies to

ToString(String, IFormatProvider)

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Source:: DateTimeOffset.cs

Converts the value of the current DateTimeOffset object to its equivalent string representation using the specified format and culture-specific format information.

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ formatProvider);

public string ToString (string format, IFormatProvider formatProvider);

public string ToString (string? format, IFormatProvider? formatProvider);

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, formatProvider As IFormatProvider) As String

Parameters

format: String

A format string.

formatProvider: IFormatProvider

An object that supplies culture-specific formatting information.

Returns

String

A string representation of the value of the current DateTimeOffset object, as specified by format and formatProvider.

Implements

ToString(String, IFormatProvider)

Exceptions

FormatException

The length of format is one, and it is not one of the standard format specifier characters defined for DateTimeFormatInfo.

-or-

format does not contain a valid custom format pattern.

ArgumentOutOfRangeException

The date and time is outside the range of dates supported by the calendar used by formatProvider.

Examples

The following example uses the ToString(String, IFormatProvider) method to display a DateTimeOffset object using a custom format string for several different cultures.

DateTimeOffset outputDate = new DateTimeOffset(2007, 11, 1, 9, 0, 0,
                                     new TimeSpan(-7, 0, 0));
string format = "dddd, MMM dd yyyy HH:mm:ss zzz";

// Output date and time using custom format specification
Console.WriteLine(outputDate.ToString(format, null as DateTimeFormatInfo));
Console.WriteLine(outputDate.ToString(format, CultureInfo.InvariantCulture));
Console.WriteLine(outputDate.ToString(format,
                                      new CultureInfo("fr-FR")));
Console.WriteLine(outputDate.ToString(format,
                                      new CultureInfo("es-ES")));
// The example displays the following output to the console:
//    Thursday, Nov 01 2007 09:00:00 -07:00
//    Thursday, Nov 01 2007 09:00:00 -07:00
//    jeudi, nov. 01 2007 09:00:00 -07:00
//    jueves, nov 01 2007 09:00:00 -07:00

let outputDate = DateTimeOffset(2007, 11, 1, 9, 0, 0, TimeSpan(-7, 0, 0))
let format = "dddd, MMM dd yyyy HH:mm:ss zzz"

// Output date and time using custom format specification
printfn $"{outputDate.ToString(format, null)}"
printfn $"{outputDate.ToString(format, CultureInfo.InvariantCulture)}"
printfn $"""{outputDate.ToString(format, CultureInfo "fr-FR")}"""
printfn $"""{outputDate.ToString(format, CultureInfo "es-ES")}"""

// The example displays the following output to the console:
//    Thursday, Nov 01 2007 09:00:00 -07:00
//    Thursday, Nov 01 2007 09:00:00 -07:00
//    jeudi, nov. 01 2007 09:00:00 -07:00
//    jueves, nov 01 2007 09:00:00 -07:00

Dim outputDate As New DateTimeOffset(#11/1/2007 9:00AM#, _
                                     New TimeSpan(-7, 0, 0)) 
Dim format As String = "dddd, MMM dd yyyy HH:mm:ss zzz"

' Output date and time using custom format specification
Console.WriteLine(outputDate.ToString(format, Nothing))
Console.WriteLine(outputDate.ToString(format, CultureInfo.InvariantCulture))
Console.WriteLine(outputDate.ToString(format, _
                                      New CultureInfo("fr-FR")))
Console.WriteLine(outputDate.ToString(format, _
                                      New CultureInfo("es-ES")))
' The example displays the following output to the console:
'    Thursday, Nov 01 2007 09:00:00 -07:00
'    Thursday, Nov 01 2007 09:00:00 -07:00
'    jeudi, nov. 01 2007 09:00:00 -07:00
'    jueves, nov 01 2007 09:00:00 -07:00

Remarks

The format parameter should contain either a single format specifier character (see Standard Date and Time Format Strings) or a custom format pattern (see Custom Date and Time Format Strings). If format is a null or empty string (""), the DateTimeOffset object is output using the default format.

The following table shows the exact operation of certain format specifiers when used with DateTimeOffset, which differs from their behavior when used with DateTime.

Existing format specifier	New behavior
"K"	Designed to round-trip a date and time. With DateTimeOffset, maps to "zzz" (the offset is always displayed with hours and minutes). Note that "K" is a custom format specifier; it cannot appear as the single character in `format`.
"U"	Not supported.
"r"	Converts the DateTimeOffset object to Coordinated Universal Time (UTC) and outputs it using the custom format string `ddd, dd MMM yyyy HH:mm:ss GMT`.
"u"	Converts the DateTimeOffset value to UTC and outputs it using the format `yyyy-MM-dd HH:mm:ssZ`.

The remaining standard date and time format specifiers behave the same with the ToString(String) method as they do with the ToString method.

The pattern that corresponds to standard format specifiers, as well as the symbols and names of date and time components, is defined by the formatProvider parameter. The formatProvider parameter can be either of the following:

A CultureInfo object that represents the culture whose formatting is used in input. The DateTimeFormatInfo object returned by the CultureInfo.DateTimeFormat property defines the formatting used in input.
A DateTimeFormatInfo object that defines the format of date and time data.

If formatProvider is null, the DateTimeFormatInfo object associated with the current culture is used (see CurrentCulture).

Notes to Callers

The ToString(String, IFormatProvider) method returns the string representation of the date and time in the calendar used by the formatProvider parameter. Its calendar is defined by the Calendar property. If the value of the current DateTimeOffset instance is earlier than MinSupportedDateTime or later than MaxSupportedDateTime, the method throws an ArgumentOutOfRangeException. The following example provides an illustration. It attempts to format a date that is outside the range of the UmAlQuraCalendar class.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo arSA = new CultureInfo("ar-SA");
      arSA.DateTimeFormat.Calendar = new UmAlQuraCalendar();
      DateTimeOffset date1 = new DateTimeOffset(new DateTime(1890, 9, 10),
                                                TimeSpan.Zero);

      try {
         Console.WriteLine(date1.ToString("d", arSA));
      }
      catch (ArgumentOutOfRangeException) {
         Console.WriteLine("{0:d} is earlier than {1:d} or later than {2:d}",
                           date1,
                           arSA.DateTimeFormat.Calendar.MinSupportedDateTime,
                           arSA.DateTimeFormat.Calendar.MaxSupportedDateTime);
      }
   }
}
// The example displays the following output:
//    9/10/1890 is earlier than 4/30/1900 or later than 5/13/2029

open System
open System.Globalization

let arSA = CultureInfo "ar-SA"
arSA.DateTimeFormat.Calendar <- UmAlQuraCalendar()
let date1 = DateTimeOffset(DateTime(1890, 9, 10), TimeSpan.Zero)

try
    printfn $"""{date1.ToString("d", arSA)}"""
with :? ArgumentOutOfRangeException ->
    printfn $"{date1:d} is earlier than {arSA.DateTimeFormat.Calendar.MinSupportedDateTime:d} or later than {arSA.DateTimeFormat.Calendar.MaxSupportedDateTime:d}"

// The example displays the following output:
//    9/10/1890 is earlier than 4/30/1900 or later than 11/16/2077

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim arSA As New CultureInfo("ar-SA")
      arSA.DateTimeFormat.Calendar = New UmAlQuraCalendar() 
      Dim date1 As New DateTimeOffset(#09/10/1890#, TimeSpan.Zero)

      Try
         Console.WriteLine(date1.ToString("d", arSA))
      Catch e As ArgumentOutOfRangeException
         Console.WriteLine("{0:d} is earlier than {1:d} or later than {2:d}", _
                           date1, _
                           arSA.DateTimeFormat.Calendar.MinSupportedDateTime, _ 
                           arSA.DateTimeFormat.Calendar.MaxSupportedDateTime) 
      End Try
   End Sub
End Module
' The example displays the following output:
'    9/10/1890 is earlier than 4/30/1900 or later than 5/13/2029

Applies to

Share via

DateTimeOffset.ToString Method

Definition

Overloads

ToString()

Returns

Exceptions

Examples

Remarks

Notes to Callers

Applies to

ToString(IFormatProvider)

Parameters

Returns

Exceptions

Examples

Remarks

Notes to Callers

Applies to

ToString(String)

Parameters

Returns

Exceptions

Examples

Remarks

Notes to Callers

See also

Applies to

ToString(String, IFormatProvider)

Parameters

Returns

Implements

Exceptions

Examples

Remarks

Notes to Callers

See also

Applies to

Aanvullende resources