Udostępnij za pośrednictwem


Standardowe ciągi formatujące datę i godzinę

Standardowy ciąg formatu daty i godziny używa pojedynczego znaku jako specyfikatora formatu, aby zdefiniować reprezentację DateTime tekstową DateTimeOffset wartości lub. Dowolny ciąg formatu daty i godziny zawierający więcej niż jeden znak, w tym biały znak, jest interpretowany jako niestandardowy ciąg formatu daty i godziny. Ciągu formatu standardowego lub niestandardowego można używać na dwa sposoby:

  • Aby zdefiniować ciąg będący wynikiem operacji formatowania.

  • Aby zdefiniować tekstową reprezentację wartości daty i godziny, którą można przekonwertować na DateTime wartość lub DateTimeOffset za pomocą operacji analizy.

Porada

Możesz pobrać narzędzie formatowania, aplikację platformy .NET Windows Forms, która umożliwia stosowanie ciągów formatu do wartości liczbowych lub wartości daty i godziny oraz wyświetlania ciągu wynikowego. Kod źródłowy jest dostępny dla języka C# i Visual Basic.

Uwaga

Niektóre przykłady języka C# w tym artykule są uruchamiane w Try.NET wbudowanym modułem uruchamiającym kod i placem zabaw. Wybierz przycisk Uruchom , aby uruchomić przykład w oknie interaktywnym. Po wykonaniu kodu możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając ponownie pozycję Uruchom . Zmodyfikowany kod jest uruchamiany w oknie interaktywnym lub, jeśli kompilacja zakończy się niepowodzeniem, w oknie interaktywnym zostaną wyświetlone wszystkie komunikaty o błędach kompilatora języka C#.

Lokalna strefa czasowamodułu uruchamiającego kod Try.NET wbudowanego i placu zabaw to uniwersalny czas koordynowany lub UTC. Może to mieć wpływ na zachowanie i dane wyjściowe przykładów ilustrujących DateTimetypy , DateTimeOffseti TimeZoneInfo oraz ich składowe.

Specyfikatory formatu tabela

W poniższej tabeli opisano standardowe specyfikatory formatu daty i godziny. O ile nie określono inaczej, określony standardowy specyfikator formatu daty i godziny generuje identyczną reprezentację ciągu niezależnie od tego, czy jest używany z wartością DateTimeDateTimeOffset lub . Zobacz Panel sterowania Settings (Ustawienia) i DateTimeFormatInfo Properties (Właściwości dateTimeFormatInfo), aby uzyskać dodatkowe informacje na temat używania standardowych ciągów formatu daty i godziny.

Specyfikator formatu Opis Przykłady
„d” Wzorzec daty krótkiej.

Więcej informacji: Specyfikator formatu daty krótkiej ("d").
2009-06-15T13:45:30 -> 6/15/2009 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 (fr-FR)

2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)
„D” Wzorzec daty długiej.

Więcej informacji: Specyfikator formatu daty długiej ("D").
2009-06-15T13:45:30 —> poniedziałek, 15 czerwca 2009 r. (en-US)

2009-06-15T13:45:30 -> понедельник, 15 июня 2009 г. (ru-RU)

2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)
„f” Wzorzec pełnej daty/godziny (godzina krótka).

Więcej informacji: Specyfikator formatu pełnej daty krótkiej ("f").
2009-06-15T13:45:30 -> poniedziałek, 15 czerwca 2009 13:45 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45 (sv-SE)

2009-06-15T13:45:30 -> Δευτυρα, 15 Ιουνίου 2009 1:45 μμμ (el-GR)
„F” Wzorzec pełnej daty/godziny (godzina długa).

Więcej informacji: Specyfikator formatu daty pełnej daty długiej ("F").
2009-06-15T13:45:30 -> poniedziałek, 15 czerwca 2009 1:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτυρα, 15 Ιουνίου 2009 1:45:30 μμ (el-GR)
„g” Wzorzec ogólnej daty/godziny (godzina krótka).

Więcej informacji: Specyfikator formatu daty ogólnej daty krótkiej ("g").
2009-06-15T13:45:30 -> 15/15/2009 1:45 PM (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45 (zh-CN)
„G” Wzorzec ogólnej daty/godziny (godzina długa).

Więcej informacji: Specyfikator formatu daty ogólnej daty długiej ("G").
2009-06-15T13:45:30 -> 6/15/2009 1:45:30 PM (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45:30 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45:30 (zh-CN)
„M”, „m” Wzorzec miesiąc/dzień.

Więcej informacji: Specyfikator formatu miesiąca ("M", "m").
2009-06-15T13:45:30 —> 15 czerwca (en-US)

2009-06-15T13:45:30 -> 15. juni (da-DK)

2009-06-15T13:45:30 -> 15 Juni (id-ID)
„O”, „o” wzorzec daty/godziny rundy.

Więcej informacji: Specyfikator formatu rundy ("O", "o").
DateTime Wartości:

2009-06-15T13:45:30 (DateTimeKind.Local) --> 2009-06-15T13:45:30.0000000-07:00

2009-06-15T13:45:30 (DateTimeKind.Utc) -> 2009-06-15T13:45:30.0000000Z

2009-06-15T13:45:30 (DateTimeKind.Unspecified) -> 2009-06-15T13:45:30.0000000

DateTimeOffset Wartości:

2009-06-15T13:45:30-07:00 --> 2009-06-15T13:45:30.0000000-07:00
„R”, „r” Wzorzec RFC1123.

Więcej informacji: Specyfikator formatu RFC1123 ("R", "r").
DateTimeOffset input: 2009-06-15T13:45:30 -> Pon, 15 czerwca 2009 20:45:30 GMT
DateTime input: 2009-06-15T13:45:30 -> Pon, 15 czerwca 2009 13:45:30 GMT
„s” Wzorzec sortowalnej daty/godziny.

Więcej informacji: Specyfikator formatu sortowalnego ("s").
2009-06-15T13:45:30 (DateTimeKind.Local) -> 2009-06-15T13:45:30

2009-06-15T13:45:30 (DateTimeKind.Utc) —> 2009-06-15T13:45:30
„t” Wzorzec godziny krótkiej.

Więcej informacji: Specyfikator formatu czasu krótkiego ("t").
2009-06-15T13:45:30 -> 1:45 PM (en-US)

2009-06-15T13:45:30 -> 13:45 (hr-HR)

2009-06-15T13:45:30 -> 01:45 م (ar-EG)
„T” Wzorzec godziny długiej.

Więcej informacji: Specyfikator formatu długiego czasu ("T").
2009-06-15T13:45:30 -> 1:45:30 PM (en-US)

2009-06-15T13:45:30 -> 13:45:30 (hr-HR)

2009-06-15T13:45:30 -> 01:45:30 م (ar-EG)
„u” Wzorzec uniwersalnej sortowalnej daty/godziny.

Więcej informacji: specyfikator formatu uniwersalnego sortowalnego ("u").
Z wartością DateTime : 2009-06-15T13:45:30 -> 2009-06-15 13:45:30Z

Z wartością DateTimeOffset : 2009-06-15T13:45:30 -> 2009-06-15 20:45:30Z
„U” Wzorzec uniwersalnej pełnej daty/godziny.

Więcej informacji: Uniwersalny specyfikator formatu pełnego ("U").
2009-06-15T13:45:30 -> poniedziałek, 15 czerwca 2009 8:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 20:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτιρα, 15 Ιουνίου 2009 8:45:30 μμ (el-GR)
„Y”, „y” Wzorzec roku i miesiąca.

Więcej informacji: Specyfikator formatu miesiąca roku ("Y").
2009-06-15T13:45:30 –> czerwiec 2009 (en-US)

2009-06-15T13:45:30 -> juni 2009 (da-DK)

2009-06-15T13:45:30 —> Juni 2009 (id-ID)
Jakikolwiek inny pojedynczy znak Nieznany specyfikator. Zgłasza czas FormatExceptionwykonywania .

Jak działają standardowe ciągi formatu

W operacji formatowania ciąg formatu standardowego jest po prostu aliasem ciągu formatu niestandardowego. Zaletą użycia aliasu w celu odwołania się do ciągu formatu niestandardowego jest to, że ciąg formatu niestandardowego może być różny, mimo że alias pozostaje niezmienny. Jest to ważne, ponieważ ciągi reprezentujące wartości daty i godziny są zazwyczaj różne w zależności od kultury. Na przykład ciąg formatu standardowego „d” wskazuje, że wartość daty i godziny zostanie wyświetlona przy użyciu wzorca daty krótkiej. Ten wzorzec dla niezmiennej kultury to „MM/dd/yyyy”. Dla kultury fr-FR jest to „dd/MM/yyyy”. Dla kultury ja-JP jest to „yyyy/MM/dd”.

Jeśli ciąg formatu standardowego w operacji formatowania jest mapowany na ciąg formatu niestandardowego danej kultury, aplikacja może definiować określoną kulturę, której ciągi formatu niestandardowego są używane na jeden z poniższych sposobów:

  • Można użyć domyślnej (bieżącej) kultury. W poniższym przykładzie data jest wyświetlana przy użyciu formatu daty krótkiej dla bieżącej kultury. Bieżącą kulturą jest w tym przypadku kultura en-US.

    // 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
    
    ' Display using current (en-us) culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Console.WriteLine(thisDate.ToString("d"))     ' Displays 3/15/2008
    
  • Można przekazać obiekt reprezentujący kulturę CultureInfo , której formatowanie ma być używane do metody, która ma IFormatProvider parametr . W poniższym przykładzie data jest wyświetlana przy użyciu formatu daty krótkiej dla kultury pt-BR.

    // Display using pt-BR culture's short date format
    DateTime thisDate = new DateTime(2008, 3, 15);
    CultureInfo culture = new CultureInfo("pt-BR");
    Console.WriteLine(thisDate.ToString("d", culture));  // Displays 15/3/2008
    
    ' Display using pt-BR culture's short date format
    Dim thisDate As Date = #03/15/2008#
    Dim culture As New CultureInfo("pt-BR")
    Console.WriteLine(thisDate.ToString("d", culture))   ' Displays 15/3/2008
    
  • Obiekt, który udostępnia informacje o formatowaniu, można przekazać DateTimeFormatInfo do metody, która ma IFormatProvider parametr. Poniższy przykład przedstawia datę przy użyciu formatu daty krótkiej z DateTimeFormatInfo obiektu dla kultury hr-HR.

    // Display using date format information from hr-HR culture
    DateTime thisDate = new DateTime(2008, 3, 15);
    DateTimeFormatInfo fmt = (new CultureInfo("hr-HR")).DateTimeFormat;
    Console.WriteLine(thisDate.ToString("d", fmt));      // Displays 15.3.2008
    
    ' Display using date format information from hr-HR culture
    Dim thisDate As Date = #03/15/2008#
    Dim fmt As DateTimeFormatInfo = (New CultureInfo("hr-HR")).DateTimeFormat
    Console.WriteLine(thisDate.ToString("d", fmt))   ' Displays 15.3.2008
    

Uwaga

Aby uzyskać informacje na temat dostosowywania wzorców lub ciągów używanych w formatowaniu wartości daty i godziny, zobacz NumberFormatInfo temat klasy.

W niektórych przypadkach ciąg formatu standardowego służy jako wygodny skrót dla dłuższego ciągu formatu niestandardowego, który jest niezmienny. Cztery ciągi formatu standardowego należą do tej kategorii: „O” (lub „o”), „R” (lub „r”), „s” i „u”. Te ciągi odpowiadają ciągom formatów niestandardowych, które są zdefiniowane przez niezmienną kulturę. Wytwarzają one reprezentacje wartości daty i godziny w postaci ciągu, które mają być identyczne dla różnych kultur. W poniższej tabeli przedstawiono informacje dotyczące tych czterech ciągów standardowych formatów daty i godziny.

Ciąg formatu standardowego Definiowany przez właściwość DateTimeFormatInfo.InvariantInfo Ciąg formatu niestandardowego
„O” lub „o” Brak yyy'-'MM'-'dd'T'HH':'mm':'ss'"." fffffffK
„R” lub „r” RFC1123Pattern ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
„s” SortableDateTimePattern yyyy'-'MM'-'dd'T'HH':'mm':'ss
„u” UniversalSortableDateTimePattern yyyy'-'MM'-'dd HH':'mm':'ss'Z'

Standardowe ciągi formatu mogą być również używane w operacjach analizowania za pomocą DateTime.ParseExact metod lub DateTimeOffset.ParseExact , które wymagają ciągu wejściowego, aby dokładnie dopasować się do określonego wzorca operacji analizowania, aby operacja analizy zakończyła się powodzeniem. Wiele ciągów formatów standardowych jest mapowanych na wielu ciągów formatów niestandardowych, więc wartość daty i godziny może być reprezentowana przez wiele formatów, a operacja analizy i tak zakończy się powodzeniem. Można określić niestandardowy ciąg formatu lub ciągi, które odpowiadają standardowym ciągom formatu, wywołując metodę DateTimeFormatInfo.GetAllDateTimePatterns(Char) . W poniższym przykładzie są wyświetlane ciągi formatów niestandardowych mapowane na ciąg formatu standardowego „d” (wzorzec daty krótkiej).

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
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("'d' standard format string:")
        For Each customString In DateTimeFormatInfo.CurrentInfo.GetAllDateTimePatterns("d"c)
            Console.WriteLine("   {0}", customString)
        Next
    End Sub
End Module
' 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

W poniższych sekcjach opisano standardowe specyfikatory formatu dla DateTime wartości i DateTimeOffset .

Formaty dat

Ta grupa zawiera następujące formaty:

Specyfikator formatu daty krótkiej ("d")

Specyfikator formatu standardowego "d" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez właściwość określonej kultury DateTimeFormatInfo.ShortDatePattern . Na przykład ciąg formatu niestandardowego zwracany przez ShortDatePattern właściwość niezmiennej kultury to "MM/dd/rrrr".

W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu kontrolujące formatowanie zwracanego ciągu.

Właściwość Opis
ShortDatePattern Definiuje ogólny format ciągu wynikowego.
DateSeparator Określa ciąg, który oddziela składniki daty: rok, miesiąc i dzień.

W poniższym przykładzie użyto specyfikatora formatu „d”, aby wyświetlić wartość daty i godziny.

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
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("en-NZ")));
// Displays 10/04/2008
Console.WriteLine(date1.ToString("d",
                  CultureInfo.CreateSpecificCulture("de-DE")));
// Displays 10.04.2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("d", DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays 4/10/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("en-NZ")))
' Displays 10/04/2008                       
Console.WriteLine(date1.ToString("d", _
                  CultureInfo.CreateSpecificCulture("de-DE")))
' Displays 10.04.2008                       

Powrót do tabeli

Specyfikator formatu daty długiej ("D")

Specyfikator formatu standardowego "D" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez bieżącą DateTimeFormatInfo.LongDatePattern właściwość. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „dddd, dd MMMM yyyy”.

W poniższej tabeli wymieniono właściwości DateTimeFormatInfo obiektu kontrolujące formatowanie zwracanego ciągu.

Właściwość Opis
LongDatePattern Definiuje ogólny format ciągu wynikowego.
DayNames Definiuje zlokalizowane nazwy dni, które mogą być wyświetlane w ciągu wynikowym.
MonthNames Definiuje zlokalizowane nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.

W poniższym przykładzie użyto specyfikatora formatu „D”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10);
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("pt-BR")));
// Displays quinta-feira, 10 de abril de 2008
Console.WriteLine(date1.ToString("D",
                  CultureInfo.CreateSpecificCulture("es-MX")));
// Displays jueves, 10 de abril de 2008
Dim date1 As Date = #4/10/2008#
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("pt-BR")))
' Displays quinta-feira, 10 de abril de 2008                        
Console.WriteLine(date1.ToString("D", _
                  CultureInfo.CreateSpecificCulture("es-MX")))
' Displays jueves, 10 de abril de 2008                        

Powrót do tabeli

Formaty daty i godziny

Ta grupa zawiera następujące formaty:

Specyfikator formatu daty pełnej daty krótkiej ("f")

Specyfikator formatu standardowego „f” reprezentuje kombinację wzorców daty długiej („D”) i godziny krótkiej („t”), rozdzielonych spacją.

Ciąg wyniku ma wpływ na informacje dotyczące formatowania określonego DateTimeFormatInfo obiektu. W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez DateTimeFormatInfo.LongDatePattern właściwości i DateTimeFormatInfo.ShortTimePattern niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
LongDatePattern Definiuje format składnika daty w ciągu wynikowym.
ShortTimePattern Definiuje format składnika godziny w ciągu wynikowym.
DayNames Definiuje zlokalizowane nazwy dni, które mogą być wyświetlane w ciągu wynikowym.
MonthNames Definiuje zlokalizowane nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

W poniższym przykładzie użyto specyfikatora formatu „f”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30 AM
Console.WriteLine(date1.ToString("f",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30 AM                        
Console.WriteLine(date1.ToString("f", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30                       

Powrót do tabeli

Specyfikator formatu daty pełnej daty (F)

Specyfikator formatu standardowego "F" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez bieżącą DateTimeFormatInfo.FullDateTimePattern właściwość. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „dddd, dd MMMM yyyy HH:mm:ss”.

W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez FullDateTimePattern właściwość niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
FullDateTimePattern Definiuje ogólny format ciągu wynikowego.
DayNames Definiuje zlokalizowane nazwy dni, które mogą być wyświetlane w ciągu wynikowym.
MonthNames Definiuje zlokalizowane nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

W poniższym przykładzie użyto specyfikatora formatu „F”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays Thursday, April 10, 2008 6:30:00 AM
Console.WriteLine(date1.ToString("F",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays jeudi 10 avril 2008 06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("en-US")))
' Displays Thursday, April 10, 2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("F", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays jeudi 10 avril 2008 06:30:00                       

Powrót do tabeli

Specyfikator formatu daty ogólnej daty krótkiej ("g")

Specyfikator formatu standardowego „g” reprezentuje kombinację wzorców daty krótkiej („g”) i godziny krótkiej („t”), rozdzielonych spacją.

Ciąg wyniku ma wpływ na informacje dotyczące formatowania określonego DateTimeFormatInfo obiektu. W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez DateTimeFormatInfo.ShortDatePattern właściwości i DateTimeFormatInfo.ShortTimePattern niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
ShortDatePattern Definiuje format składnika daty w ciągu wynikowym.
ShortTimePattern Definiuje format składnika godziny w ciągu wynikowym.
DateSeparator Określa ciąg, który oddziela składniki daty: rok, miesiąc i dzień.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

W poniższym przykładzie użyto specyfikatora formatu „g”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("g",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30 AM
Console.WriteLine(date1.ToString("g",
                  CultureInfo.CreateSpecificCulture("fr-BE")));
// Displays 10/04/2008 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("g", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30                      
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30 AM                       
Console.WriteLine(date1.ToString("g", _
                  CultureInfo.CreateSpecificCulture("fr-BE")))
' Displays 10/04/2008 6:30                        

Powrót do tabeli

Specyfikator formatu daty ogólnej daty długiej ("G")

Specyfikator formatu standardowego „G” reprezentuje kombinację wzorców daty krótkiej („d”) i godziny długiej („T”), rozdzielonych spacją.

Ciąg wyniku ma wpływ na informacje dotyczące formatowania określonego DateTimeFormatInfo obiektu. W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez DateTimeFormatInfo.ShortDatePattern właściwości i DateTimeFormatInfo.LongTimePattern niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
ShortDatePattern Definiuje format składnika daty w ciągu wynikowym.
LongTimePattern Definiuje format składnika godziny w ciągu wynikowym.
DateSeparator Określa ciąg, który oddziela składniki daty: rok, miesiąc i dzień.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

W poniższym przykładzie użyto specyfikatora formatu „G”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("G",
                  DateTimeFormatInfo.InvariantInfo));
// Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 4/10/2008 6:30:00 AM
Console.WriteLine(date1.ToString("G",
                  CultureInfo.CreateSpecificCulture("nl-BE")));
// Displays 10/04/2008 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("G", _
                  DateTimeFormatInfo.InvariantInfo))
' Displays 04/10/2008 06:30:00
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 4/10/2008 6:30:00 AM                        
Console.WriteLine(date1.ToString("G", _
                  CultureInfo.CreateSpecificCulture("nl-BE")))
' Displays 10/04/2008 6:30:00                       

Powrót do tabeli

Specyfikator formatu round-trip ("O", "o")

Specyfikator formatu standardowego "O" lub "o" reprezentuje niestandardowy ciąg formatu daty i godziny przy użyciu wzorca, który zachowuje informacje o strefie czasowej i emituje ciąg wynikowy zgodny z normą ISO 8601. W przypadku DateTime wartości ten specyfikator formatu jest przeznaczony do zachowywania wartości daty i godziny wraz z właściwością DateTime.Kind w tekście. Sformatowany ciąg można przeanalizować za pomocą DateTime.Parse(String, IFormatProvider, DateTimeStyles) metody lub DateTime.ParseExact , jeśli styles parametr ma wartość DateTimeStyles.RoundtripKind.

Specyfikator formatu standardowego "O" lub "o" odpowiada specyfikatorowi formatu "rrrr'-'MM'-'dd'T'HH':'mm':'ss". ciąg formatu niestandardowego fffffK dla DateTime wartości i "yyyy'-'MM'-'dd'T'HH':'mm'ss". ciąg formatu niestandardowego fffffffzzz dla DateTimeOffset wartości. W tym ciągu pary znaków apostrofu, które oddzielają pojedyncze znaki, takie jak łączniki, dwukropki i litera „T”, wskazują, że indywidualny znak jest literałem, który nie może być zmieniony. Apostrofy nie znajdują się w ciągu wyjściowym.

Specyfikator formatu standardowego "O" lub "o" (i "rrrr'-'MM'-'dd'T'HH':'mm'ss'". Ciąg formatu niestandardowego fffffK) wykorzystuje trzy sposoby, na które iso 8601 reprezentuje informacje o strefie czasowej w celu zachowania Kind właściwości DateTime wartości:

  • Składnik strefy czasowej DateTimeKind.Local wartości daty i godziny jest przesunięciem od UTC (na przykład +01:00, -07:00). Wszystkie DateTimeOffset wartości są również reprezentowane w tym formacie.

  • Składnik strefy czasowej DateTimeKind.Utc wartości daty i godziny używa wartości "Z" (co oznacza zero przesunięcia) do reprezentowania czasu UTC.

  • DateTimeKind.Unspecified Wartości daty i godziny nie zawierają informacji o strefie czasowej.

Ponieważ specyfikator formatu standardowego "O" lub "o" jest zgodny ze standardem międzynarodowym, operacja formatowania lub analizowania, która używa specyfikatora, zawsze używa niezmiennej kultury i kalendarza gregoriańskiego.

Ciągi przekazywane do Parsemetod DateTimeOffsetDateTime , TryParse, ParseExacti TryParseExact mogą być analizowane przy użyciu specyfikatora formatu "O" lub "o", jeśli znajdują się w jednym z tych formatów. W przypadku DateTime obiektów wywołanie przeciążenia analizy powinno również zawierać styles parametr o wartości .DateTimeStyles.RoundtripKind Należy pamiętać, że jeśli wywołasz metodę analizowania z ciągiem formatu niestandardowego, który odpowiada specyfikatorowi formatu "O" lub "o", nie otrzymasz tych samych wyników co "O" lub "o". Jest to spowodowane tym, że metody analizowania, które używają ciągu formatu niestandardowego, nie mogą przeanalizować ciągu reprezentacji wartości daty i godziny, które nie mają składnika strefy czasowej lub używają ciągu "Z", aby wskazać utc.

W poniższym przykładzie użyto specyfikatora formatu "o", aby wyświetlić serię DateTime wartości i DateTimeOffset wartość w systemie w strefie czasowej Pacyfiku USA.

using System;

public class Example
{
   public static void Main()
   {
       DateTime dat = new DateTime(2009, 6, 15, 13, 45, 30,
                                   DateTimeKind.Unspecified);
       Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind);

       DateTime uDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Utc);
       Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind);

       DateTime lDat = new DateTime(2009, 6, 15, 13, 45, 30,
                                    DateTimeKind.Local);
       Console.WriteLine("{0} ({1}) --> {0:O}\n", lDat, lDat.Kind);

       DateTimeOffset dto = new DateTimeOffset(lDat);
       Console.WriteLine("{0} --> {0:O}", dto);
   }
}
// The example displays the following output:
//    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
//    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
//    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
//
//    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00
Module Example
    Public Sub Main()
        Dim dat As New Date(2009, 6, 15, 13, 45, 30,
                            DateTimeKind.Unspecified)
        Console.WriteLine("{0} ({1}) --> {0:O}", dat, dat.Kind)

        Dim uDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Utc)
        Console.WriteLine("{0} ({1}) --> {0:O}", uDat, uDat.Kind)

        Dim lDat As New Date(2009, 6, 15, 13, 45, 30, DateTimeKind.Local)
        Console.WriteLine("{0} ({1}) --> {0:O}", lDat, lDat.Kind)
        Console.WriteLine()

        Dim dto As New DateTimeOffset(lDat)
        Console.WriteLine("{0} --> {0:O}", dto)
    End Sub
End Module
' The example displays the following output:
'    6/15/2009 1:45:30 PM (Unspecified) --> 2009-06-15T13:45:30.0000000
'    6/15/2009 1:45:30 PM (Utc) --> 2009-06-15T13:45:30.0000000Z
'    6/15/2009 1:45:30 PM (Local) --> 2009-06-15T13:45:30.0000000-07:00
'    
'    6/15/2009 1:45:30 PM -07:00 --> 2009-06-15T13:45:30.0000000-07:00

W poniższym przykładzie użyto specyfikatora formatu "o", aby utworzyć sformatowany ciąg, a następnie przywróci oryginalną wartość daty i godziny przez wywołanie metody daty i godziny Parse .

// 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.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 12, 9, 30, 0), DateTimeKind.Utc);
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 time in an unspecified time zone.
originalDate = DateTime.SpecifyKind(new DateTime(2008, 4, 13, 12, 30, 0), DateTimeKind.Unspecified);
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 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);
// The example displays the following output:
//    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.
' Round-trip DateTime values.
Dim originalDate, newDate As Date
Dim dateString As String
' Round-trip a local time.
originalDate = Date.SpecifyKind(#4/10/2008 6:30AM#, DateTimeKind.Local)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip a UTC time.
originalDate = Date.SpecifyKind(#4/12/2008 9:30AM#, DateTimeKind.Utc)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)
' Round-trip time in an unspecified time zone.
originalDate = Date.SpecifyKind(#4/13/2008 12:30PM#, DateTimeKind.Unspecified)
dateString = originalDate.ToString("o")
newDate = Date.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} {1} to {2} {3}.", originalDate, originalDate.Kind, _
                  newDate, newDate.Kind)

' Round-trip a DateTimeOffset value.
Dim originalDTO As New DateTimeOffset(#4/12/2008 9:30AM#, New TimeSpan(-8, 0, 0))
dateString = originalDTO.ToString("o")
Dim newDTO As DateTimeOffset = DateTimeOffset.Parse(dateString, Nothing, DateTimeStyles.RoundtripKind)
Console.WriteLine("Round-tripped {0} to {1}.", originalDTO, newDTO)
' The example displays the following output:
'    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.

Powrót do tabeli

Specyfikator formatu RFC1123 ("R", "r")

Specyfikator formatu standardowego "R" lub "r" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez DateTimeFormatInfo.RFC1123Pattern właściwość. Wzorzec odzwierciedla zdefiniowany standard, a właściwość jest tylko do odczytu. Dlatego też zawsze jest taki sam, niezależnie od używanej kultury oraz dostarczonego dostawcy formatów. Ciąg formatu niestandardowego to „ddd, dd MMM yyyy HH':'mm':'ss 'GMT'”. Gdy jest używany ten specyfikator formatu standardowego, w operacji formatowania lub analizowania zawsze jest używana niezmienna kultura.

Ciąg wyniku ma wpływ na następujące właściwości DateTimeFormatInfo obiektu zwróconego przez DateTimeFormatInfo.InvariantInfo właściwość reprezentującą niezmienną kulturę.

Właściwość Opis
RFC1123Pattern Definiuje format ciągu wynikowego.
AbbreviatedDayNames Definiuje skrócone nazwy dni, które mogą być wyświetlane w ciągu wynikowym.
AbbreviatedMonthNames Definiuje skrócone nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.

Mimo że standard RFC 1123 wyraża czas jako uniwersalny czas koordynowany (UTC), operacja formatowania nie modyfikuje wartości DateTime obiektu, który jest sformatowany. W związku z tym należy przekonwertować DateTime wartość na UTC, wywołując metodę DateTime.ToUniversalTime przed wykonaniem operacji formatowania. DateTimeOffset Natomiast wartości wykonują tę konwersję automatycznie. Nie ma potrzeby wywoływania DateTimeOffset.ToUniversalTime metody przed operacją formatowania.

W poniższym przykładzie użyto specyfikatora formatu "r", aby wyświetlić DateTime wartość i DateTimeOffset w systemie w strefie czasowej Pacyfiku USA.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
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
Dim date1 As Date = #4/10/2008 6:30AM#
Dim dateOffset As 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                        

Powrót do tabeli

Specyfikator formatu sortowalnego ("s")

Specyfikator formatu standardowego "s" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez DateTimeFormatInfo.SortableDateTimePattern właściwość . Wzorzec odzwierciedla zdefiniowany standard (ISO 8601), a właściwość jest tylko do odczytu. Dlatego też zawsze jest taki sam, niezależnie od używanej kultury oraz dostarczonego dostawcy formatów. Ciąg formatu niestandardowego to „yyyy'-'MM'-'dd'T'HH':'mm':'ss”.

Celem specyfikatora formatu "s" jest wygenerowanie ciągów wynikowych, które są sortowane spójnie w kolejności rosnącej lub malejącej na podstawie wartości daty i godziny. W rezultacie, chociaż specyfikator formatu standardowego "s" reprezentuje wartość daty i godziny w spójnym formacie, operacja formatowania nie modyfikuje wartości obiektu daty i godziny sformatowanego w celu odzwierciedlenia jego DateTime.Kind właściwości lub DateTimeOffset.Offset jej wartości. Na przykład ciągi wynikowe generowane przez formatowanie wartości daty i godziny 2014-11-15T18:32:17+00:00 i 2014-11-15T18:32:17+08:00 są identyczne.

Gdy jest używany ten specyfikator formatu standardowego, w operacji formatowania lub analizowania zawsze jest używana niezmienna kultura.

W poniższym przykładzie użyto specyfikatora formatu "s", aby wyświetlić DateTime wartość i DateTimeOffset w systemie w strefie czasowej Pacyfik USA.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("s"));
// Displays 2008-04-10T06:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("s"))
' Displays 2008-04-10T06:30:00                       

Powrót do tabeli

Specyfikator formatu uniwersalnego sortowania ("u")

Specyfikator formatu standardowego "u" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez DateTimeFormatInfo.UniversalSortableDateTimePattern właściwość . Wzorzec odzwierciedla zdefiniowany standard, a właściwość jest tylko do odczytu. Dlatego też zawsze jest taki sam, niezależnie od używanej kultury oraz dostarczonego dostawcy formatów. Ciąg formatu niestandardowego to „yyyy'-'MM'-'dd HH':'mm':'ss'Z'”. Gdy jest używany ten specyfikator formatu standardowego, w operacji formatowania lub analizowania zawsze jest używana niezmienna kultura.

Mimo że ciąg wynikowy powinien wyrazić czas jako uniwersalny czas koordynowany (UTC), podczas operacji formatowania nie jest wykonywana konwersja oryginalnej DateTime wartości. W związku z tym należy przekonwertować wartość na czas UTC, wywołując metodę DateTimeDateTime.ToUniversalTime przed jej sformatowaniem. Z kolei DateTimeOffset wartości wykonują tę konwersję automatycznie; nie ma potrzeby wywoływania DateTimeOffset.ToUniversalTime metody przed operacją formatowania.

W poniższym przykładzie użyto specyfikatora formatu „u”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToUniversalTime().ToString("u"));
// Displays 2008-04-10 13:30:00Z
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToUniversalTime.ToString("u"))
' Displays 2008-04-10 13:30:00Z                       

Powrót do tabeli

Specyfikator uniwersalnego pełnego formatu ("U")

Specyfikator formatu standardowego "U" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez właściwość określonej kultury DateTimeFormatInfo.FullDateTimePattern . Wzorzec jest taki sam, jak wzorzec specyfikatora „F”. DateTime Jednak wartość jest automatycznie konwertowana na czas UTC, zanim zostanie sformatowana.

W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez FullDateTimePattern właściwość niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
FullDateTimePattern Definiuje ogólny format ciągu wynikowego.
DayNames Definiuje zlokalizowane nazwy dni, które mogą być wyświetlane w ciągu wynikowym.
MonthNames Definiuje zlokalizowane nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

Specyfikator formatu "U" nie jest obsługiwany przez DateTimeOffset typ i zgłasza FormatException wartość , jeśli jest używany do formatowania DateTimeOffset wartości.

W poniższym przykładzie użyto specyfikatora formatu „U”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("U",
                  CultureInfo.CreateSpecificCulture("en-US")));
// 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
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("U", CultureInfo.CreateSpecificCulture("en-US")))
' 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                       

Powrót do tabeli

Formaty czasu

Ta grupa zawiera następujące formaty:

Specyfikator formatu czasu krótkiego ("t")

Specyfikator formatu standardowego "t" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez bieżącą DateTimeFormatInfo.ShortTimePattern właściwość. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „HH:mm”.

Ciąg wynikowy ma wpływ na informacje o formatowaniu określonego DateTimeFormatInfo obiektu. W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez DateTimeFormatInfo.ShortTimePattern właściwość niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
ShortTimePattern Definiuje format składnika godziny w ciągu wynikowym.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

W poniższym przykładzie użyto specyfikatora formatu „t”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30 AM
Console.WriteLine(date1.ToString("t",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30 AM                        
Console.WriteLine(date1.ToString("t", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30                      

Powrót do tabeli

Specyfikator formatu długiego czasu ("T")

Specyfikator formatu standardowego "T" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez właściwość określonej kultury DateTimeFormatInfo.LongTimePattern . Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „HH:mm:ss”.

W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu, które mogą kontrolować formatowanie zwracanego ciągu. Specyfikator formatu niestandardowego zwracany przez DateTimeFormatInfo.LongTimePattern właściwość niektórych kultur może nie używać wszystkich właściwości.

Właściwość Opis
LongTimePattern Definiuje format składnika godziny w ciągu wynikowym.
TimeSeparator Definiuje ciąg, który rozdziela składniki godziny, minuty i sekundy w ciągu reprezentującym godzinę.
AMDesignator Określa ciąg, który wskazuje czas od północy do południa (z wyłączeniem południa), w formacie 12-godzinnym.
PMDesignator Określa ciąg, który wskazuje czas od południa do północy (z wyłączeniem północy), w formacie 12-godzinnym.

W poniższym przykładzie użyto specyfikatora formatu „T”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays 6:30:00 AM
Console.WriteLine(date1.ToString("T",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays 6:30:00
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays 6:30:00 AM                       
Console.WriteLine(date1.ToString("T", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays 6:30:00                      

Powrót do tabeli

Częściowe formaty dat

Ta grupa zawiera następujące formaty:

Specyfikator formatu miesiąca ("M", "m")

Specyfikator formatu standardowego "M" lub "m" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez bieżącą DateTimeFormatInfo.MonthDayPattern właściwość. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „MMMM dd”.

W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu kontrolujące formatowanie zwracanego ciągu.

Właściwość Opis
MonthDayPattern Definiuje ogólny format ciągu wynikowego.
MonthNames Definiuje zlokalizowane nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.

W poniższym przykładzie użyto specyfikatora formatu „m”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("en-us")));
// Displays April 10
Console.WriteLine(date1.ToString("m",
                  CultureInfo.CreateSpecificCulture("ms-MY")));
// Displays 10 April
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("en-us")))
' Displays April 10                        
Console.WriteLine(date1.ToString("m", _
                  CultureInfo.CreateSpecificCulture("ms-MY")))
' Displays 10 April                       

Powrót do tabeli

Specyfikator formatu miesiąca roku ("Y", "y")

Specyfikator formatu standardowego "Y" lub "y" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez DateTimeFormatInfo.YearMonthPattern właściwość określonej kultury. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „yyyy MMMM”.

W poniższej tabeli wymieniono DateTimeFormatInfo właściwości obiektu kontrolujące formatowanie zwracanego ciągu.

Właściwość Opis
YearMonthPattern Definiuje ogólny format ciągu wynikowego.
MonthNames Definiuje zlokalizowane nazwy miesięcy, które mogą być wyświetlane w ciągu wynikowym.

W poniższym przykładzie użyto specyfikatora formatu „y”, aby wyświetlić wartość daty i godziny.

DateTime date1 = new DateTime(2008, 4, 10, 6, 30, 0);
Console.WriteLine(date1.ToString("Y",
                  CultureInfo.CreateSpecificCulture("en-US")));
// Displays April, 2008
Console.WriteLine(date1.ToString("y",
                  CultureInfo.CreateSpecificCulture("af-ZA")));
// Displays April 2008
Dim date1 As Date = #4/10/2008 6:30AM#
Console.WriteLine(date1.ToString("Y", CultureInfo.CreateSpecificCulture("en-US")))
' Displays April, 2008                       
Console.WriteLine(date1.ToString("y", CultureInfo.CreateSpecificCulture("af-ZA")))
' Displays April 2008                       

Powrót do tabeli

ustawienia Panel sterowania

W systemie Windows ustawienia w elemencie Opcje regionalne i językowe w Panel sterowania wpływają na ciąg wynikowy wygenerowany przez operację formatowania. Te ustawienia służą do inicjowania DateTimeFormatInfo obiektu skojarzonego z bieżącą kulturą, który udostępnia wartości używane do zarządzania formatowaniem. Na komputerach, na których są używane różne ustawienia, są generowane różne ciągi wynikowe.

Ponadto, jeśli używasz konstruktora CultureInfo(String) do utworzenia wystąpienia nowego CultureInfo obiektu, który reprezentuje tę samą kulturę co bieżąca kultura systemu, wszelkie dostosowania ustanowione przez element Opcje regionalne i językowe w Panel sterowania zostaną zastosowane do nowego CultureInfo obiektu. Konstruktor umożliwia CultureInfo(String, Boolean) utworzenie CultureInfo obiektu, który nie odzwierciedla dostosowań systemu.

Właściwości DateTimeFormatInfo

Formatowanie ma wpływ na właściwości bieżącego DateTimeFormatInfo obiektu, który jest dostarczany niejawnie przez bieżącą kulturę lub jawnie przez IFormatProvider parametr metody, która wywołuje formatowanie. Dla parametru IFormatProvider aplikacja powinna określić CultureInfo obiekt, który reprezentuje kulturę lub DateTimeFormatInfo obiekt, który reprezentuje konwencje formatowania daty i godziny określonej kultury. Wiele specyfikatorów standardowego formatu daty i godziny to aliasy wzorców formatowania zdefiniowanych przez właściwości bieżącego DateTimeFormatInfo obiektu. Aplikacja może zmienić wynik wygenerowany przez niektóre standardowe specyfikatory formatu daty i godziny, zmieniając odpowiednie wzorce formatu daty i godziny odpowiedniej DateTimeFormatInfo właściwości.

Zobacz też