DateTimeFormatInfo Klasa

Definicja

Zawiera informacje specyficzne dla kultury dotyczące formatu wartości daty i godziny.Provides culture-specific information about the format of date and time values.

public ref class DateTimeFormatInfo sealed : IFormatProvider
public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider
public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider, System::Runtime::Serialization::ISerializable
public sealed class DateTimeFormatInfo : IFormatProvider
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider, System.Runtime.Serialization.ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
    interface ISerializable
Public NotInheritable Class DateTimeFormatInfo
Implements IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable
Dziedziczenie
DateTimeFormatInfo
Atrybuty
Implementuje

Przykłady

Poniższy przykład używa odbicia w celu uzyskania właściwości obiektu DateTimeFormatInfo dla kultury angielskiej (Stany Zjednoczone).The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Wyświetla wartości tych właściwości, które zawierają ciągi formatu niestandardowego i używa tych ciągów do wyświetlania sformatowanych dat.It displays the value of those properties that contain custom format strings and uses those strings to display formatted dates.

using System;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get the properties of an en-US DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo("en-US").DateTimeFormat;
      Type typ = dtfi.GetType();
      PropertyInfo[] props = typ.GetProperties();
      DateTime value = new DateTime(2012, 5, 28, 11, 35, 0);

      foreach (var prop in props) {
         // Is this a format pattern-related property?
         if (prop.Name.Contains("Pattern")) {
            string fmt = prop.GetValue(dtfi, null).ToString();
            Console.WriteLine("{0,-33} {1} \n{2,-37}Example: {3}\n",
                              prop.Name + ":", fmt, "",
                              value.ToString(fmt));
         }
      }
   }
}
// The example displays the following output:
//    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
//                                         Example: Monday, May 28, 2012 11:35:00 AM
//
//    LongDatePattern:                  dddd, MMMM dd, yyyy
//                                         Example: Monday, May 28, 2012
//
//    LongTimePattern:                  h:mm:ss tt
//                                         Example: 11:35:00 AM
//
//    MonthDayPattern:                  MMMM dd
//                                         Example: May 28
//
//    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
//                                         Example: Mon, 28 May 2012 11:35:00 GMT
//
//    ShortDatePattern:                 M/d/yyyy
//                                         Example: 5/28/2012
//
//    ShortTimePattern:                 h:mm tt
//                                         Example: 11:35 AM
//
//    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
//                                         Example: 2012-05-28T11:35:00
//
//    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
//                                         Example: 2012-05-28 11:35:00Z
//
//    YearMonthPattern:                 MMMM, yyyy
//                                         Example: May, 2012
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get the properties of an en-US DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo("en-US").DateTimeFormat
      Dim typ As Type = dtfi.GetType()
      Dim props() As PropertyInfo = typ.GetProperties()
      Dim value As Date = #05/28/2012 11:35AM# 
      
      For Each prop In props
         ' Is this a format pattern-related property?
         If prop.Name.Contains("Pattern") Then
            Dim fmt As String = CStr(prop.GetValue(dtfi, Nothing))
            Console.WriteLine("{0,-33} {1} {2}{3,-37}Example: {4}", 
                              prop.Name + ":", fmt, vbCrLf, "",
                              value.ToString(fmt)) 
            Console.WriteLine()
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
'                                         Example: Monday, May 28, 2012 11:35:00 AM
'    
'    LongDatePattern:                  dddd, MMMM dd, yyyy
'                                         Example: Monday, May 28, 2012
'    
'    LongTimePattern:                  h:mm:ss tt
'                                         Example: 11:35:00 AM
'    
'    MonthDayPattern:                  MMMM dd
'                                         Example: May 28
'    
'    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
'                                         Example: Mon, 28 May 2012 11:35:00 GMT
'    
'    ShortDatePattern:                 M/d/yyyy
'                                         Example: 5/28/2012
'    
'    ShortTimePattern:                 h:mm tt
'                                         Example: 11:35 AM
'    
'    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
'                                         Example: 2012-05-28T11:35:00
'    
'    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
'                                         Example: 2012-05-28 11:35:00Z
'    
'    YearMonthPattern:                 MMMM, yyyy
'                                         Example: May, 2012

Uwagi

Właściwości klasy DateTimeFormatInfo zawierają informacje specyficzne dla kultury do formatowania lub analizowania wartości daty i godziny, takich jak następujące:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Wzorce używane do formatowania wartości dat.The patterns used to format date values.

  • Wzorce używane do formatowania wartości czasu.The patterns used to format time values.

  • Nazwy dni tygodnia.The names of the days of the week.

  • Nazwy miesięcy roku.The names of the months of the year.

  • RanoThe A.M. and P.M.and P.M. określenia używane w wartościach czasu.designators used in time values.

  • Kalendarz, w którym są wyrażane daty.The calendar in which dates are expressed.

W tej sekcji:In this section:

Utworzenie wystąpienia obiektu DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

Obiekt DateTimeFormatInfo może reprezentować konwencje formatowania kultury niezmiennej, określoną kulturę, kulturę neutralną lub bieżącą kulturę.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. W tej sekcji omówiono sposób tworzenia wystąpienia każdego typu DateTimeFormatInfo obiektu.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Utworzenie wystąpienia obiektu DateTimeFormatInfo dla kultury niezmiennejInstantiating a DateTimeFormatInfo object for the invariant culture

Niezmienna kultura reprezentuje kulturę, w której nie uwzględnia się ustawień kulturowych.The invariant culture represents a culture that is culture-insensitive. Jest on oparty na języku angielskim, ale nie w żadnym konkretnym kraju/regionie mówiącym w języku angielskim.It is based on the English language, but not on any specific English-speaking country/region. Chociaż dane określonych kultur mogą być dynamiczne i mogą ulec zmianie, aby odzwierciedlały nowe konwencje kulturalne lub Preferencje użytkownika, dane niezmiennej kultury nie zmieniają się.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Można utworzyć wystąpienie DateTimeFormatInfo obiektu, który reprezentuje konwencje formatowania niezmiennej kultury w następujący sposób:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Poniższy przykład używa każdej z tych metod, aby utworzyć wystąpienie DateTimeFormatInfo obiektu, który reprezentuje niezmienną kulturę.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Następnie wskazuje, czy obiekt jest tylko do odczytu.It then indicates whether the object is read-only.

System.Globalization.DateTimeFormatInfo dtfi;

dtfi = System.Globalization.DateTimeFormatInfo.InvariantInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = new System.Globalization.DateTimeFormatInfo();
Console.WriteLine(dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//       True
//       False
//       True
Dim dtfi As System.Globalization.DateTimeFormatInfo

dtfi = System.Globalization.DateTimeFormatInfo.InvariantInfo
Console.WriteLine(dtfi.IsReadOnly)               

dtfi = New System.Globalization.DateTimeFormatInfo()
Console.WriteLine(dtfi.IsReadOnly)               

dtfi = System.Globalization.CultureInfo.InvariantCulture.DateTimeFormat
Console.WriteLine(dtfi.IsReadOnly) 
' The example displays the following output:
'       True
'       False
'       True      

Utworzenie wystąpienia obiektu DateTimeFormatInfo dla określonej kulturyInstantiating a DateTimeFormatInfo object for a specific culture

Określona kultura reprezentuje język, który jest mówiony w określonym kraju/regionie.A specific culture represents a language that is spoken in a particular country/region. Na przykład, en-US to określona kultura, która reprezentuje język angielski, który jest mówiony w Stany Zjednoczone, a en-CA to określona kultura, która reprezentuje język angielski w Kanadzie.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Można utworzyć wystąpienie DateTimeFormatInfo obiektu, który reprezentuje konwencje formatowania określonej kultury w następujący sposób:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Poniższy przykład ilustruje każdy z tych metod, aby utworzyć wystąpienie obiektu DateTimeFormatInfo i wskazuje, czy otrzymany obiekt jest tylko do odczytu.The following example illustrates each of these ways to instantiate a DateTimeFormatInfo object and indicates whether the resulting object is read-only.

System.Globalization.CultureInfo ci = null;
System.Globalization.DateTimeFormatInfo dtfi = null;

// Instantiate a culture using CreateSpecificCulture.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-US");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a culture using the CultureInfo constructor.
ci = new System.Globalization.CultureInfo("en-CA");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", ci.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU");
dtfi = ci.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", ci.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling DateTimeFormatInfo.GetInstance.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(ci);
Console.WriteLine("{0} from GetInstance: {1}", ci.Name, dtfi.IsReadOnly);

// The example displays the following output:
//      en-US from CreateSpecificCulture: False
//      en-CA from CultureInfo constructor: False
//      en-AU from GetCultureInfo: True
//      en-GB from GetInstance: False
Dim ci As System.Globalization.CultureInfo = Nothing
Dim dtfi As System.Globalization.DateTimeFormatInfo = Nothing

' Instantiate a culture using CreateSpecificCulture.
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-US")
dtfi = ci.DateTimeFormat
Console.WriteLine("{0} from CreateSpecificCulture: {1}", ci.Name, dtfi.IsReadOnly)

' Instantiate a culture using the CultureInfo constructor.
ci = new System.Globalization.CultureInfo("en-CA") 
dtfi = ci.DateTimeFormat
Console.WriteLine("{0} from CultureInfo constructor: {1}", ci.Name, dtfi.IsReadOnly)

' Retrieve a culture by calling the GetCultureInfo method.
ci = System.Globalization.CultureInfo.GetCultureInfo("en-AU")
dtfi = ci.DateTimeFormat
Console.WriteLine("{0} from GetCultureInfo: {1}", ci.Name, dtfi.IsReadOnly)


' Instantiate a DateTimeFormatInfo object by calling DateTimeFormatInfo.GetInstance.  
ci = System.Globalization.CultureInfo.CreateSpecificCulture("en-GB")
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(ci)
Console.WriteLine("{0} from GetInstance: {1}", ci.Name, dtfi.IsReadOnly)

' The example displays the following output:
'      en-US from CreateSpecificCulture: False
'      en-CA from CultureInfo constructor: False
'      en-AU from GetCultureInfo: True
'      en-GB from GetInstance: False

Utworzenie wystąpienia obiektu DateTimeFormatInfo dla kultury neutralnejInstantiating a DateTimeFormatInfo object for a neutral culture

Neutralna kultura reprezentuje kulturę lub język, który jest niezależny od kraju/regionu; zwykle jest elementem nadrzędnym jednej lub kilku określonych kultur.A neutral culture represents a culture or language that is independent of a country/region; it is typically the parent of one or more specific cultures. Na przykład fr jest neutralną kulturą dla języka francuskiego i elementem nadrzędnym kultury fr-FR.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. Można utworzyć wystąpienie DateTimeFormatInfo obiektu, który reprezentuje konwencje formatowania neutralnej kultury w taki sam sposób, jak w przypadku utworzenia obiektu DateTimeFormatInfo, który reprezentuje konwencje formatowania określonej kultury.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a neutral culture in the same ways that you create a DateTimeFormatInfo object that represents the formatting conventions of a specific culture. Ponadto można pobrać obiekt DateTimeFormatInfo neutralnej kultury, pobierając neutralną kulturę z właściwości CultureInfo.Parent określonej kultury i pobierając obiekt DateTimeFormatInfo zwracany przez jego właściwość CultureInfo.DateTimeFormat.In addition, you can retrieve a neutral culture's DateTimeFormatInfo object by retrieving a neutral culture from a specific culture's CultureInfo.Parent property and retrieving the DateTimeFormatInfo object returned by its CultureInfo.DateTimeFormat property. Chyba że kultura nadrzędna reprezentuje niezmienną kulturę, zwracany obiekt DateTimeFormatInfo jest odczyt/zapis.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. Poniższy przykład ilustruje te metody tworzenia wystąpienia DateTimeFormatInfo obiektu, który reprezentuje kulturę neutralną.The following example illustrates these ways of instantiating a DateTimeFormatInfo object that represents a neutral culture.

System.Globalization.CultureInfo specific, neutral;
System.Globalization.DateTimeFormatInfo dtfi;

// Instantiate a culture by creating a specific culture and using its Parent property.
specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR");
neutral = specific.Parent;
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat;
Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a neutral culture using the CultureInfo constructor.
neutral = new System.Globalization.CultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a culture using CreateSpecificCulture.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly);

// Retrieve a culture by calling the GetCultureInfo method.
neutral = System.Globalization.CultureInfo.GetCultureInfo("fr");
dtfi = neutral.DateTimeFormat;
Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly);

// Instantiate a DateTimeFormatInfo object by calling GetInstance.
neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr");
dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral);
Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly);

// The example displays the following output:
//       fr from Parent property: False
//       fr from Parent property: False
//       fr from CultureInfo constructor: False
//       fr-FR from CreateSpecificCulture: False
//       fr from GetCultureInfo: True
//       fr-FR from GetInstance: False
 Dim specific, neutral As System.Globalization.CultureInfo
 Dim dtfi As System.Globalization.DateTimeFormatInfo

 ' Instantiate a culture by creating a specific culture and using its Parent property.
 specific = System.Globalization.CultureInfo.GetCultureInfo("fr-FR")
 neutral = specific.Parent
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly)
 
 dtfi = System.Globalization.CultureInfo.GetCultureInfo("fr-FR").Parent.DateTimeFormat
 Console.WriteLine("{0} from Parent property: {1}", neutral.Name, dtfi.IsReadOnly)

 ' Instantiate a neutral culture using the CultureInfo constructor.
 neutral = New System.Globalization.CultureInfo("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from CultureInfo constructor: {1}", neutral.Name, dtfi.IsReadOnly)

 ' Instantiate a culture using CreateSpecificCulture. 
 neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from CreateSpecificCulture: {1}", neutral.Name, dtfi.IsReadOnly)
 
 ' Retrieve a culture by calling the GetCultureInfo method.
 neutral = System.Globalization.CultureInfo.GetCultureInfo("fr")
 dtfi = neutral.DateTimeFormat
 Console.WriteLine("{0} from GetCultureInfo: {1}", neutral.Name, dtfi.IsReadOnly)
 
 ' Instantiate a DateTimeFormatInfo object by calling GetInstance.  
 neutral = System.Globalization.CultureInfo.CreateSpecificCulture("fr")
 dtfi = System.Globalization.DateTimeFormatInfo.GetInstance(neutral)
 Console.WriteLine("{0} from GetInstance: {1}", neutral.Name, dtfi.IsReadOnly)

 ' The example displays the following output:
 '       fr from Parent property: False
 '       fr from Parent property: False
 '       fr from CultureInfo constructor: False
 '       fr-FR from CreateSpecificCulture: False
 '       fr from GetCultureInfo: True
 '       fr-FR from GetInstance: False       

Uwaga

W .NET Framework wersje 1,0 do .NET Framework 3.5.NET Framework 3.5, próba pobrania obiektu DateTimeFormatInfo, który odzwierciedla konwencje formatowania kultury neutralnej zgłasza wyjątek NotSupportedException.In the .NET Framework versions 1.0 through .NET Framework 3.5.NET Framework 3.5, trying to retrieve a DateTimeFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Niemniej jednak niezależna kultura nie ma informacji o formatowaniu specyficznych dla kultury, ponieważ jest ona niezależnie od określonego kraju/regionu.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. Zamiast wypełniania obiektu DateTimeFormatInfo przy użyciu wartości ogólnych, .NET Framework zwraca obiekt DateTimeFormatInfo, który odzwierciedla konwencje formatowania określonej kultury, która jest elementem podrzędnym kultury neutralnej.Instead of populating the DateTimeFormatInfo object with generic values, the .NET Framework returns a DateTimeFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Na przykład obiekt DateTimeFormatInfo dla neutralnej kultury jest odzwierciedla konwencje formatowania kultury en-US, a obiekt DateTimeFormatInfo dla kultury fr odzwierciedla konwencje formatowania kultury fr-FR.For example, the DateTimeFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the DateTimeFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Można użyć kodu, takiego jak następujące, aby określić, które konwencje formatowania określonej kultury reprezentują neutralną kulturę.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. W przykładzie przedstawiono użycie odbicia w celu porównania właściwości DateTimeFormatInfo neutralnej kultury z właściwościami określonej kultury podrzędnej.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Traktuje dwa kalendarze jako równoważne, jeśli są one tego samego typu Kalendarz i dla kalendarzy gregoriańskich, jeśli ich właściwości GregorianCalendar.CalendarType mają identyczne wartości.It considers two calendars to be equivalent if they are the same calendar type and, for Gregorian calendars, if their GregorianCalendar.CalendarType properties have identical values.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;

public class Example
{
   public static void Main()
   {
      // Get all the neutral cultures
      List<String> names = new List<String>();
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    culture => names.Add(culture.Name));
      names.Sort();
      foreach (var name in names) {
         // Ignore the invariant culture.
         if (name == "") continue;

         ListSimilarChildCultures(name);
      }
   }

   private static void ListSimilarChildCultures(String name)
   {
      // Create the neutral DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo(name).DateTimeFormat;
      // Retrieve all specific cultures of the neutral culture.
      CultureInfo[] cultures = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures),
                               culture => culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase));
      // Create an array of DateTimeFormatInfo properties
      PropertyInfo[] properties = typeof(DateTimeFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
      bool hasOneMatch = false;

      foreach (var ci in cultures) {
         bool match = true;
         // Get the DateTimeFormatInfo for a specific culture.
         DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.
            if (prop.Name == "IsReadOnly") continue;

            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) {
               IList nList = (IList) prop.GetValue(dtfi, null);
               IList sList = (IList) prop.GetValue(specificDtfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
                  break;
               }

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) {
                     match = false;
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name);
                     break;
                  }
               }

               if (! match) break;
            }
            // Get non-array values.
            else {
               Object specificValue = prop.GetValue(specificDtfi);
               Object neutralValue = prop.GetValue(dtfi);

               // Handle comparison of Calendar objects.
               if (prop.Name == "Calendar") {
                  // The cultures have a different calendar type.
                  if (specificValue.ToString() != neutralValue.ToString()) {
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name);
                     match = false;
                     break;
                  }

                  if (specificValue is GregorianCalendar) {
                     if (((GregorianCalendar) specificValue).CalendarType != ((GregorianCalendar) neutralValue).CalendarType) {
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name);
                        match = false;
                        break;
                     }
                  }
               }
               else if (! specificValue.Equals(neutralValue)) {
                  match = false;
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name);
                  break;
               }
            }
         }
         if (match) {
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'",
                              name, ci.Name);
            hasOneMatch = true;
         }
      }
      if (! hasOneMatch)
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);

      Console.WriteLine();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral DateTimeFormatInfo object.
      Dim dtfi As DateTimeFormatInfo = CultureInfo.GetCultureInfo(name).DateTimeFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of DateTimeFormatInfo properties
      Dim properties() As PropertyInfo = GetType(DateTimeFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the DateTimeFormatInfo for a specific culture.
         Dim specificDtfi As DateTimeFormatInfo = ci.DateTimeFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(dtfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificDtfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name)
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name)                     
                     Exit For
                  End If     
               Next
               
               If Not match Then Exit For
            ' Get non-array values.
            Else
               Dim specificValue As Object = prop.GetValue(specificDtfi)
               Dim neutralValue As Object = prop.GetValue(dtfi)
                               
               ' Handle comparison of Calendar objects.
               If prop.Name = "Calendar" Then 
                  ' The cultures have a different calendar type.
                  If specificValue.ToString() <> neutralValue.ToString() Then
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name)
                     match = False
                     Exit For
                  End If
                   
                  If TypeOf specificValue Is GregorianCalendar Then
                     If CType(specificValue, GregorianCalendar).CalendarType <> CType(neutralValue, GregorianCalendar).CalendarType Then
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name)
                        match = False
                        Exit For
                     End If
                  End If
               Else If Not specificValue.Equals(neutralValue) Then
                  match = false
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name)                  
                  Exit For   
               End If
            End If        
         Next
         If match Then
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = True
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

Utworzenie wystąpienia obiektu DateTimeFormatInfo dla bieżącej kulturyInstantiating a DateTimeFormatInfo object for the current culture

Można utworzyć wystąpienie DateTimeFormatInfo obiektu, który reprezentuje konwencje formatowania bieżącej kultury w następujący sposób:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

Poniższy przykład używa każdej z tych metod, aby utworzyć wystąpienie DateTimeFormatInfo obiektu, który reprezentuje konwencje formatowania bieżącej kultury.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Następnie wskazuje, czy obiekt jest tylko do odczytu.It then indicates whether the object is read-only.

DateTimeFormatInfo dtfi;

dtfi = DateTimeFormatInfo.CurrentInfo;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = CultureInfo.CurrentCulture.DateTimeFormat;
Console.WriteLine(dtfi.IsReadOnly);

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture);
Console.WriteLine(dtfi.IsReadOnly);
// The example displays the following output:
//     True
//     True
//     True
Dim dtfi As DateTimeFormatInfo

dtfi = DateTimeFormatInfo.CurrentInfo
Console.WriteLine(dtfi.IsReadOnly)

dtfi = CultureInfo.CurrentCulture.DateTimeFormat
Console.WriteLine(dtfi.IsReadOnly)

dtfi = DateTimeFormatInfo.GetInstance(CultureInfo.CurrentCulture)
Console.WriteLine(dtfi.IsReadOnly)
' The example displays the following output:
'     True
'     True
'     True

Można utworzyć zapisywalny obiekt DateTimeFormatInfo, który reprezentuje konwencje bieżącej kultury wątku w jeden z następujących sposobów:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

Poniższy przykład ilustruje każdy sposób tworzenia wystąpienia obiektu DateTimeFormatInfo odczytu/zapisu i wyświetla wartość właściwości IsReadOnly.The following example illustrates each way of instantiating a read/write DateTimeFormatInfo object and displays the value of its IsReadOnly property.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTimeFormatInfo current1 = DateTimeFormatInfo.CurrentInfo;
      current1 = (DateTimeFormatInfo) current1.Clone();
      Console.WriteLine(current1.IsReadOnly);

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      DateTimeFormatInfo current2 = culture2.DateTimeFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As DateTimeFormatInfo = DateTimeFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), DateTimeFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As DateTimeFormatInfo = culture2.DateTimeFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

W systemie Windows użytkownik może przesłonić niektóre wartości właściwości DateTimeFormatInfo używanych podczas formatowania i analizowania operacji za pomocą regionu i aplikacji językowych w panelu sterowania.In Windows, the user can override some of the DateTimeFormatInfo property values used in formatting and parsing operations through the Region and Language application in Control Panel. Na przykład użytkownik, którego kultura jest w języku angielskim (Stany Zjednoczone), może zdecydować się na wyświetlanie wartości czasu długiego przy użyciu 24-godzinnego zegara (w formacie gg: mm: SS) zamiast domyślnego zegara 12-godzinnego (w formacie h:mm: SS TT).For example, a user whose culture is English (United States) might choose to display long time values using a 24-hour clock (in the format HH:mm:ss) instead of the default 12-hour clock (in the format h:mm:ss tt). Obiekty DateTimeFormatInfo pobierane w opisanych wcześniej szczegółach odzwierciedlają te zastąpienia użytkownika.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Jeśli jest to niepożądane, można utworzyć obiekt NumberFormatInfo, który nie odzwierciedla przesłonięć użytkownika (i jest również odczytywany/zapisu zamiast tylko do odczytu) przez wywołanie konstruktora CultureInfo.CultureInfo(String, Boolean) i dostarczenie wartości false dla argumentu useUserOverride.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and is also read/write instead of read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. Poniższy przykład ilustruje ten system dla systemu, którego bieżąca kultura jest w języku angielskim (Stany Zjednoczone) i którego wzorzec czasu długiego został zmieniony z domyślnej wartości h:mm: SS TT na HH: mm: SS.The following example illustrates this for a system whose current culture is English (United States) and whose long time pattern has been changed from the default of h:mm:ss tt to HH:mm:ss.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      DateTimeFormatInfo dtfi;

      culture = CultureInfo.CurrentCulture;
      dtfi = culture.DateTimeFormat;
      Console.WriteLine("Culture Name:      {0}", culture.Name);
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride);
      Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:      {0}",   culture.Name);
      Console.WriteLine("User Overrides:    {0}",   culture.UseUserOverride);
      Console.WriteLine("Long Time Pattern: {0}\n", culture.DateTimeFormat.LongTimePattern);
   }
}
// The example displays the following output:
//       Culture Name:      en-US
//       User Overrides:    True
//       Long Time Pattern: HH:mm:ss
//
//       Culture Name:      en-US
//       User Overrides:    False
//       Long Time Pattern: h:mm:ss tt
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim dtfi As DateTimeFormatInfo
      
      culture = CultureInfo.CurrentCulture
      dtfi = culture.DateTimeFormat
      Console.WriteLine("Culture Name:      {0}", culture.Name)
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride)
      Console.WriteLine("Long Time Pattern: {0}", culture.DateTimeFormat.LongTimePattern)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:      {0}", culture.Name)
      Console.WriteLine("User Overrides:    {0}", culture.UseUserOverride)
      Console.WriteLine("Long Time Pattern: {0}", culture.DateTimeFormat.LongTimePattern)
   End Sub
End Module
' The example displays the following output:
'       Culture Name:      en-US
'       User Overrides:    True
'       Long Time Pattern: HH:mm:ss
'       
'       Culture Name:      en-US
'       User Overrides:    False
'       Long Time Pattern: h:mm:ss tt

DateTimeFormatInfo i dane dynamiczneDateTimeFormatInfo and dynamic data

Dane specyficzne dla kultury służące do formatowania wartości daty i godziny dostarczone przez klasę DateTimeFormatInfo są dynamiczne, podobnie jak dane kulturowe dostarczone przez klasę CultureInfo.The culture-specific data for formatting date and time values provided by the DateTimeFormatInfo class is dynamic, just like cultural data provided by the CultureInfo class. Nie należy wprowadzać żadnych założeń dotyczących trwałości wartości dla obiektów DateTimeFormatInfo, które są skojarzone z konkretnymi obiektami CultureInfo.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Tylko dane dostarczone przez niezmienną kulturę i skojarzony obiekt DateTimeFormatInfo są stabilne.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Inne dane mogą ulec zmianie między sesjami aplikacji lub nawet wtedy, gdy aplikacja jest uruchomiona.Other data can change between application sessions or even while your application is running. Istnieją cztery główne źródła zmian:There are four major sources of change:

  • Aktualizacje systemu.System updates. Preferencje kulturowe, takie jak preferowany Kalendarz lub niestandardowe formaty daty i godziny, zmieniają się w miarę upływu czasu.Cultural preferences such as the preferred calendar or customary date and time formats change over time. W takim przypadku Windows Update obejmuje zmiany wartości właściwości DateTimeFormatInfo dla określonej kultury.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Kultury zamienne.Replacement cultures. Klasa CultureAndRegionInfoBuilder może służyć do zastępowania danych istniejącej kultury.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Kaskadowe zmiany wartości właściwości.Cascading changes to property values. Wiele właściwości związanych z kulturą może ulec zmianie w czasie wykonywania, co z kolei powoduje zmianę danych DateTimeFormatInfo.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Na przykład bieżącą kulturę można zmienić programowo lub za pomocą akcji użytkownika.For example, the current culture can be changed either programmatically or through user action. W takim przypadku obiekt DateTimeFormatInfo zwracany przez właściwość CurrentInfo zmieni się na obiekt skojarzony z bieżącą kulturą.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. Podobnie kalendarz kultury może ulec zmianie, co może spowodować zmiany w wielu DateTimeFormatInfo wartości właściwości.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Preferencje użytkownika.User preferences. Użytkownicy aplikacji mogą zdecydować się na zastąpienie niektórych wartości skojarzonych z bieżącą kulturą systemu za pomocą opcji regionalnych i językowych w panelu sterowania.Users of your application might choose to override some of the values associated with the current system culture through the regional and language options in Control Panel. Na przykład użytkownicy mogą zdecydować się na wyświetlanie daty w innym formacie.For example, users might choose to display the date in a different format. Jeśli właściwość CultureInfo.UseUserOverride jest ustawiona na true, właściwości obiektu DateTimeFormatInfo są również pobierane z ustawień użytkownika.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Jeśli ustawienia użytkownika są niezgodne z kulturą skojarzoną z obiektem CultureInfo (na przykład jeśli wybrany kalendarz nie jest jednym z kalendarzy wskazanym przez właściwość OptionalCalendars), wyniki metod i wartości właściwości są niezdefiniowane.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars indicated by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Aby zminimalizować prawdopodobieństwo niespójnych danych, wszystkie właściwości, które można wypróbować obiektu DateTimeFormatInfo są inicjowane podczas tworzenia obiektu.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Nadal istnieje możliwość niespójności, ponieważ nie można utworzyć obiektu ani proces przesłonięcia użytkownika jest niepodzielny i odpowiednie wartości mogą ulec zmianie podczas tworzenia obiektu.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic and the relevant values can change during object creation. Ta sytuacja powinna jednak być wyjątkowo rzadki.However, this situation should be extremely rare.

Można kontrolować, czy zastąpienia użytkowników są odzwierciedlone w DateTimeFormatInfo obiektów, które reprezentują tę samą kulturę co kultura systemowa.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. W poniższej tabeli przedstawiono sposób, w jaki można pobrać obiekt DateTimeFormatInfo i wskazuje, czy obiekt wyniku odzwierciedla zastąpienia użytkownika.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Źródło obiektu CultureInfo i DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Odzwierciedla zastąpienia użytkownikaReflects user overrides
CultureInfo.CurrentCulture.DateTimeFormat WłaściwośćCultureInfo.CurrentCulture.DateTimeFormat property TakYes
DateTimeFormatInfo.CurrentInfo WłaściwośćDateTimeFormatInfo.CurrentInfo property TakYes
CultureInfo.CreateSpecificCulture, MetodaCultureInfo.CreateSpecificCulture method TakYes
CultureInfo.GetCultureInfo, MetodaCultureInfo.GetCultureInfo method NieNo
Konstruktor CultureInfo.CultureInfo(String)CultureInfo.CultureInfo(String) constructor TakYes
Konstruktor CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Zależy od wartości parametru useUserOverrideDepends on value of useUserOverride parameter

O ile nie istnieje istotny powód, aby to zrobić, należy przestrzegać zastąpień użytkownika podczas używania obiektu DateTimeFormatInfo w aplikacjach klienckich do formatowania i analizowania danych wejściowych użytkownika lub do wyświetlania.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the DateTimeFormatInfo object in client applications to format and parse user input or to display data. W przypadku aplikacji serwerowych lub aplikacji nienadzorowanych nie należy.For server applications or unattended applications, you should not. Jeśli jednak używasz obiektu DateTimeFormatInfo albo jawnie lub niejawnie, aby utrwalał dane daty i godziny w postaci ciągu, należy użyć obiektu DateTimeFormatInfo, który odzwierciedla konwencje formatowania kultury niezmiennej, lub należy określić niestandardowy ciąg formatu daty i godziny, który będzie używany bez względu na kulturę.However, if you are using the DateTimeFormatInfo object either explicitly or implicitly to persist date and time data in string form, you should either use a DateTimeFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom date and time format string that you use regardless of culture.

Formatowanie daty i godzinyFormatting dates and times

Obiekt DateTimeFormatInfo jest używany niejawnie lub jawnie we wszystkich operacjach formatowania daty i godziny.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Obejmują one wywołania następujących metod:These include calls to the following methods:

Wszystkie operacje formatowania daty i godziny używają implementacji IFormatProvider.All date and time formatting operations make use of an IFormatProvider implementation. Interfejs IFormatProvider zawiera pojedynczą metodę, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Ta metoda wywołania zwrotnego jest przenoszona Type obiektu, który reprezentuje typ wymagany do zapewnienia informacji o formatowaniu.This callback method is passed a Type object that represents the type needed to provide formatting information. Metoda zwraca wystąpienie tego typu lub null, jeśli nie można podać wystąpienia typu.The method returns either an instance of that type or null if it cannot provide an instance of the type. .NET Framework obejmuje dwie implementacje IFormatProvider do formatowania dat i godzin:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Jeśli implementacja IFormatProvider nie zostanie przekazana do metody formatowania jawnie, zostanie użyty obiekt CultureInfo zwrócony przez właściwość CultureInfo.CurrentCulture reprezentującą bieżącą kulturę wątku.If an IFormatProvider implementation is not provided to a formatting method explicitly, the CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Poniższy przykład ilustruje relacje między interfejsem IFormatProvider i klasą DateTimeFormatInfo w operacjach formatowania.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Definiuje niestandardowe implementacje IFormatProvider, których Metoda GetFormat wyświetla typ obiektu żądanego przez operację formatowania.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. Jeśli żąda obiektu DateTimeFormatInfo, Metoda udostępnia obiekt DateTimeFormatInfo dla bieżącej kultury wątku.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Jak wynika z przykładu, Metoda Decimal.ToString(IFormatProvider) żąda obiektu DateTimeFormatInfo, aby zapewnić informacje o formatowaniu, podczas gdy metoda String.Format(IFormatProvider, String, Object[]) żąda NumberFormatInfo i DateTimeFormatInfo obiektów, a także implementacji ICustomFormatter.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a DateTimeFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

using System;
using System.Globalization;

public class CurrentCultureFormatProvider : IFormatProvider
{
   public Object GetFormat(Type formatType)
   {
      Console.WriteLine("Requesting an object of type {0}",
                        formatType.Name);
      if (formatType == typeof(NumberFormatInfo))
         return NumberFormatInfo.CurrentInfo;
      else if (formatType == typeof(DateTimeFormatInfo))
         return DateTimeFormatInfo.CurrentInfo;
      else
         return null;
   }
}

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 28, 12, 30, 0);
      string value = dateValue.ToString("F", new CurrentCultureFormatProvider());
      Console.WriteLine(value);
      Console.WriteLine();
      string composite = String.Format(new CurrentCultureFormatProvider(),
                                       "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                       dateValue, 1264.03m, "Service Charge");
      Console.WriteLine(composite);
      Console.WriteLine();
   }
}
// The example displays output like the following:
//       Requesting an object of type DateTimeFormatInfo
//       Tuesday, May 28, 2013 1:30:00 PM
//
//       Requesting an object of type ICustomFormatter
//       Requesting an object of type DateTimeFormatInfo
//       Requesting an object of type NumberFormatInfo
//       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge
Imports System.Globalization

Public Class CurrentCultureFormatProvider : Implements IFormatProvider
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      Console.WriteLine("Requesting an object of type {0}", 
                        formatType.Name)
      If formatType Is GetType(NumberFormatInfo) Then
         Return NumberFormatInfo.CurrentInfo
      Else If formatType Is GetType(DateTimeFormatInfo) Then
         Return DateTimeFormatInfo.CurrentInfo
      Else
         Return Nothing
      End If
   End Function
End Class

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 05, 28, 13, 30, 0)
      Dim value As String = dateValue.ToString("F", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0:d}   Amount: {1:C}   Description: {2}",
                                              dateValue, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'       Requesting an object of type DateTimeFormatInfo
'       Tuesday, May 28, 2013 1:30:00 PM
'       
'       Requesting an object of type ICustomFormatter
'       Requesting an object of type DateTimeFormatInfo
'       Requesting an object of type NumberFormatInfo
'       Date: 5/28/2013   Amount: $1,264.03   Description: Service Charge

Ciągi formatów i właściwości DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

Obiekt DateTimeFormatInfo zawiera trzy rodzaje właściwości, które są używane w operacjach formatowania z wartościami daty i godziny:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

Standardowe ciągi formatujące datę i godzinę, takie jak "d", "d", "f" i "f", to aliasy, które odpowiadają określonym DateTimeFormatInfo właściwości wzorca formatowania.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. Większość niestandardowych ciągów formatu daty i godziny dotyczy ciągów lub podciągów, które operacja formatowania wstawia do strumienia wynikowego.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. W poniższej tabeli wymieniono specyfikatory standardowego i niestandardowego formatu daty i godziny oraz skojarzone z nimi DateTimeFormatInfo właściwości.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Aby uzyskać szczegółowe informacje na temat używania tych specyfikatorów formatu, zobacz ciągi standardowego formatu daty i godziny oraz Niestandardowe ciągi formatujące datę i godzinę.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Należy zauważyć, że każdy ciąg formatu standardowego odpowiada właściwości DateTimeFormatInfo, której wartość jest niestandardowym ciągiem formatu daty i godziny.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Poszczególne Specyfikatory w tym niestandardowym ciągu formatu są zgodne z innymi właściwościami DateTimeFormatInfo.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. W tabeli wymieniono tylko właściwości DateTimeFormatInfo, dla których są używane ciągi formatu standardowego, i nie są wyświetlane właściwości, do których można uzyskać dostęp za pomocą ciągów formatu niestandardowego przypisanych do tych właściwości.The table lists only the DateTimeFormatInfo properties for which the standard format strings are aliases, and does not list properties that may be accessed by custom format strings assigned to those aliased properties. Ponadto tabela zawiera tylko specyfikatory formatu niestandardowego, które odpowiadają DateTimeFormatInfo właściwości.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Specyfikator formatuFormat specifier Skojarzone właściwościAssociated properties
"d" (Data krótka; ciąg formatu standardowego)"d" (short date; standard format string) ShortDatePattern, aby zdefiniować ogólny format ciągu wynikowego.ShortDatePattern, to define the overall format of the result string.
"D" (Data długa; ciąg formatu standardowego)"D" (long date; standard format string) LongDatePattern, aby zdefiniować ogólny format ciągu wynikowego.LongDatePattern, to define the overall format of the result string.
"f" (pełna Data/godzina krótka; ciąg formatu standardowego)"f" (full date / short time; standard format string) LongDatePattern, aby zdefiniować format składnika daty w ciągu wynikowym.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.ShortTimePattern, to define the format of the time component of the result string.
"F" (pełna Data/godzina długa; ciąg formatu standardowego)"F" (full date / long time; standard format string) LongDatePattern, aby zdefiniować format składnika daty w ciągu wynikowym.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.LongTimePattern, to define the format of the time component of the result string.
"g" (Data ogólna/godzina krótka; ciąg formatu standardowego)"g" (general date / short time; standard format string) ShortDatePattern, aby zdefiniować format składnika daty w ciągu wynikowym.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.ShortTimePattern, to define the format of the time component of the result string.
"G" (ogólna Data/godzina długa; ciąg formatu standardowego)"G" (general date / long time; standard format string) ShortDatePattern, aby zdefiniować format składnika daty w ciągu wynikowym.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (miesiąc/dzień; ciąg formatu standardowego)"M", "m" (month/day; standard format string) MonthDayPattern, aby zdefiniować ogólny format ciągu wynikowego.MonthDayPattern, to define the overall format of the result string.
"O", "o" (Data/godzina rundy; ciąg formatu standardowego)"O", "o" (round-trip date/time; standard format string) Brak.None.
"R", "r" (RFC1123; ciąg formatu standardowego)"R", "r" (RFC1123; standard format string) RFC1123Pattern, aby zdefiniować ciąg wynikowy, który jest zgodny ze standardem RFC 1123.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. Właściwość jest tylko do odczytu.The property is read-only.
"s" (sortowanie daty/godziny; ciąg formatu standardowego)"s" (sortable date/time; standard format string) SortableDateTimePattern, aby zdefiniować ciąg wynikowy, który jest zgodny ze standardem ISO 8601.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. Właściwość jest tylko do odczytu.The property is read-only.
"t" (godzina krótka; ciąg formatu standardowego)"t" (short time; standard format string) ShortTimePattern, aby zdefiniować ogólny format ciągu wynikowego.ShortTimePattern, to define the overall format of the result string.
"T" (godzina długa; ciąg formatu standardowego)"T" (long time; standard format string) LongTimePattern, aby zdefiniować ogólny format ciągu wynikowego.LongTimePattern, to define the overall format of the result string.
"u" (uniwersalna Data/godzina, ciąg formatu standardowego)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, aby zdefiniować ciąg wynikowy, który jest zgodny ze standardem ISO 8601 dla uniwersalnego czasu koordynowanego.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. Właściwość jest tylko do odczytu.The property is read-only.
"U" (uniwersalna pełna Data/godzina; ciąg formatu standardowego)"U" (universal full date/time; standard format string) FullDateTimePattern, aby zdefiniować ogólny format ciągu wynikowego.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (miesiąc rok; ciąg formatu standardowego)"Y", "y" (year month; standard format string) YearMonthPattern, aby zdefiniować ogólny format ciągu wynikowego.YearMonthPattern, to define the overall format of the result string.
"ddd" (specyfikator formatu niestandardowego)"ddd" (custom format specifier) AbbreviatedDayNames, aby uwzględnić skróconą nazwę dnia tygodnia w ciągu wynikowym.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "gg" (specyfikator formatu niestandardowego)"g", "gg" (custom format specifier) Wywołuje metodę GetEraName, aby wstawić nazwę ERA w ciągu wynikowym.Calls the GetEraName method to insert the era name in the result string.
"MMM" (specyfikator formatu niestandardowego)"MMM" (custom format specifier) AbbreviatedMonthNames, aby w ciągu wynikowym uwzględnić skróconą nazwę miesiąca.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (specyfikator formatu niestandardowego)"MMMM" (custom format specifier) MonthNames lub MonthGenitiveNames, aby uwzględnić pełną nazwę miesiąca w ciągu wynikowym.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (specyfikator formatu niestandardowego)"t" (custom format specifier) AMDesignator lub PMDesignator, aby uwzględnić pierwszy znak oznaczenia AM/PM w ciągu wynikowym.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"tt" (specyfikator formatu niestandardowego)"tt" (custom format specifier) AMDesignator lub PMDesignator, aby uwzględnić pełny wskaźnik AM/PM w ciągu wynikowym.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (specyfikator formatu niestandardowego)":" (custom format specifier) TimeSeparator, aby uwzględnić separator czasu w ciągu wynikowym.TimeSeparator, to include the time separator in the result string.
"/" (specyfikator formatu niestandardowego)"/" (custom format specifier) DateSeparator, aby uwzględnić separator daty w ciągu wynikowym.DateSeparator, to include the date separator in the result string.

Modyfikowanie właściwości DateTimeFormatInfoModifying DateTimeFormatInfo properties

Można zmienić ciąg wynikowy generowany przez ciągi formatu daty i godziny, modyfikując skojarzone właściwości obiektu DateTimeFormatInfo do zapisu.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. Aby określić, czy obiekt DateTimeFormatInfo można zapisać, użyj właściwości IsReadOnly.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. Aby dostosować obiekt DateTimeFormatInfo w następujący sposób:To customize a DateTimeFormatInfo object in this way:

  1. Utwórz kopię obiektu DateTimeFormatInfo do odczytu/zapisu, którego konwencje formatowania chcesz zmodyfikować.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Zobacz sekcję Tworzenie wystąpienia obiektu DateTimeFormatInfo ).(See the Instantiating a DateTimeFormatInfo object section.)

  2. Zmodyfikuj właściwość lub właściwości, które są używane do generowania żądanego ciągu wynikowego.Modify the property or properties that are used to produce the desired result string. (Aby uzyskać informacje na temat sposobu, w jaki metody formatowania używają właściwości DateTimeFormatInfo do definiowania ciągów wynikowych, zobacz poprzednią sekcję, ciągi formatów i właściwości DateTimeFormatInfo).(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Użyj niestandardowego obiektu DateTimeFormatInfo utworzonego jako argument IFormatProvider w wywołaniach metod formatowania.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Istnieją dwa inne sposoby zmiany formatu ciągu wynikowego:There are two other ways to change the format of a result string:

  • Można użyć klasy CultureAndRegionInfoBuilder, aby zdefiniować niestandardową kulturę (kulturę, która ma unikatową nazwę i która uzupełnia istniejące kultury) lub kulturę zamienną (używaną zamiast określonej kultury).You can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture). Możesz zapisać tę kulturę i uzyskać do niej dostęp programowo tak, jak każdy obiekt CultureInfo obsługiwany przez .NET Framework.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Jeśli ciąg wynikowy nie jest uwzględniany w kulturze i nie jest zgodny ze wstępnie zdefiniowanym formatem, można użyć niestandardowego ciągu formatu daty i godziny.If the result string is not culture-sensitive and doesn't follow a predefined format, you can use a custom date and time format string. Na przykład, jeśli Serializowanie danych daty i godziny w formacie rrrrmmddggmmss, można wygenerować ciąg wynikowy przez przekazanie ciągu formatu niestandardowego do metody DateTime.ToString(String) i można przekonwertować ciąg wynikowy z powrotem na wartość DateTime, wywołując metodę DateTime.ParseExact.For example, if you are serializing date and time data in the format YYYYMMDDHHmmss, you can generate the result string by passing the custom format string to the DateTime.ToString(String) method, and you can convert the result string back to a DateTime value by calling the DateTime.ParseExact method.

Zmienianie wzorca daty krótkiejChanging the short date pattern

Poniższy przykład zmienia format ciągu wynikowego wygenerowanego w ciągu formatu standardowego "d" (Data krótka).The following example changes the format of a result string produced by the "d" (short date) standard format string. Zmienia skojarzoną Właściwość ShortDatePattern dla kultury en-US lub English (Stany Zjednoczone) z wartości domyślnej "M/d/rrrr" na "RRRR"-"MM"-"DD" i używa ciągu formatu standardowego "d" do wyświetlania daty przed i po zmianie właściwości ShortDatePattern.It changes the associated ShortDatePattern property for the en-US or English (United States) culture from its default of "M/d/yyyy" to "yyyy'-"MM"-"dd" and uses the "d" standard format string to display the date both before and after the ShortDatePattern property is changed.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 8, 18);
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

      Console.WriteLine("Before modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}\n", dtfi.ShortDatePattern,
                                    dateValue.ToString("d", enUS));

      // Modify the short date pattern.
      dtfi.ShortDatePattern = "yyyy-MM-dd";
      Console.WriteLine("After modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern,
                                    dateValue.ToString("d", enUS));
   }
}
// The example displays the following output:
//       Before modifying DateTimeFormatInfo object:
//       M/d/yyyy: 8/18/2013
//
//       After modifying DateTimeFormatInfo object:
//       yyyy-MM-dd: 2013-08-18
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 18) 
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      
      Console.WriteLine("Before modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
      Console.WriteLine()
      
      ' Modify the short date pattern.
      dtfi.ShortDatePattern = "yyyy-MM-dd"
      Console.WriteLine("After modifying DateTimeFormatInfo object: ")
      Console.WriteLine("{0}: {1}", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS))
   End Sub
End Module
' The example displays the following output:
'       Before modifying DateTimeFormatInfo object:
'       M/d/yyyy: 8/18/2013
'       
'       After modifying DateTimeFormatInfo object:
'       yyyy-MM-dd: 2013-08-18

Zmienianie znaku separatora datyChanging the date separator character

Poniższy przykład zmienia znak separatora daty w obiekcie DateTimeFormatInfo, który reprezentuje konwencje formatowania kultury fr-FR.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. W przykładzie użyto standardowego ciągu formatu "g", aby wyświetlić datę wcześniejszą i po zmianie właściwości DateSeparator.The example uses the "g" standard format string to display the date both before and after the DateSeparator property is changed.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 08, 28);
      CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
      DateTimeFormatInfo dtfi = frFR.DateTimeFormat;

      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));

      // Modify the date separator.
      dtfi.DateSeparator = "-";
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
   }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 18/08/2013 00:00
//       After modifying the DateSeparator property: 18-08-2013 00:00
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 08, 28) 
      Dim frFR As CultureInfo = CultureInfo.CreateSpecificCulture("fr-FR")
      Dim dtfi As DateTimeFormatInfo = frFR.DateTimeFormat
      
      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR))
      
      ' Modify the date separator.
      dtfi.DateSeparator = "-"
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR))
   End Sub
End Module
' The example displays the following output:
'       Before modifying DateSeparator property: 28/08/2013 00:00
'       After modifying the DateSeparator property: 28-08-2013 00:00

Zmienianie skrótów nazw dni i wzorzec daty długiejChanging day name abbreviations and the long date pattern

W niektórych przypadkach wzorzec daty długiej, który zwykle wyświetla pełną nazwę dnia i miesiąca wraz z liczbą dni miesiąca i roku, może być zbyt długi.In some cases, the long date pattern, which typically displays the full day and month name along with the number of the day of the month and the year, may be too long. Poniższy przykład skraca wzorzec daty długiej dla kultury en-US w celu zwrócenia jednoznakowego lub dwubajtowego skrótu nazwy, a następnie numeru dnia, skrótu nazwy miesiąca i roku.The following example shortens the long date pattern for the en-US culture to return a one-character or two-character day name abbreviation followed by the day number, the month name abbreviation, and the year. Wykonuje to poprzez przypisanie krótszych skrótów nazw dni do tablicy AbbreviatedDayNames i zmodyfikowanie niestandardowego ciągu formatu przypisanego do właściwości LongDatePattern.It does this by assigning shorter day name abbreviations to the AbbreviatedDayNames array, and by modifying the custom format string assigned to the LongDatePattern property. Ma to wpływ na ciągi wynikowe zwracane przez ciągi formatu standardowego "D" i "f".This affects the result strings returned by the "D" and "f" standard format strings.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime value = new DateTime(2013, 7, 9);
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String[] formats = { "D", "F", "f" };

      // Display date before modifying properties.
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));

      Console.WriteLine();

      // We don't want to change the FullDateTimePattern, so we need to save it.
      String originalFullDateTimePattern = dtfi.FullDateTimePattern;

      // Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
      dtfi.FullDateTimePattern = originalFullDateTimePattern;
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       D: Tuesday, July 09, 2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tuesday, July 09, 2013 12:00 AM
//
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim value As New Date(2013, 7, 9)
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim formats() As String = { "D", "F", "f" }

      ' Display date before modifying properties.
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' We don't want to change the FullDateTimePattern, so we need to save it.
      Dim originalFullDateTimePattern As String = dtfi.FullDateTimePattern
      
      ' Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = { "Su", "M", "Tu", "W", "Th", "F", "Sa" }
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy"
      dtfi.FullDateTimePattern = originalFullDateTimePattern
      For Each fmt In formats
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' The example displays the following output:
'       D: Tuesday, July 09, 2013
'       F: Tuesday, July 09, 2013 12:00:00 AM
'       f: Tuesday, July 09, 2013 12:00 AM
'       
'       D: Tu 09-Jul-2013
'       F: Tuesday, July 09, 2013 12:00:00 AM
'       f: Tu 09-Jul-2013 12:00 AM

Zwykle zmiana właściwości LongDatePattern ma także wpływ na Właściwość FullDateTimePattern, która z kolei definiuje ciąg wynik zwracany przez ciąg formatu standardowego "F".Ordinarily, the change to the LongDatePattern property also affects the FullDateTimePattern property, which in turn defines the result string returned by the "F" standard format string. Aby zachować oryginalny wzorzec pełnej daty i godziny, przykład ponownie przypisuje oryginalny ciąg formatu niestandardowego przypisany do właściwości FullDateTimePattern po zmodyfikowaniu właściwości LongDatePattern.To preserve the original full date and time pattern, the example reassigns the original custom format string assigned to the FullDateTimePattern property after the LongDatePattern property is modified.

Zmiana z 12-godzinnego zegara na 24-godzinnyChanging from a 12-hour clock to a 24-hour clock

W przypadku wielu kultur w .NET Framework czas jest wyrażany przy użyciu zegara 12-godzinnego i oznaczenia AM/PM.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. W poniższym przykładzie zdefiniowano metodę ReplaceWith24HourClock, która zastępuje dowolny format czasu, który używa zegara 12-godzinnego z formatem korzystającym z 24-godzinnego zegara.The following example defines a ReplaceWith24HourClock method that replaces any time format that uses a 12-hour clock with a format that uses a 24-hour clock.

using System;
using System.Globalization;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;

      Console.WriteLine("Original Property Values:");
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
      Console.WriteLine();

      dtfi.LongTimePattern = ReplaceWith24HourClock(dtfi.LongTimePattern);
      dtfi.ShortTimePattern = ReplaceWith24HourClock(dtfi.ShortTimePattern);

      Console.WriteLine("Modififed Property Values:");
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern);
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern);
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern);
   }

   private static string ReplaceWith24HourClock(string fmt)
   {
      string pattern = @"^(?<openAMPM>\s*t+\s*)? " +
                       @"(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                       @"| \s*h+(?<nonHours>[^ht]+)\s*t+)";
      return Regex.Replace(fmt, pattern, "HH${nonHours}",
                           RegexOptions.IgnorePatternWhitespace);
   }
}
// The example displays the following output:
//       Original Property Values:
//       ShortTimePattern: h:mm tt
//       LongTimePattern: h:mm:ss tt
//       FullDateTimePattern: dddd, MMMM dd, yyyy h:mm:ss tt
//
//       Modififed Property Values:
//       ShortTimePattern: HH:mm
//       LongTimePattern: HH:mm:ss
//       FullDateTimePattern: dddd, MMMM dd, yyyy HH:mm:ss
Imports System.Globalization
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat

      Console.WriteLine("Original Property Values:")
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern)
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern)
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern)
      Console.WriteLine()
      
      dtfi.LongTimePattern = ReplaceWith24HourClock(dtfi.LongTimePattern)
      dtfi.ShortTimePattern = ReplaceWith24HourClock(dtfi.ShortTimePattern)
      
      Console.WriteLine("Modififed Property Values:")
      Console.WriteLine("ShortTimePattern: " + dtfi.ShortTimePattern)
      Console.WriteLine("LongTimePattern: " + dtfi.LongTimePattern)
      Console.WriteLine("FullDateTimePattern: " + dtfi.FullDateTimePattern)
   End Sub
   
   Private Function ReplaceWith24HourClock(fmt As String) As String
      Dim pattern As String = "^(?<openAMPM>\s*t+\s*)? " +
                              "(?(openAMPM) h+(?<nonHours>[^ht]+)$ " +
                              "| \s*h+(?<nonHours>[^ht]+)\s*t+)"
      Return Regex.Replace(fmt, pattern, "HH${nonHours}", RegexOptions.IgnorePatternWhitespace)   
   End Function
End Module
' The example displays the following output:
'       Original Property Values:
'       ShortTimePattern: h:mm tt
'       LongTimePattern: h:mm:ss tt
'       FullDateTimePattern: dddd, MMMM dd, yyyy h:mm:ss tt
'       
'       Modififed Property Values:
'       ShortTimePattern: HH:mm
'       LongTimePattern: HH:mm:ss
'       FullDateTimePattern: dddd, MMMM dd, yyyy HH:mm:ss

W przykładzie do modyfikacji ciągu formatu jest stosowane wyrażenie regularne.The example uses a regular expression to modify the format string. @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) wzorca wyrażenia regularnego definiuje się w następujący sposób:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

WzorcePattern OpisDescription
^ Rozpocznij dopasowanie na początku ciągu.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Dopasowanie do zera lub jednego wystąpienia zero lub więcej białych znaków, po których następuje litera "t" co najmniej raz, a po nim zero lub więcej znaków białych.Match zero or one occurrence of zero or more white-space characters, followed by the letter "t" one or more times, followed by zero or more white-space characters. Ta grupa przechwytywania ma nazwę openAMPM.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Jeśli grupa openAMPM ma dopasowanie, dopasowuje się do litery "h" co najmniej jeden raz, a następnie jeden lub więcej znaków, które nie są "h" ani "t".If the openAMPM group has a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t". Dopasowanie kończy się na końcu ciągu.The match ends at the end of the string. Wszystkie znaki przechwycone po znaku "h" są zawarte w grupie przechwytywania o nazwie nonHours.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Jeśli grupa openAMPM nie ma dopasowania, Dopasuj literę "h" jeden lub więcej razy, a po niej jeden lub więcej znaków, które nie są znakami "h" ani "t", po których następuje zero lub więcej znaków białych.If the openAMPM group does not have a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t", followed by zero or more white-space characters. Na koniec dopasowuje jedno lub więcej wystąpień litery "t".Finally, match one or more occurrences of the letter "t". Wszystkie znaki przechwycone po "h" i przed znakiem "t" są zawarte w grupie przechwytywania o nazwie nonHours.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

Grupa przechwytywania nonHours zawiera minutę i prawdopodobnie drugi składnik niestandardowego ciągu formatu daty i godziny wraz z dowolnym symbolem separatora czasu.The nonHours capturing group contains the minute and possibly the second component of a custom date and time format string, along with any time separator symbols. Wzorzec zamieniania HH${nonHours} dołącza podciąg "gg" do tych elementów.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Wyświetlanie i zmienianie ery w dacieDisplaying and changing the era in a date

W poniższym przykładzie specyfikator formatu niestandardowego "g" jest dodawany do właściwości LongDatePattern obiektu, który reprezentuje konwencje formatowania kultury en-US.The following example adds the "g" custom format specifier to the LongDatePattern property of an object that represents the formatting conventions of the en-US culture. To dodanie ma wpływ na trzy następujące ciągi formatu standardowego:This addition affects the following three standard format strings:

  • Ciąg formatu standardowego "D" (Long Date), który mapuje bezpośrednio do właściwości LongDatePattern.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • Ciąg formatu standardowego "f" (pełna Data/godzina krótka), który tworzy ciąg wynikowy, który łączy podciągi utworzone przez LongDatePattern i ShortTimePattern właściwości.The "f" (full date / short time) standard format string, which produces a result string that concatenates the substrings produced by the LongDatePattern and ShortTimePattern properties.

  • Ciąg formatu standardowego "F" (pełna Data/godzina długa), który mapuje bezpośrednio do właściwości FullDateTimePattern.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Ponieważ ta wartość właściwości nie została jawnie ustawiona, jest generowana dynamicznie przez połączenie właściwości LongDatePattern i LongTimePattern.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

W przykładzie pokazano również, jak zmienić nazwę ery dla kultury, której kalendarz ma pojedynczą ERA.The example also shows how to change the era name for a culture whose calendar has a single era. W takim przypadku Kultura en-US używa kalendarza gregoriańskiego, który jest reprezentowany przez obiekt GregorianCalendar.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. Klasa GregorianCalendar obsługuje pojedynczą ERA, która nazywa N.E.The GregorianCalendar class supports a single era, which it names A.D. (Anno Domini).(Anno Domini). Przykład zmienia nazwę ery na 0001The example changes the era name to C.E. (Typowy ERA) przez zastąpienie specyfikatora formatu niestandardowego "g" w ciągu formatu przypisanym do właściwości FullDateTimePattern z ciągiem literału.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. Użycie ciągu literału jest konieczne, ponieważ nazwa era jest zazwyczaj zwracana przez metodę GetEraName z danych prywatnych w tabelach kultury dostarczonych przez .NET Framework lub system operacyjny Windows.The use of a literal string is necessary, because the era name is typically returned by the GetEraName method from private data in the culture tables supplied by either the .NET Framework or the Windows operating system.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 18, 13, 30, 0);
      String[] formats = { "D", "f", "F" };

      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String originalLongDatePattern = dtfi.LongDatePattern;

      // Display the default form of three long date formats.
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

      Console.WriteLine();

      // Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

      Console.WriteLine();

      // Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       Saturday, May 18, 2013
//       Saturday, May 18, 2013 1:30 PM
//       Saturday, May 18, 2013 1:30:00 PM
//
//       Saturday, May 18, 2013 A.D.
//       Saturday, May 18, 2013 A.D. 1:30 PM
//       Saturday, May 18, 2013 A.D. 1:30:00 PM
//
//       Saturday, May 18, 2013 C.E.
//       Saturday, May 18, 2013 C.E. 1:30 PM
//       Saturday, May 18, 2013 C.E. 1:30:00 PM
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateValue As New Date(2013, 5, 18, 13, 30, 0)
      Dim formats() As String = { "D", "f", "F" }      
      
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim dtfi As DateTimeFormatInfo = enUS.DateTimeFormat
      Dim originalLongDatePattern As String = dtfi.LongDatePattern

      ' Display the default form of three long date formats.
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Modify the long date pattern.
      dtfi.LongDatePattern = originalLongDatePattern + " g"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
      Console.WriteLine()
      
      ' Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + " 'C.E.'"
      For Each fmt In formats
         Console.WriteLine(dateValue.ToString(fmt, dtfi))
      Next
   End Sub
End Module
' The example displays the following output:
'       Saturday, May 18, 2013
'       Saturday, May 18, 2013 1:30 PM
'       Saturday, May 18, 2013 1:30:00 PM
'       
'       Saturday, May 18, 2013 A.D.
'       Saturday, May 18, 2013 A.D. 1:30 PM
'       Saturday, May 18, 2013 A.D. 1:30:00 PM
'       
'       Saturday, May 18, 2013 C.E.
'       Saturday, May 18, 2013 C.E. 1:30 PM
'       Saturday, May 18, 2013 C.E. 1:30:00 PM

Analiza ciągów daty i godzinyParsing date and time strings

Analizowanie obejmuje przekonwertowanie ciągu reprezentującego datę i godzinę na wartość DateTime lub DateTimeOffset.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Oba typy obejmują metody Parse, TryParse, ParseExacti TryParseExact do obsługi operacji analizowania.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Metody Parse i TryParse konwertują ciąg, który może mieć różne formaty, podczas gdy ParseExact i TryParseExact wymagają, aby ciąg miał zdefiniowany format lub formaty.The Parse and TryParse methods convert a string that can have a variety of formats, whereas ParseExact and TryParseExact require that the string have a defined format or formats. W przypadku niepowodzenia operacji analizowania Parse i ParseExact zgłosić wyjątek, a TryParse i TryParseExact zwracać false.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Metody analizy niejawnie lub jawnie wykorzystują DateTimeStyles wartość wyliczenia, aby określić, które elementy stylu (takie jak wiodące, końcowe lub białe znaki wewnętrzne) mogą być obecne w ciągu do analizy i jak interpretować przeanalizowany ciąg lub brakujące elementy.The parsing methods implicitly or explicitly use a DateTimeStyles enumeration value to determine which style elements (such as leading, trailing, or inner white space) can be present in the string to be parsed, and how to interpret the parsed string or any missing elements. Jeśli nie podano wartości DateTimeStyles podczas wywoływania metody Parse lub TryParse, wartością domyślną jest DateTimeStyles.AllowWhiteSpaces, która jest stylem złożonym zawierającym flagi DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhitei DateTimeStyles.AllowInnerWhite.If you don't provide a DateTimeStyles value when you call the Parse or TryParse method, the default is DateTimeStyles.AllowWhiteSpaces, which is a composite style that includes the DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, and DateTimeStyles.AllowInnerWhite flags. Dla metod ParseExact i TryParseExact wartość domyślna to DateTimeStyles.None; ciąg wejściowy musi dokładnie odpowiadać określonemu ciągowi niestandardowego formatu daty i godziny.For the ParseExact and TryParseExact methods, the default is DateTimeStyles.None; the input string must correspond precisely to a particular custom date and time format string.

Metody analizy również niejawnie lub jawnie używają obiektu DateTimeFormatInfo, który definiuje określone symbole i wzorce, które mogą wystąpić w ciągu do przeanalizowania.The parsing methods also implicitly or explicitly use a DateTimeFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Jeśli nie podano obiektu DateTimeFormatInfo, domyślnie używany jest obiekt DateTimeFormatInfo dla bieżącej kultury wątku.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Aby uzyskać więcej informacji na temat analizowania ciągów daty i godziny, zobacz poszczególne metody analizy, takie jak DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExacti DateTimeOffset.TryParseExact.For more information about parsing date and time strings, see the individual parsing methods, such as DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, and DateTimeOffset.TryParseExact.

Poniższy przykład ilustruje kulturowy charakter analizy ciągów daty i godziny.The following example illustrates the culture-sensitive nature of parsing date and time strings. Próbuje on analizować dwa ciągi dat przy użyciu konwencji en-US, en-GB, fr-FR i fi-FI kultur.It tries to parse two date strings by using the conventions of the en-US, en-GB, fr-FR, and fi-FI cultures. Data, która jest interpretowana jako 8/18/2014 w kulturze en-US, zgłasza wyjątek FormatException w pozostałych trzech kulturach, ponieważ 18 jest interpretowany jako numer miesiąca.The date that is interpreted as 8/18/2014 in the en-US culture throws a FormatException exception in the other three cultures because 18 is interpreted as the month number. 1/2/2015 jest analizowany w drugim dniu pierwszego miesiąca w kulturze en-US, ale jako pierwszy dzień drugiego miesiąca w pozostałych kulturach.1/2/2015 is parsed as the second day of the first month in the en-US culture, but as the first day of the second month in the remaining cultures.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] dateStrings = { "08/18/2014", "01/02/2015" };
      string[] cultureNames = { "en-US", "en-GB", "fr-FR", "fi-FI" };

      foreach (var cultureName in cultureNames) {
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("Parsing strings using the {0} culture.",
                           culture.Name);
         foreach (var dateStr in dateStrings) {
            try {
               Console.WriteLine(String.Format(culture,
                                 "   '{0}' --> {1:D}", dateStr,
                                 DateTime.Parse(dateStr, culture)));
            }
            catch (FormatException) {
               Console.WriteLine("   Unable to parse '{0}'", dateStr);
            }
         }
      }
   }
}
// The example displays the following output:
//       Parsing strings using the en-US culture.
//          '08/18/2014' --> Monday, August 18, 2014
//          '01/02/2015' --> Friday, January 02, 2015
//       Parsing strings using the en-GB culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 01 February 2015
//       Parsing strings using the fr-FR culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> dimanche 1 février 2015
//       Parsing strings using the fi-FI culture.
//          Unable to parse '08/18/2014'
//          '01/02/2015' --> 1. helmikuuta 2015
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateStrings() As String = { "08/18/2014", "01/02/2015" }
      Dim cultureNames() As String = { "en-US", "en-GB", "fr-FR", "fi-FI" }
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Parsing strings using the {0} culture.", 
                           culture.Name)
         For Each dateStr In dateStrings
            Try
               Console.WriteLine(String.Format(culture, 
                                 "   '{0}' --> {1:D}", dateStr, 
                                 DateTime.Parse(dateStr, culture)))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'", dateStr)
            End Try
         Next
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing strings using the en-US culture.
'          '08/18/2014' --> Monday, August 18, 2014
'          '01/02/2015' --> Friday, January 02, 2015
'       Parsing strings using the en-GB culture.
'          Unable to parse '08/18/2014'
'          '01/02/2015' --> 01 February 2015
'       Parsing strings using the fr-FR culture.
'          Unable to parse '08/18/2014'
'          '01/02/2015' --> dimanche 1 février 2015
'       Parsing strings using the fi-FI culture.
'          Unable to parse '08/18/2014'
'          '01/02/2015' --> 1. helmikuuta 2015

Ciągi daty i godziny są zwykle analizowane z dwóch powodów:Date and time strings are typically parsed for two reasons:

  • Aby przekonwertować dane wejściowe użytkownika na wartość daty i godziny.To convert user input into a date and time value.

  • Aby zaokrąglić wartość daty i godziny, oznacza to, że w celu deserializacji wartości daty i godziny, która była uprzednio serializowana jako ciąg.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

W poniższych sekcjach szczegółowo omówiono te dwie operacje.The following sections discuss these two operations in greater detail.

Analiza ciągów użytkownikaParsing user strings

Podczas analizowania ciągów daty i godziny w danych wejściowych użytkownika należy zawsze utworzyć wystąpienie DateTimeFormatInfo obiektu, który odzwierciedla ustawienia kulturowe użytkownika, łącznie z dowolnymi dostosowaniami przez użytkownika.When you parse date and time strings input by the user, you should always instantiate a DateTimeFormatInfo object that reflects the user's cultural settings, including any customizations the user may have made. W przeciwnym razie obiekt date i Time może mieć nieprawidłowe wartości.Otherwise, the date and time object may have incorrect values. Informacje o sposobie tworzenia wystąpienia obiektu DateTimeFormatInfo, który odzwierciedla dostosowania kulturowe użytkownika, można znaleźć w sekcji DateTimeFormatInfo i dane dynamiczne .For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

Poniższy przykład ilustruje różnicę między operacją analizowania, która odzwierciedla ustawienia kulturowe użytkownika i takie, które nie.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. W tym przypadku domyślna kultura systemowa to en-US, ale użytkownik użył panelu sterowania, regionu i języka , aby zmienić wzorzec daty krótkiej z domyślnego "M/d/rrrr" na "RR/mm/dd".In this case, the default system culture is en-US, but the user has used Control Panel, Region and Language to change the short date pattern from its default of "M/d/yyyy" to "yy/MM/dd". Gdy użytkownik wprowadza ciąg, który odzwierciedla ustawienia użytkownika, a ciąg jest analizowany przez obiekt DateTimeFormatInfo, który również odzwierciedla ustawienia użytkownika (przesłonięcia), operacja analizowania zwraca prawidłowy wynik.When the user enters a string that reflects user settings, and the string is parsed by a DateTimeFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Jeśli jednak ciąg jest analizowany przez obiekt DateTimeFormatInfo, który odzwierciedla standardowe ustawienia kulturowe en-US, metoda analizy zgłasza wyjątek FormatException, ponieważ interpretuje 14 jako liczbę miesięcy, a nie ostatnie dwie cyfry roku.However, when the string is parsed by a DateTimeFormatInfo object that reflects standard en-US cultural settings, the parsing method throws a FormatException exception because it interprets 14 as the number of the month, not the last two digits of the year.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string inputDate = "14/05/10";

      CultureInfo[] cultures = { CultureInfo.GetCultureInfo("en-US"),
                                 CultureInfo.CreateSpecificCulture("en-US") };

      foreach (var culture in cultures) {
         try {
            Console.WriteLine("{0} culture reflects user overrides: {1}",
                              culture.Name, culture.UseUserOverride);
            DateTime occasion = DateTime.Parse(inputDate, culture);
            Console.WriteLine("'{0}' --> {1}", inputDate,
                              occasion.ToString("D", CultureInfo.InvariantCulture));
         }
         catch (FormatException) {
            Console.WriteLine("Unable to parse '{0}'", inputDate);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       Unable to parse '14/05/10'
//
//       en-US culture reflects user overrides: True
//       '14/05/10' --> Saturday, 10 May 2014
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim inputDate As String = "14/05/10"
      
      Dim cultures() As CultureInfo = { CultureInfo.GetCultureInfo("en-US"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      
      For Each culture In cultures
         Try
            Console.WriteLine("{0} culture reflects user overrides: {1}", 
                              culture.Name, culture.UseUserOverride)
            Dim occasion As DateTime = DateTime.Parse(inputDate, culture)
            Console.WriteLine("'{0}' --> {1}", inputDate, 
                              occasion.ToString("D", CultureInfo.InvariantCulture))
         Catch e As FormatException
            Console.WriteLine("Unable to parse '{0}'", inputDate)                           
         End Try   
         Console.WriteLine()  
      Next
   End Sub
End Module
' The example displays the following output:
'       en-US culture reflects user overrides: False
'       Unable to parse '14/05/10'
'       
'       en-US culture reflects user overrides: True
'       '14/05/10' --> Saturday, 10 May 2014

Serializacja i deserializacja danych daty i godzinySerializing and deserializing date and time data

Serializowane dane daty i godziny są oczekiwane do rundy; oznacza to, że wszystkie wartości serializowane i deserializowane powinny być identyczne.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Jeśli wartość daty i godziny reprezentuje pojedynczy moment w czasie, wartość deserializowana powinna reprezentować ten sam moment w czasie, niezależnie od kultury lub strefy czasowej systemu, w którym została przywrócona.If a date and time value represents a single moment in time, the deserialized value should represent the same moment in time regardless of the culture or time zone of the system on which it was restored. Aby pomyślnie zaokrąglić dane daty i godziny, należy użyć Konwencji niezmiennej niezmiennej, która jest zwracana przez właściwość InvariantInfo, aby generować i analizować dane.To round-trip date and time data successfully, you must use the conventions of the invariant culture, which is returned by the InvariantInfo property, to generate and parse the data. Operacje formatowania i analizowania nigdy nie powinny odzwierciedlać Konwencji domyślnej kultury.The formatting and parsing operations should never reflect the conventions of the default culture. Jeśli używasz domyślnych ustawień kultury, przenośność danych jest ściśle ograniczona; można go pomyślnie deserializować tylko w wątku, którego ustawienia specyficzne dla kultury są takie same jak w wątku, w którym został on Zserializowany.If you use default cultural settings, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose cultural-specific settings are identical to those of the thread on which it was serialized. W niektórych przypadkach oznacza to, że dane nie mogą być nawet pomyślnie serializowane i deserializowane w tym samym systemie.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Jeśli składnik czasu wartości daty i godziny jest znaczący, powinien również zostać przekonwertowany na czas UTC i serializować przy użyciu standardowego ciągu formatu"o" lub "r".If the time component of a date and time value is significant, it should also be converted to UTC and serialized by using the "o" or "r" standard format string. Dane czasu można następnie przywrócić przez wywołanie metody analizy i przekazanie jej odpowiedniego ciągu formatu wraz z niezmienną kulturą jako argumentem provider.The time data can then be restored by calling a parsing method and passing it the appropriate format string along with the invariant culture as the provider argument.

Poniższy przykład ilustruje proces okrężnej wartości daty i godziny.The following example illustrates the process of round-tripping a date and time value. Deserializacji datę i godzinę w systemie, który obserwuje czas pacyficzny USA, i którego bieżąca kultura jest EN-US.It serializes a date and time on a system that observes U.S. Pacific time and whose current culture is en-US.

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\DateData.dat");
      // Define a date and time to serialize.
      DateTime originalDate = new DateTime(2014, 08, 18, 08, 16, 35);
      // Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate);
      Console.WriteLine("Current Culture:   {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}",
                        TimeZoneInfo.Local.DisplayName);
      // Convert the date value to UTC.
      DateTime utcDate = originalDate.ToUniversalTime();
      // Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo));
      sw.Close();
   }
}
// The example displays the following output:
//       Date to serialize: Monday, August 18, 2014 8:16:35 AM
//       Current Culture:   en-US
//       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\DateData.dat")
      ' Define a date and time to serialize.
      Dim originalDate As New Date(2014, 08, 18, 08, 16, 35)
      ' Display information on the date and time.
      Console.WriteLine("Date to serialize: {0:F}", originalDate)
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName)
      ' Convert the date value to UTC.
      Dim utcDate As Date = originalDate.ToUniversalTime()
      ' Serialize the UTC value.
      sw.Write(utcDate.ToString("o", DateTimeFormatInfo.InvariantInfo))
      sw.Close()
   End Sub
End Module
' The example displays the following output:
'       Date to serialize: Monday, August 18, 2014 8:16:35 AM
'       Current Culture:   en-US
'       Time Zone:         (UTC-08:00) Pacific Time (US & Canada)

Deserializacji dane w systemie w Brukseli, Kopenhaga, Madrytu i paryskiej strefie czasowej, których bieżącą kulturą jest fr-FR.It deserializes the data on a system in the Brussels, Copenhagen, Madrid and Paris time zone and whose current culture is fr-FR. Przywrócona Data to dziewięć godzin później niż oryginalna data, która odzwierciedla korektę strefy czasowej z ośmiu godzin za UTC do godziny przed czasem UTC.The restored date is nine hours later than the original date, which reflects the time zone adjustment from eight hours behind UTC to one hour ahead of UTC. Zarówno Data oryginalna, jak i Data przywrócenia reprezentują ten sam moment w czasie.Both the original date and the restored date represent the same moment in time.

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      // Open the file and retrieve the date string.
      StreamReader sr = new StreamReader(@".\DateData.dat");
      String dateValue = sr.ReadToEnd();

      // Parse the date.
      DateTime parsedDate = DateTime.ParseExact(dateValue, "o",
                            DateTimeFormatInfo.InvariantInfo);
      // Convert it to local time.
      DateTime restoredDate = parsedDate.ToLocalTime();
      // Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate);
      Console.WriteLine("Current Culture:   {0}",
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Time Zone:         {0}",
                        TimeZoneInfo.Local.DisplayName);
   }
}
// The example displays the following output:
//    Deserialized date: lundi 18 août 2014 17:16:35
//    Current Culture:   fr-FR
//    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      ' Open the file and retrieve the date string.
      Dim sr As New StreamReader(".\DateData.dat")             
      Dim dateValue As String = sr.ReadToEnd()
      
      ' Parse the date.
      Dim parsedDate As Date = Date.ParseExact(dateValue, "o", 
                               DateTimeFormatInfo.InvariantInfo)
      ' Convert it to local time.                             
      Dim restoredDate As Date = parsedDate.ToLocalTime()
      ' Display information on the date and time.
      Console.WriteLine("Deserialized date: {0:F}", restoredDate)
      Console.WriteLine("Current Culture:   {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Time Zone:         {0}", 
                        TimeZoneInfo.Local.DisplayName)
   End Sub
End Module
' The example displays the following output:
'    Deserialized date: lundi 18 août 2014 17:16:35
'    Current Culture:   fr-FR
'    Time Zone:         (UTC+01:00) Brussels, Copenhagen, Madrid, Paris

Konstruktory

DateTimeFormatInfo()

Inicjuje nowe, zapisywalne wystąpienie klasy DateTimeFormatInfo, która jest niezależna od kultury (niezmienna).Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Właściwości

AbbreviatedDayNames

Pobiera lub ustawia jednowymiarową tablicę typu String zawierającą skrócone nazwy dla określonych kultur dni tygodnia.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames

Pobiera lub ustawia tablicę ciągów zawierającą skrócone nazwy miesięcy skojarzone z bieżącym obiektem DateTimeFormatInfo.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames

Pobiera lub ustawia jednowymiarową tablicę ciągów, która zawiera skrócone nazwy miesięcy określonych dla kultury.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator

Pobiera lub ustawia oznaczenie ciągu dla godzin, które są "ante meridiem" (przed południem).Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar

Pobiera lub ustawia kalendarz, który ma być używany dla bieżącej kultury.Gets or sets the calendar to use for the current culture.

CalendarWeekRule

Pobiera lub ustawia wartość określającą, która reguła jest używana do określenia pierwszego tygodnia kalendarzowego roku.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo

Pobiera obiekt DateTimeFormatInfo tylko do odczytu, który formatuje wartości w oparciu o bieżącą kulturę.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator

Pobiera lub ustawia ciąg oddzielający składniki daty, czyli rok, miesiąc i dzień.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames

Pobiera lub ustawia jednowymiarową tablicę ciągów, która zawiera pełne nazwy charakterystyczne dla kultury dni tygodnia.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek

Pobiera lub ustawia pierwszy dzień tygodnia.Gets or sets the first day of the week.

FullDateTimePattern

Pobiera lub ustawia ciąg formatu niestandardowego dla wartości daty długiej i godziny długiej.Gets or sets the custom format string for a long date and long time value.

InvariantInfo

Pobiera domyślny obiekt DateTimeFormatInfo tylko do odczytu, który jest niezależny od kultury (niezmienna).Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly

Pobiera wartość wskazującą, czy DateTimeFormatInfo obiekt jest tylko do odczytu.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern

Pobiera lub ustawia ciąg formatu niestandardowego dla wartości daty długiej.Gets or sets the custom format string for a long date value.

LongTimePattern

Pobiera lub ustawia niestandardowy ciąg formatu dla długiej wartości czasu.Gets or sets the custom format string for a long time value.

MonthDayPattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości miesiąca i dnia.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames

Pobiera lub ustawia tablicę ciągów nazw miesięcy skojarzonych z bieżącym obiektem DateTimeFormatInfo.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames

Pobiera lub ustawia jednowymiarową tablicę typu String zawierającą pełne nazwy miesięcy charakterystyczne dla kultury.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName

Pobiera natywną nazwę kalendarza skojarzonego z bieżącym obiektem DateTimeFormatInfo.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator

Pobiera lub ustawia oznaczenie ciągu dla godzin, które są "post meridiem" (po południu).Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern

Pobiera niestandardowy ciąg formatu dla wartości czasu, która jest oparta na specyfikacji żądania RFC (Internet Engineering Task Force) dla programu Comments (IETF) 1123.Gets the custom format string for a time value that is based on the Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 specification.

ShortDatePattern

Pobiera lub ustawia ciąg formatu niestandardowego dla krótkiej wartości daty.Gets or sets the custom format string for a short date value.

ShortestDayNames

Pobiera lub ustawia tablicę ciągów najkrótszych unikatowych nazw skróconych dni skojarzonych z bieżącym obiektem DateTimeFormatInfo.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości godziny krótkiej.Gets or sets the custom format string for a short time value.

SortableDateTimePattern

Pobiera niestandardowy ciąg formatu dla wartości daty i godziny sortowania.Gets the custom format string for a sortable date and time value.

TimeSeparator

Pobiera lub ustawia ciąg oddzielający składniki czasu, czyli godzinę, minuty i sekundy.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern

Pobiera niestandardowy ciąg formatu dla uniwersalnego, sortowanego ciągu daty i godziny, zgodnie z definicją ISO 8601.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości roku i miesiąca.Gets or sets the custom format string for a year and month value.

Metody

Clone()

Tworzy skróconą kopię DateTimeFormatInfo.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetAbbreviatedDayName(DayOfWeek)

Zwraca skróconą nazwę określonego dnia tygodnia w oparciu o kulturę skojarzoną z bieżącym obiektem DateTimeFormatInfo.Returns the culture-specific abbreviated name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetAbbreviatedEraName(Int32)

Zwraca ciąg zawierający skróconą nazwę podanej ery, jeśli istnieje skrót.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32)

Zwraca skróconą nazwę określonego miesiąca określoną dla kultury w oparciu o kulturę skojarzoną z bieżącym obiektem DateTimeFormatInfo.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns()

Zwraca wszystkie wzorce standardowe, w których można sformatować wartości daty i godziny.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char)

Zwraca wszystkie wzorce, w których wartości daty i godziny można sformatować przy użyciu określonego ciągu formatu standardowego.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek)

Zwraca pełną nazwę określonego dnia tygodnia w oparciu o kulturę skojarzoną z bieżącym obiektem DateTimeFormatInfo.Returns the culture-specific full name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetEra(String)

Zwraca liczbę całkowitą reprezentującą określoną ERA.Returns the integer representing the specified era.

GetEraName(Int32)

Zwraca ciąg zawierający nazwę określonego ery.Returns the string containing the name of the specified era.

GetFormat(Type)

Zwraca obiekt określonego typu, który udostępnia usługę formatowania daty i godziny.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetInstance(IFormatProvider)

Zwraca obiekt DateTimeFormatInfo skojarzony z określonym IFormatProvider.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32)

Zwraca pełną nazwę określonego miesiąca w oparciu o kulturę skojarzoną z bieżącym obiektem DateTimeFormatInfo.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek)

Uzyskuje najkrótszą skróconą nazwę dnia dla określonego dnia tygodnia, która jest skojarzona z bieżącym obiektem DateTimeFormatInfo.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Object.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
ReadOnly(DateTimeFormatInfo)

Zwraca otokę DateTimeFormatInfo tylko do odczytu.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char)

Ustawia niestandardowe ciągi formatujące datę i godzinę odpowiadające określonemu ciągowi formatu standardowego.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Dotyczy

Zobacz też