DateTimeOffset.ToString Methode

Definitie

Naamruimte:: System

Assembly's:: mscorlib.dll, System.Runtime.dll

Assembly's:: netstandard.dll, System.Runtime.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave.

Overloads

Name	Description
ToString()	Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave.
ToString(IFormatProvider)	Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave met behulp van de opgegeven cultuurspecifieke opmaakinformatie.
ToString(String)	Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave met behulp van de opgegeven indeling.
ToString(String, IFormatProvider)	Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave met behulp van de opgegeven notatie- en cultuurspecifieke indelingsgegevens.

ToString()

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave.

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

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Retouren

String

Een tekenreeksweergave van een DateTimeOffset object dat de offset bevat die aan het einde van de tekenreeks is toegevoegd.

Uitzonderingen

ArgumentOutOfRangeException

De datum en tijd vallen buiten het datumbereik dat wordt ondersteund door de kalender die door de huidige cultuur wordt gebruikt.

Voorbeelden

In het volgende voorbeeld ziet u aanroepen naar de ToString() methode en wordt de uitvoer weergegeven op een systeem waarvan de huidige cultuur 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

Opmerkingen

De retourwaarde van deze methode is identiek aan die van de DateTime.ToString() methode, behalve dat deze een spatie bevat, gevolgd door de offset die aan het einde van de tekenreeks is toegevoegd. Met andere woorden, het formatteert uitvoer met behulp van het korte datumpatroon, het lange tijdpatroon en de zzz tekenreeks voor aangepaste notatie, waarbij elk element is gescheiden van het vorige element door een spatie. Als bijvoorbeeld DateTime.ToString() een waarde van 1-12-2008 15:15:50 uur retourneert, ToString() wordt een waarde van 1-12-2008 15:50 -08:00 geretourneerd voor een tijd die acht uur achter Coordinated Universal Time (UTC) ligt.

Deze methode maakt gebruik van opmaakgegevens die zijn afgeleid van de huidige cultuur. Zie CurrentCulture voor meer informatie. Met andere overbelastingen van de ToString methode kunt u de cultuur opgeven waarvan de opmaak moet worden gebruikt en om het uitvoerpatroon van de DateTimeOffset waarde te definiëren.

Notities voor bellers

De ToString() methode retourneert de tekenreeksweergave van de datum en tijd in de kalender die door de huidige cultuur wordt gebruikt. Als de waarde van het huidige DateTimeOffset exemplaar ouder is dan MinSupportedDateTime of later dan MaxSupportedDateTime, genereert de methode een ArgumentOutOfRangeException. In het volgende voorbeeld ziet u een afbeelding. Het probeert een datum op te maken die buiten het bereik van de HijriCalendar klas valt wanneer de huidige cultuur Arabisch (Syrië) is.

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

Van toepassing op

ToString(IFormatProvider)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave met behulp van de opgegeven cultuurspecifieke opmaakinformatie.

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

Een object dat cultuurspecifieke opmaakinformatie levert.

Retouren

String

Een tekenreeksweergave van de waarde van het huidige DateTimeOffset object, zoals opgegeven door formatProvider.

Uitzonderingen

ArgumentOutOfRangeException

De datum en tijd vallen buiten het datumbereik dat wordt ondersteund door de kalender die wordt gebruikt door formatProvider.

Voorbeelden

In het volgende voorbeeld wordt een DateTimeOffset object weergegeven met behulp van CultureInfo objecten die de invariante cultuur vertegenwoordigen, evenals vier andere culturen.

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

Opmerkingen

De retourwaarde van deze methode is identiek aan die van de equivalente overbelasting van de DateTime.ToString methode, behalve dat deze een spatie bevat, gevolgd door de offset die aan het einde van de tekenreeks is toegevoegd. Met andere woorden, het formatteert uitvoer met behulp van het korte datumpatroon, het lange tijdpatroon en de zzz tekenreeks voor aangepaste notatie, waarbij elk element is gescheiden van het vorige element door een spatie.

De indeling van deze drie elementen wordt gedefinieerd door de formatProvider parameter. De formatProvider parameter kan een van de volgende zijn:

Een CultureInfo object dat de cultuur vertegenwoordigt waarvan de opmaakconventies worden toegepast op de geretourneerde tekenreeks. Het DateTimeFormatInfo object dat door de CultureInfo.DateTimeFormat eigenschap wordt geretourneerd, definieert de opmaak van de geretourneerde tekenreeks.
Een DateTimeFormatInfo object dat de notatie van datum- en tijdgegevens definieert.

Als formatProvider dat het is null, wordt het DateTimeFormatInfo object gebruikt dat is gekoppeld aan de huidige cultuur (zie CurrentCulture).

Notities voor bellers

De ToString(IFormatProvider) methode retourneert de tekenreeksweergave van de datum en tijd in de kalender die wordt gebruikt door de cultuur die wordt vertegenwoordigd door de formatProvider parameter. De agenda wordt gedefinieerd door de Calendar eigenschap. Als de waarde van het huidige DateTimeOffset exemplaar ouder is dan MinSupportedDateTime of later dan MaxSupportedDateTime, genereert de methode een ArgumentOutOfRangeException. In het volgende voorbeeld ziet u een afbeelding. Er wordt geprobeerd een datum op te maken die buiten het bereik van de JapaneseCalendar klasse valt.

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

Van toepassing op

ToString(String)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave met behulp van de opgegeven indeling.

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

Een notatietekenreeks.

Retouren

String

Een tekenreeksweergave van de waarde van het huidige DateTimeOffset object, zoals opgegeven door format.

Uitzonderingen

FormatException

De lengte is format één, en het is niet een van de standaardnotatieaanduidingstekens die zijn gedefinieerd voor DateTimeFormatInfo.

– of –

format bevat geen geldig aangepast opmaakpatroon.

ArgumentOutOfRangeException

De datum en tijd vallen buiten het datumbereik dat wordt ondersteund door de kalender die door de huidige cultuur wordt gebruikt.

Voorbeelden

In het volgende voorbeeld wordt een DateTimeOffset object weergegeven in de console met behulp van de standaardaanduidingen voor datum- en tijdnotatie. De uitvoer wordt opgemaakt met behulp van de en-us cultuur.

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

Opmerkingen

De format parameter moet een teken voor één opmaakaanduiding bevatten (zie Standaardtekenreeksen voor datum- en tijdnotatie) of een aangepast notatiepatroon (zie Tekenreeksen voor aangepaste datum- en tijdnotatie) waarmee de indeling van de geretourneerde tekenreeks wordt gedefinieerd. Als format een null- of lege tekenreeks (""), wordt de DateTimeOffset waarde uitgevoerd met behulp van de standaardindeling.

In de volgende tabel ziet u de exacte werking van bepaalde notatieaanduidingen bij gebruik met DateTimeOffset, wat verschilt van hun gedrag bij gebruik met DateTime.

Bestaande opmaakaanduiding	Nieuw gedrag
"K"	Ontworpen om een datum en tijd af te ronden. Hiermee DateTimeOffsetwordt toegewezen aan 'zzz' (de offset wordt altijd weergegeven met uren en minuten). Houd er rekening mee dat K een aangepaste notatieaanduiding is; het kan niet worden weergegeven als één teken in `format`.
"U"	Wordt niet ondersteund.
"r"	Converteert het DateTimeOffset object naar Coordinated Universal Time (UTC) en voert het uit met behulp van de tekenreeks `ddd, dd MMM yyyy HH:mm:ss GMT`voor aangepaste notatie.
u	Converteert het DateTimeOffset object naar UTC en voert het uit met behulp van de indeling `yyyy-MM-dd HH:mm:ssZ`.

De overige standaardaanduidingen voor datum- en tijdnotatie gedragen zich hetzelfde met de ToString(String) methode als bij de ToString methode.

Deze methode maakt gebruik van opmaakgegevens die zijn afgeleid van de huidige cultuur. Zie CurrentCulture voor meer informatie.

Notities voor bellers

De ToString(String) methode retourneert de tekenreeksweergave van de datum en tijd in de kalender die door de huidige cultuur wordt gebruikt. Als de waarde van het huidige DateTimeOffset exemplaar ouder is dan MinSupportedDateTime of later dan MaxSupportedDateTime, genereert de methode een ArgumentOutOfRangeException. In het volgende voorbeeld ziet u een afbeelding. Het probeert een datum op te maken die buiten het bereik van de HebrewCalendar klasse valt wanneer de huidige cultuur Hebreeuws (Israël) is.

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

Zie ook

Van toepassing op

ToString(String, IFormatProvider)

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Bron:: DateTimeOffset.cs

Converteert de waarde van het huidige DateTimeOffset object naar de equivalente tekenreeksweergave met behulp van de opgegeven notatie- en cultuurspecifieke indelingsgegevens.

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

Een notatietekenreeks.

formatProvider: IFormatProvider

Een object dat cultuurspecifieke opmaakinformatie levert.

Retouren

String

Een tekenreeksweergave van de waarde van het huidige DateTimeOffset object, zoals opgegeven door format en formatProvider.

Implementeringen

ToString(String, IFormatProvider)

Uitzonderingen

FormatException

De lengte is format één, en het is niet een van de standaardnotatieaanduidingstekens die zijn gedefinieerd voor DateTimeFormatInfo.

– of –

format bevat geen geldig aangepast opmaakpatroon.

ArgumentOutOfRangeException

De datum en tijd vallen buiten het datumbereik dat wordt ondersteund door de kalender die wordt gebruikt door formatProvider.

Voorbeelden

In het volgende voorbeeld wordt de ToString(String, IFormatProvider) methode gebruikt om een DateTimeOffset object weer te geven met behulp van een tekenreeks voor aangepaste notatie voor verschillende culturen.

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

Opmerkingen

De format parameter moet een teken voor één opmaakaanduiding bevatten (zie Standaardtekenreeksen voor datum- en tijdnotatie) of een aangepast notatiepatroon (zie Tekenreeksen voor aangepaste datum- en tijdnotatie). Als format het een null- of lege tekenreeks ("") is, wordt het DateTimeOffset object uitgevoerd met behulp van de standaardindeling.

In de volgende tabel ziet u de exacte werking van bepaalde notatieaanduidingen bij gebruik met DateTimeOffset, wat verschilt van hun gedrag bij gebruik met DateTime.

Bestaande opmaakaanduiding	Nieuw gedrag
"K"	Ontworpen om een datum en tijd af te ronden. Hiermee DateTimeOffsetwordt toegewezen aan 'zzz' (de offset wordt altijd weergegeven met uren en minuten). Houd er rekening mee dat K een aangepaste notatieaanduiding is; het kan niet worden weergegeven als één teken in `format`.
"U"	Wordt niet ondersteund.
"r"	Converteert het DateTimeOffset object naar Coordinated Universal Time (UTC) en voert het uit met behulp van de tekenreeks `ddd, dd MMM yyyy HH:mm:ss GMT`voor aangepaste notatie.
u	Converteert de DateTimeOffset waarde naar UTC en voert deze uit met behulp van de indeling `yyyy-MM-dd HH:mm:ssZ`.

De overige standaardaanduidingen voor datum- en tijdnotatie gedragen zich hetzelfde met de ToString(String) methode als bij de ToString methode.

Het patroon dat overeenkomt met standaardnotatieaanduidingen, evenals de symbolen en namen van datum- en tijdonderdelen, wordt gedefinieerd door de formatProvider parameter. De formatProvider parameter kan een van de volgende zijn:

Een CultureInfo object dat de cultuur vertegenwoordigt waarvan de opmaak wordt gebruikt in input. Het DateTimeFormatInfo object dat door de CultureInfo.DateTimeFormat eigenschap wordt geretourneerd, definieert de opmaak die wordt gebruikt in input.
Een DateTimeFormatInfo object dat de notatie van datum- en tijdgegevens definieert.

Als formatProvider dat het is null, wordt het DateTimeFormatInfo object gebruikt dat is gekoppeld aan de huidige cultuur (zie CurrentCulture).

Notities voor bellers

De ToString(String, IFormatProvider) methode retourneert de tekenreeksweergave van de datum en tijd in de kalender die door de formatProvider parameter wordt gebruikt. De agenda wordt gedefinieerd door de Calendar eigenschap. Als de waarde van het huidige DateTimeOffset exemplaar ouder is dan MinSupportedDateTime of later dan MaxSupportedDateTime, genereert de methode een ArgumentOutOfRangeException. In het volgende voorbeeld ziet u een afbeelding. Er wordt geprobeerd een datum op te maken die buiten het bereik van de UmAlQuraCalendar klasse valt.

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

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?