DateTimeFormatInfo Klasa

Definicja

Udostępnia informacje specyficzne dla kultury dotyczące formatu wartości daty i godziny.

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.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
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

W poniższym przykładzie użyto odbicia w celu pobrania właściwości DateTimeFormatInfo obiektu dla kultury języka angielskiego (Stany Zjednoczone). Wyświetla wartość tych właściwości, które zawierają niestandardowe ciągi formatu i używa tych ciągów do wyświetlania sformatowanych dat.

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 DateTimeFormatInfo klasy zawierają informacje specyficzne dla kultury do formatowania lub analizowania wartości daty i godziny, takie jak:

  • Wzorce używane do formatowania wartości daty.

  • Wzorce używane do formatowania wartości czasu.

  • Nazwy dni tygodnia.

  • Nazwy miesięcy roku.

  • The A.M. i P.M. designatory używane w wartościach czasu.

  • Kalendarz, w którym są wyrażone daty.

W tej sekcji:

Utworzenie wystąpienia obiektu DateTimeFormatInfo

DateTimeFormatInfo Obiekt może reprezentować konwencje formatowania niezmiennej kultury, konkretnej kultury, kultury neutralnej lub bieżącej kultury. W tej sekcji omówiono sposób tworzenia wystąpienia każdego typu DateTimeFormatInfo obiektu.

Utworzenie wystąpienia obiektu DateTimeFormatInfo dla kultury niezmiennej

Niezmienna kultura reprezentuje kulturę, w której nie uwzględnia się ustawień kulturowych. Jest on oparty na języku angielskim, ale nie na żadnym konkretnym kraju/regionie języka angielskiego. Chociaż dane określonych kultur mogą być dynamiczne i mogą ulec zmianie w celu odzwierciedlenia nowych konwencji kulturowych lub preferencji użytkownika, dane niezmiennej kultury nie zmieniają się. Wystąpienie obiektu reprezentującego konwencje formatowania niezmiennej kultury można utworzyć DateTimeFormatInfo w następujący sposób:

W poniższym przykładzie użyto każdej z tych metod do utworzenia wystąpienia DateTimeFormatInfo obiektu reprezentującego niezmienną kulturę. Następnie wskazuje, czy obiekt jest tylko do odczytu.

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 kultury

Określona kultura reprezentuje język, który jest używany w określonym kraju/regionie. Na przykład en-US jest konkretną kulturą, która reprezentuje język angielski mówiony w Stany Zjednoczone, a en-CA jest konkretną kulturą, która reprezentuje język angielski mówiony w Kanadzie. Wystąpienie obiektu reprezentującego konwencje formatowania określonej kultury można utworzyć DateTimeFormatInfo w następujący sposób:

Poniższy przykład ilustruje każdy z tych sposobów tworzenia wystąpienia DateTimeFormatInfo obiektu i wskazuje, czy wynikowy obiekt jest tylko do odczytu.

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 neutralnej

Neutralna kultura reprezentuje kulturę lub język, który jest niezależny od kraju/regionu; jest to zazwyczaj element nadrzędny co najmniej jednej konkretnej kultury. Na przykład Fr jest neutralną kulturą języka francuskiego i rodzicem kultury fr-FR. Można utworzyć wystąpienie DateTimeFormatInfo obiektu reprezentującego konwencje formatowania kultury neutralnej w taki sam sposób, jak tworzy DateTimeFormatInfo się obiekt reprezentujący konwencje formatowania określonej kultury. Ponadto można pobrać obiekt kultury neutralnej DateTimeFormatInfo , pobierając neutralną kulturę z właściwości określonej kultury CultureInfo.Parent i pobierając DateTimeFormatInfo obiekt zwrócony przez jego CultureInfo.DateTimeFormat właściwość. Jeśli kultura nadrzędna nie reprezentuje niezmiennej kultury, zwracany obiekt jest odczytywany/zapisywany DateTimeFormatInfo . Poniższy przykład ilustruje te sposoby tworzenia wystąpienia DateTimeFormatInfo obiektu, który reprezentuje kulturę neutralną.

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 wersji 1.0 do .NET Framework 3.5 próbuje pobrać DateTimeFormatInfo obiekt, który odzwierciedla konwencje formatowania neutralnej kultury zgłasza NotSupportedException wyjątek.

Jednak kultura neutralna nie ma informacji o formatowaniu specyficznym dla kultury, ponieważ jest niezależna od określonego kraju/regionu. Zamiast wypełniać DateTimeFormatInfo obiekt wartościami ogólnymi, .NET Framework zwraca DateTimeFormatInfo obiekt, który odzwierciedla konwencje formatowania określonej kultury, która jest elementem podrzędnym kultury neutralnej. Na przykład DateTimeFormatInfo obiekt neutralnej kultury en odzwierciedla konwencje formatowania kultury en-US, a DateTimeFormatInfo obiekt kultury fr odzwierciedla konwencje formatowania kultury fr-FR.

Możesz użyć kodu, takiego jak poniżej, aby określić, które konwencje formatowania określonej kultury reprezentują neutralną kulturę. W przykładzie użyto odbicia w celu porównania DateTimeFormatInfo właściwości kultury neutralnej z właściwościami określonej kultury podrzędnej. Uważa, że dwa kalendarze mają być równoważne, jeśli są one tym samym typem kalendarza i, w przypadku kalendarzy gregoriańskich, jeśli ich GregorianCalendar.CalendarType właściwości mają identyczne wartości.

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 kultury

Wystąpienie obiektu reprezentującego konwencje formatowania bieżącej kultury można utworzyć DateTimeFormatInfo w następujący sposób:

W poniższym przykładzie użyto każdej z tych metod do utworzenia wystąpienia DateTimeFormatInfo obiektu reprezentującego konwencje formatowania bieżącej kultury. Następnie wskazuje, czy obiekt jest tylko do odczytu.

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 DateTimeFormatInfo obiekt reprezentujący konwencje bieżącej kultury na jeden z następujących sposobów:

Poniższy przykład ilustruje każdy sposób tworzenia wystąpienia obiektu odczytu/zapisu DateTimeFormatInfo i wyświetla wartość jego IsReadOnly właściwości.

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 Windows użytkownik może zastąpić niektóre DateTimeFormatInfo wartości właściwości używane w operacjach formatowania i analizowania za pośrednictwem aplikacji Region i Język w Panel sterowania. Na przykład użytkownik, którego kultura jest angielska (Stany Zjednoczone) może wybrać wyświetlanie długich wartości czasu przy użyciu zegara 24-godzinnego (w formacie HH:mm:ss) zamiast domyślnego zegara 12-godzinnego (w formacie h:mm:ss tt). Obiekty DateTimeFormatInfo pobrane w sposób omówiony wcześniej wszystkie odzwierciedlają te przesłonięcia użytkownika. Jeśli jest to niepożądane, można utworzyć NumberFormatInfo obiekt, który nie odzwierciedla przesłonięć użytkownika (i jest również odczytywany/zapisywany zamiast tylko do odczytu), wywołując CultureInfo.CultureInfo(String, Boolean) konstruktor i podając wartość false argumentu useUserOverride . W poniższym przykładzie pokazano to dla systemu, którego bieżąca kultura jest angielska (Stany Zjednoczone) i której wzorzec długi czas został zmieniony z wartości domyślnej h:mm:ss tt na 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 dynamiczne

Dane specyficzne dla kultury do formatowania wartości daty i godziny dostarczone przez klasę DateTimeFormatInfo są dynamiczne, podobnie jak dane kulturowe dostarczane przez klasę CultureInfo . Nie należy wprowadzać żadnych założeń dotyczących stabilności wartości obiektów DateTimeFormatInfo skojarzonych z określonymi CultureInfo obiektami. Tylko dane dostarczone przez niezmienną kulturę i skojarzony z DateTimeFormatInfo nim obiekt są stabilne. Inne dane mogą zmieniać się między sesjami aplikacji, a nawet podczas uruchamiania aplikacji. Istnieją cztery główne źródła zmian:

  • Aktualizacje systemu. Preferencje kulturowe, takie jak preferowany kalendarz lub niestandardowe formaty dat i godzin zmieniają się wraz z upływem czasu. W takim przypadku Windows Update zawiera zmiany DateTimeFormatInfo wartości właściwości dla określonej kultury.

  • Kultury zastępcze. Klasa CultureAndRegionInfoBuilder może służyć do zastępowania danych istniejącej kultury.

  • Kaskadowe zmiany wartości właściwości. Wiele właściwości związanych z kulturą może ulec zmianie w czasie wykonywania, co z kolei powoduje DateTimeFormatInfo zmianę danych. Na przykład bieżąca kultura może zostać zmieniona programowo lub za pomocą akcji użytkownika. W takim przypadku DateTimeFormatInfo obiekt zwrócony przez CurrentInfo właściwość zmienia się na obiekt skojarzony z bieżącą kulturą. Podobnie kalendarz kultury może ulec zmianie, co może spowodować zmiany w wielu DateTimeFormatInfo wartościach właściwości.

  • Preferencje użytkownika. Użytkownicy aplikacji mogą zastąpić niektóre wartości skojarzone z bieżącą kulturą systemu za pomocą opcji regionalnych i językowych w Panel sterowania. Na przykład użytkownicy mogą wybrać wyświetlanie daty w innym formacie. Jeśli właściwość jest ustawiona CultureInfo.UseUserOverride na truewartość , właściwości DateTimeFormatInfo obiektu również są pobierane z ustawień użytkownika. 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 wskazanych przez OptionalCalendars właściwość), wyniki metod i wartości właściwości są niezdefiniowane.

Aby zminimalizować możliwość niespójnych danych, podczas tworzenia obiektu inicjowane są wszystkie właściwości DateTimeFormatInfo obiektu, które można przesłonić. Nadal istnieje możliwość niespójności, ponieważ proces tworzenia obiektu ani zastępowania przez użytkownika nie jest niepodzielne, a odpowiednie wartości mogą ulec zmianie podczas tworzenia obiektu. Jednak sytuacja ta powinna być niezwykle rzadka.

Możesz kontrolować, czy przesłonięcia użytkownika są odzwierciedlane w DateTimeFormatInfo obiektach reprezentujących tę samą kulturę co kultura systemowa. W poniższej tabeli wymieniono sposoby pobierania DateTimeFormatInfo obiektu i wskazuje, czy wynikowy obiekt odzwierciedla przesłonięcia użytkowników.

Źródło obiektów CultureInfo i DateTimeFormatInfo Odzwierciedla przesłonięcia użytkowników
CultureInfo.CurrentCulture.DateTimeFormat Właściwość Tak
DateTimeFormatInfo.CurrentInfo Właściwość Tak
Metoda CultureInfo.CreateSpecificCulture Tak
Metoda CultureInfo.GetCultureInfo Nie
CultureInfo.CultureInfo(String) Konstruktor Tak
CultureInfo.CultureInfo(String, Boolean) Konstruktor Zależy od wartości parametru useUserOverride

Jeśli nie istnieje przekonujący powód, aby zrobić inaczej, należy przestrzegać przesłonięć użytkowników podczas używania DateTimeFormatInfo obiektu w aplikacjach klienckich do formatowania i analizowania danych wejściowych użytkownika lub wyświetlania danych. W przypadku aplikacji serwerowych lub aplikacji nienadzorowanych nie należy. Jeśli jednak używasz DateTimeFormatInfo obiektu jawnie lub niejawnie do utrwalania danych daty i godziny w postaci ciągu, należy użyć DateTimeFormatInfo obiektu, który odzwierciedla konwencje formatowania niezmiennej kultury lub należy określić niestandardowy ciąg formatu daty i godziny, który jest używany niezależnie od kultury.

Formatowanie daty i godziny

DateTimeFormatInfo Obiekt jest używany niejawnie lub jawnie we wszystkich operacjach formatowania daty i godziny. Obejmują one wywołania następujących metod:

Wszystkie operacje formatowania daty i godziny korzystają z implementacji IFormatProvider . Interfejs IFormatProvider zawiera jedną metodę . IFormatProvider.GetFormat(Type) Ta metoda wywołania zwrotnego jest przekazywana do obiektu reprezentującego Type typ wymagany do dostarczenia informacji o formatowaniu. Metoda zwraca wystąpienie tego typu lub null jeśli nie może podać wystąpienia typu. .NET Framework zawiera dwie IFormatProvider implementacje formatowania dat i godzin:

Jeśli implementacja IFormatProvider nie zostanie jawnie dostarczona do metody formatowania, CultureInfo używany jest obiekt zwrócony przez CultureInfo.CurrentCulture właściwość reprezentującą bieżącą kulturę.

Poniższy przykład ilustruje relację między interfejsem IFormatProvider a klasą DateTimeFormatInfo w operacjach formatowania. Definiuje on implementację niestandardową IFormatProvider , której GetFormat metoda wyświetla typ obiektu żądanego przez operację formatowania. Jeśli żąda DateTimeFormatInfo obiektu, metoda udostępnia DateTimeFormatInfo obiekt dla bieżącej kultury. Jak pokazano w danych wyjściowych z przykładu, Decimal.ToString(IFormatProvider) metoda żąda DateTimeFormatInfo obiektu w celu udostępnienia informacji o formatowaniu, natomiast String.Format(IFormatProvider, String, Object[]) metody żądań NumberFormatInfo i DateTimeFormatInfo obiektów oraz implementacji ICustomFormatter .

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, 13, 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 DateTimeFormatInfo

Obiekt DateTimeFormatInfo zawiera trzy rodzaje właściwości, które są używane w operacjach formatowania z wartościami daty i godziny:

Standardowe ciągi formatu daty i godziny, takie jak "d", "D", "f" i "F", są aliasami odpowiadającymi określonym DateTimeFormatInfo właściwościom wzorca formatu. Większość niestandardowych ciągów formatu daty i godziny jest związana z ciągami lub podciągami, które operacja formatowania wstawia do strumienia wyników. W poniższej tabeli wymieniono standardowe i niestandardowe specyfikatory formatu daty i godziny oraz skojarzone z DateTimeFormatInfo nimi właściwości. Aby uzyskać szczegółowe informacje na temat używania tych specyfikatorów formatu, zobacz Standardowe ciągi formatu daty i godziny oraz Niestandardowe ciągi formatu daty i godziny. Należy pamiętać, że każdy ciąg formatu standardowego DateTimeFormatInfo odpowiada właściwości, której wartość jest niestandardowym ciągiem formatu daty i godziny. Poszczególne specyfikatory w tym ciągu formatu niestandardowego z kolei odpowiadają innym DateTimeFormatInfo właściwościom. Tabela zawiera listę tylko DateTimeFormatInfo właściwości, dla których ciągi formatu standardowego są aliasami i nie wyświetla właściwości, do których można uzyskać dostęp za pomocą niestandardowych ciągów formatu przypisanych do tych właściwości aliasów. Ponadto tabela zawiera listę tylko specyfikatorów formatu niestandardowego, które odpowiadają właściwościom DateTimeFormatInfo .

Specyfikator formatu Skojarzone właściwości
"d" (data krótka; standardowy ciąg formatu) ShortDatePattern, aby zdefiniować ogólny format ciągu wynikowego.
"D" (data długa; standardowy ciąg formatu) LongDatePattern, aby zdefiniować ogólny format ciągu wynikowego.
"f" (pełna data/krótki czas; standardowy ciąg formatu) LongDatePattern, aby zdefiniować format składnika daty ciągu wynikowego.

ShortTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.
"F" (pełna data/godzina długa; standardowy ciąg formatu) LongDatePattern, aby zdefiniować format składnika daty ciągu wynikowego.

LongTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.
"g" (ogólna data/godzina krótka; standardowy ciąg formatu) ShortDatePattern, aby zdefiniować format składnika daty ciągu wynikowego.

ShortTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.
"G" (ogólna data/godzina długa; standardowy ciąg formatu) ShortDatePattern, aby zdefiniować format składnika daty ciągu wynikowego.

LongTimePattern, aby zdefiniować format składnika czasu ciągu wynikowego.
"M", "m" (miesiąc/dzień; standardowy ciąg formatu) MonthDayPattern, aby zdefiniować ogólny format ciągu wynikowego.
"O", "o" (data/godzina rundy; standardowy ciąg formatu) Brak.
"R", "r" (RFC1123; ciąg formatu standardowego) RFC1123Pattern, aby zdefiniować ciąg wynikowy zgodny ze standardem RFC 1123. Właściwość jest tylko do odczytu.
"s" (sortowalna data/godzina; standardowy ciąg formatu) SortableDateTimePattern, aby zdefiniować ciąg wynikowy zgodny ze standardem ISO 8601. Właściwość jest tylko do odczytu.
"t" (krótki czas; standardowy ciąg formatu) ShortTimePattern, aby zdefiniować ogólny format ciągu wynikowego.
"T" (długi czas; standardowy ciąg formatu) LongTimePattern, aby zdefiniować ogólny format ciągu wynikowego.
"u" (uniwersalna sortowalna data/godzina; standardowy ciąg formatu) UniversalSortableDateTimePattern, aby zdefiniować ciąg wynikowy zgodny ze standardem ISO 8601 dla uniwersalnego czasu koordynowanego. Właściwość jest tylko do odczytu.
"U" (uniwersalna pełna data/godzina; standardowy ciąg formatu) FullDateTimePattern, aby zdefiniować ogólny format ciągu wynikowego.
"Y", "y" (miesiąc roku; standardowy ciąg formatu) YearMonthPattern, aby zdefiniować ogólny format ciągu wynikowego.
"ddd" (specyfikator formatu niestandardowego) AbbreviatedDayNames, aby uwzględnić skróconą nazwę dnia tygodnia w ciągu wynikowym.
"g", "gg" (specyfikator formatu niestandardowego) Wywołuje metodę GetEraName , aby wstawić nazwę ery w ciągu wynikowym.
"MMM" (specyfikator formatu niestandardowego) AbbreviatedMonthNames, aby uwzględnić skróconą nazwę miesiąca w ciągu wynikowym.
"MMMM" (specyfikator formatu niestandardowego) MonthNames lub MonthGenitiveNames, aby uwzględnić pełną nazwę miesiąca w ciągu wynikowym.
"t" (specyfikator formatu niestandardowego) AMDesignator lub PMDesignator, aby uwzględnić pierwszy znak projektowania AM/PM w ciągu wynikowym.
"tt" (specyfikator formatu niestandardowego) AMDesignator lub PMDesignator, aby uwzględnić pełny designator AM/PM w ciągu wynikowym.
":" (specyfikator formatu niestandardowego) TimeSeparator, aby uwzględnić separator czasu w ciągu wynikowym.
"/" (specyfikator formatu niestandardowego) DateSeparator, aby uwzględnić separator daty w ciągu wynikowym.

Modyfikowanie właściwości DateTimeFormatInfo

Ciąg wynikowy wygenerowany przez ciągi formatu daty i godziny można zmienić, modyfikując skojarzone właściwości obiektu zapisywalnego DateTimeFormatInfo . Aby określić, czy DateTimeFormatInfo obiekt jest zapisywalny, użyj IsReadOnly właściwości . Aby dostosować DateTimeFormatInfo obiekt w ten sposób:

  1. Utwórz kopię DateTimeFormatInfo do odczytu/zapisu obiektu, którego konwencje formatowania chcesz zmodyfikować. (Zobacz sekcję tworzenia wystąpienia obiektu DateTimeFormatInfo ).

  2. Zmodyfikuj właściwość lub właściwości, które są używane do generowania żądanego ciągu wynikowego. (Aby uzyskać informacje o sposobie formatowania metod używania DateTimeFormatInfo właściwości do definiowania ciągów wyników, zobacz poprzednią sekcję, Formatowanie ciągów i właściwości DateTimeFormatInfo).

  3. Użyj obiektu niestandardowego DateTimeFormatInfo utworzonego IFormatProvider jako argumentu w wywołaniach do metod formatowania.

Istnieją dwa inne sposoby zmiany formatu ciągu wynikowego:

  • Możesz użyć CultureAndRegionInfoBuilder klasy , aby zdefiniować kulturę niestandardową (kulturę, która ma unikatową nazwę i która uzupełnia istniejące kultury) lub kulturę zastępczą (używaną zamiast określonej kultury). Możesz zapisywać i uzyskiwać dostęp do tej kultury programowo, tak jak każdy CultureInfo obiekt obsługiwany przez .NET Framework.

  • Jeśli ciąg wyniku nie jest uwzględniany w kulturze i nie ma wstępnie zdefiniowanego formatu, możesz użyć niestandardowego ciągu formatu daty i godziny. Jeśli na przykład serializujesz dane daty i godziny w formacie RRRRMMDDHHmmss, możesz wygenerować ciąg wynikowy, przekazując ciąg formatu niestandardowego do DateTime.ToString(String) metody , a następnie przekonwertować ciąg wynikowy z powrotem na wartość, wywołując DateTime.ParseExact metodę DateTime .

Zmienianie wzorca daty krótkiej

Poniższy przykład zmienia format ciągu wynikowego wygenerowanego przez ciąg formatu "d" (data krótka). Zmienia skojarzona ShortDatePattern właściwość dla kultury en-US lub English (Stany Zjednoczone) z wartości domyślnej "M/d/yyyy" na "yyyy'-"MM"-"dd" i używa standardowego ciągu formatu "d", aby wyświetlić datę zarówno przed, jak i po ShortDatePattern zmianie właściwości.

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 daty

Poniższy przykład zmienia znak separatora dat w DateTimeFormatInfo obiekcie, który reprezentuje konwencje formatowania kultury fr-FR. W przykładzie użyto standardowego ciągu formatu "g", aby wyświetlić datę zarówno przed, jak i po DateSeparator zmianie właściwości.

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: 28/08/2013 00:00
//       After modifying the DateSeparator property: 28-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ługiej

W niektórych przypadkach wzorzec daty długiej, który zazwyczaj wyświetla pełną nazwę dnia i miesiąca wraz z liczbą dni miesiąca i roku, może być zbyt długi. Poniższy przykład skraca wzorzec daty długiej dla kultury en-US, aby zwrócić jednoznaczny lub dwuznaczny skrót nazwy dnia, po którym następuje numer dnia, skrót nazwy miesiąca i rok. Robi to, przypisując krótsze skróty nazw dni do AbbreviatedDayNames tablicy i modyfikując niestandardowy ciąg formatu przypisany do LongDatePattern właściwości. Ma to wpływ na ciągi wynikowe zwracane przez ciągi formatu "D" i "f".

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 9, 2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tuesday, July 9, 2013 12:00 AM
//
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 9, 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 9, 2013
'       F: Tuesday, July 9, 2013 12:00:00 AM
'       f: Tuesday, July 9, 2013 12:00 AM
'
'       D: Tu 09-Jul-2013
'       F: Tuesday, July 9, 2013 12:00:00 AM
'       f: Tu 09-Jul-2013 12:00 AM

Zwykle zmiana LongDatePattern właściwości wpływa również na FullDateTimePattern właściwość, która z kolei definiuje ciąg wynikowy zwracany przez ciąg formatu standardowego "F". Aby zachować oryginalny wzorzec pełnej daty i godziny, przykład ponownie przypisuje oryginalny ciąg formatu niestandardowego przypisany do FullDateTimePattern właściwości po LongDatePattern zmodyfikowaniu właściwości.

Zmiana z 12-godzinnego zegara na 24-godzinny

W przypadku wielu kultur w .NET Framework czas jest wyrażany za pomocą zegara 12-godzinnego i projektowania AM/PM. W poniższym przykładzie zdefiniowano metodę ReplaceWith24HourClock , która zastępuje dowolny format czasu, który używa zegara 12-godzinnego w formacie, który używa zegara 24-godzinnego.

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 użyto wyrażenia regularnego do zmodyfikowania ciągu formatu. Wzorzec @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) wyrażenia regularnego jest definiowany w następujący sposób:

Wzorce Opis
^ Rozpocznij dopasowanie na początku ciągu.
(?<openAMPM>\s*t+\s*)? Dopasuj zero lub jedno wystąpienie zera lub więcej znaków odstępu, po którym następuje litera "t" co najmniej raz, po której następuje zero lub więcej znaków odstępu. Ta grupa przechwytywania nosi nazwę openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ openAMPM Jeśli grupa ma dopasowanie, dopasuj literę "h" co najmniej raz, po której następuje jeden lub więcej znaków, które nie są ani "h", ani "t". Dopasowanie kończy się na końcu ciągu. Wszystkie znaki przechwycone po znaku "h" są uwzględniane w grupie przechwytywania o nazwie nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) openAMPM Jeśli grupa nie ma dopasowania, dopasuj literę "h" co najmniej raz, po której następuje 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 odstępu. Na koniec dopasuj co najmniej jedno wystąpienie litery "t". Wszystkie znaki przechwycone po znaku "h" i przed białymi spacjami i "t" są uwzględniane w grupie przechwytywania o nazwie nonHours.

Grupa przechwytywania nonHours zawiera minutę i prawdopodobnie drugi składnik niestandardowego ciągu formatu daty i godziny wraz z dowolnymi symbolami separatora czasu. Wzorzec HH${nonHours} zastępowania poprzedza podciąg "HH" do tych elementów.

Wyświetlanie i zmienianie ery w dacie

W poniższym przykładzie specyfikator formatu niestandardowego "g" jest dodawany do LongDatePattern właściwości obiektu reprezentującego konwencje formatowania kultury en-US. Ten dodatek ma wpływ na następujące trzy standardowe ciągi formatu:

  • Standardowy ciąg formatu "D" (data długa), który jest mapowy bezpośrednio na LongDatePattern właściwość .

  • Standardowy ciąg formatu "f" (pełna data/krótki czas), który generuje ciąg wynikowy, który łączy podciągów utworzonych przez LongDatePattern właściwości i ShortTimePattern .

  • Standardowy ciąg formatu "F" (pełna data/godzina długa), który jest mapowy bezpośrednio na FullDateTimePattern właściwość. Ponieważ ta wartość właściwości nie została jawnie ustawiona, jest generowana dynamicznie przez łączenie LongDatePattern właściwości i LongTimePattern .

W przykładzie pokazano również, jak zmienić nazwę ery dla kultury, której kalendarz ma jedną erę. W tym przypadku kultura en-US używa kalendarza gregoriańskiego, który jest reprezentowany GregorianCalendar przez obiekt. Klasa GregorianCalendar obsługuje jedną erę, którą nazywa A.D. (Anno Domini). Przykład zmienia nazwę ery na C.E. (Common Era) przez zastąpienie specyfikatora formatu niestandardowego "g" w ciągu formatu przypisanym do FullDateTimePattern właściwości ciągiem literału. Użycie ciągu literału jest konieczne, ponieważ nazwa ery jest zwykle zwracana przez GetEraName metodę z prywatnych danych w tabelach kultury dostarczonych przez .NET Framework lub system operacyjny Windows.

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 godziny

Analizowanie obejmuje konwertowanie ciągu reprezentującego datę i godzinę na DateTime wartość lub DateTimeOffset . Oba te typy obejmują Parsemetody , TryParse, ParseExacti TryParseExact do obsługi operacji analizowania. Metody Parse i TryParse konwertują ciąg, który może mieć różne formaty, natomiast ParseExact TryParseExact i wymagają, aby ciąg miał zdefiniowany format lub format. Jeśli operacja analizowania zakończy się niepowodzeniem Parse i ParseExact zgłosi wyjątek, a następnie TryParse TryParseExact zwróci wartość false.

Metody analizowania niejawnie lub jawnie używają DateTimeStyles wartości wyliczenia, aby określić, które elementy stylu (takie jak wiodące, końcowe lub wewnętrzne białe znaki) mogą być obecne w ciągu do przeanalizowania i jak interpretować przeanalizowany ciąg lub wszelkie brakujące elementy. Jeśli nie podasz DateTimeStyles wartości podczas wywoływania Parse metody lub TryParse , wartość domyślna to DateTimeStyles.AllowWhiteSpaces, czyli styl złożony zawierający DateTimeStyles.AllowLeadingWhiteflagi , DateTimeStyles.AllowTrailingWhitei DateTimeStyles.AllowInnerWhite . ParseExact W przypadku metod i TryParseExact wartość domyślna to DateTimeStyles.None; ciąg wejściowy musi odpowiadać dokładnie określonemu niestandardowemu ciągowi formatu daty i godziny.

Metody analizowania również niejawnie lub jawnie używają DateTimeFormatInfo obiektu, który definiuje określone symbole i wzorce, które mogą wystąpić w ciągu do przeanalizowania. Jeśli nie podasz DateTimeFormatInfo obiektu, DateTimeFormatInfo obiekt dla bieżącej kultury jest używany domyślnie. Aby uzyskać więcej informacji na temat analizowania ciągów daty i godziny, zobacz poszczególne metody analizowania, takie jak DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExacti DateTimeOffset.TryParseExact.

Poniższy przykład ilustruje wrażliwy na kulturę charakter analizowania ciągów daty i godziny. Próbuje przeanalizować dwa ciągi dat przy użyciu konwencji en-US, en-GB, fr-FR i fi-FI kultur. Data interpretowana jako 18.08.2014 w kulturze en-US zgłasza FormatException wyjątek w pozostałych trzech kulturach, ponieważ 18 jest interpretowane jako numer miesiąca. 1/2/2015 jest analizowany jako drugi dzień pierwszego miesiąca w kulturze en-US, ale jako pierwszy dzień drugiego miesiąca w pozostałych kulturach.

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:

  • Aby przekonwertować dane wejściowe użytkownika na wartość daty i godziny.

  • Aby zaokrąglić wartość daty i godziny; oznacza to, aby deserializować wartość daty i godziny, która została wcześniej serializowana jako ciąg.

W poniższych sekcjach omówiono te dwie operacje bardziej szczegółowo.

Analiza ciągów użytkownika

Podczas analizowania ciągów daty i godziny wejściowych przez użytkownika zawsze należy utworzyć DateTimeFormatInfo wystąpienie obiektu, który odzwierciedla ustawienia kulturowe użytkownika, w tym wszelkie dostosowania wprowadzone przez użytkownika. W przeciwnym razie obiekt daty i godziny może mieć nieprawidłowe wartości. Aby uzyskać informacje na temat tworzenia wystąpienia DateTimeFormatInfo obiektu, który odzwierciedla dostosowania kulturowe użytkownika, zobacz sekcję DateTimeFormatInfo i dane dynamiczne .

Poniższy przykład ilustruje różnicę między operacją analizowania, która odzwierciedla ustawienia kulturowe użytkownika, a taką, która nie. W tym przypadku domyślna kultura systemu to en-US, ale użytkownik użył Panel sterowania, Region i Język, aby zmienić wzorzec daty krótkiej z domyślnej wartości "M/d/rryy" na "yyy/MM/dd". Gdy użytkownik wprowadzi ciąg, który odzwierciedla ustawienia użytkownika, a ciąg jest analizowany przez DateTimeFormatInfo obiekt, który odzwierciedla również ustawienia użytkownika (przesłonięcia), operacja analizowania zwraca prawidłowy wynik. Jednak gdy ciąg jest analizowany przez DateTimeFormatInfo obiekt, który odzwierciedla standardowe ustawienia kulturowe en-US, metoda analizowania zgłasza wyjątek, ponieważ interpretuje FormatException 14 jako liczbę miesięcy, a nie ostatnie dwie cyfry roku.

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 godziny

Oczekuje się serializacji danych daty i godziny w obie strony; oznacza to, że wszystkie serializowane i deserializowane wartości powinny być identyczne. Jeśli wartość daty i godziny reprezentuje jeden moment w czasie, wartość deserializacji powinna reprezentować ten sam moment w czasie niezależnie od kultury lub strefy czasowej systemu, na którym został przywrócony. Aby dane daty i godziny rundy zostały pomyślnie wykonane, należy użyć konwencji niezmiennej kultury, która jest zwracana przez InvariantInfo właściwość, aby wygenerować i przeanalizować dane. Operacje formatowania i analizowania nigdy nie powinny odzwierciedlać konwencji kultury domyślnej. Jeśli używasz domyślnych ustawień kulturowych, przenośność danych jest ściśle ograniczona; Można go pomyślnie deserializować tylko w wątku, którego ustawienia specyficzne dla kultury są identyczne z ustawieniami wątku, na którym został serializowany. W niektórych przypadkach oznacza to, że dane nie mogą być nawet pomyślnie serializowane i deserializowane w tym samym systemie.

Jeśli składnik godziny wartości daty i godziny jest znaczący, należy go również przekonwertować na czas UTC i serializować przy użyciu standardowego ciągu formatu "o" lub "r". 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 .

Poniższy przykład ilustruje proces zaokrąglania wartości daty i godziny. Serializuje datę i godzinę w systemie, który obserwuje czas pacyficzny USA i którego obecna kultura jest 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)

Deserializuje dane dotyczące systemu w Brukseli, Kopenhadze, Madrycie i Paryżu strefy czasowej oraz których obecna kultura jest fr-FR. Przywrócona data wynosi dziewięć godzin później niż oryginalna data, która odzwierciedla korektę strefy czasowej z ośmiu godzin od UTC do jednej godziny przed utc. Zarówno oryginalna data, jak i przywrócona data reprezentują ten sam moment w czasie.

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 DateTimeFormatInfo nowe zapisywalne wystąpienie klasy niezależnej od kultury (niezmienne).

Właściwości

AbbreviatedDayNames

Pobiera lub ustawia jednowymiarową tablicę typu String zawierającą skrócone nazwy dni tygodnia specyficzne dla kultury.

AbbreviatedMonthGenitiveNames

Pobiera lub ustawia tablicę ciągów skróconych nazw miesięcy skojarzonych z bieżącym DateTimeFormatInfo obiektem.

AbbreviatedMonthNames

Pobiera lub ustawia jednowymiarową tablicę ciągów zawierającą skrócone nazwy miesięcy specyficzne dla kultury.

AMDesignator

Pobiera lub ustawia zaprojektator ciągów przez godziny, które są "ante meridiem" (przed południem).

Calendar

Pobiera lub ustawia kalendarz do użycia dla bieżącej kultury.

CalendarWeekRule

Pobiera lub ustawia wartość określającą, która reguła jest używana do określenia pierwszego tygodnia kalendarzowego roku.

CurrentInfo

Pobiera obiekt tylko do DateTimeFormatInfo odczytu, który formatuje wartości na podstawie bieżącej kultury.

DateSeparator

Pobiera lub ustawia ciąg, który oddziela składniki daty, czyli rok, miesiąc i dzień.

DayNames

Pobiera lub ustawia jednowymiarową tablicę ciągów zawierającą pełne nazwy dni tygodnia specyficzne dla kultury.

FirstDayOfWeek

Pobiera lub ustawia pierwszy dzień tygodnia.

FullDateTimePattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości daty długiej i długiej.

InvariantInfo

Pobiera domyślny obiekt tylko do DateTimeFormatInfo odczytu, który jest niezależny od kultury (niezmienny).

IsReadOnly

Pobiera wartość wskazującą, czy DateTimeFormatInfo obiekt jest tylko do odczytu.

LongDatePattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości daty długiej.

LongTimePattern

Pobiera lub ustawia ciąg formatu niestandardowego przez długi czas.

MonthDayPattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości miesiąca i dnia.

MonthGenitiveNames

Pobiera lub ustawia tablicę ciągów nazw miesięcy skojarzonych z bieżącym DateTimeFormatInfo obiektem.

MonthNames

Pobiera lub ustawia jednowymiarową tablicę typu String zawierającą pełne nazwy miesięcy specyficzne dla kultury.

NativeCalendarName

Pobiera natywną nazwę kalendarza skojarzonego z bieżącym DateTimeFormatInfo obiektem.

PMDesignator

Pobiera lub ustawia projektator ciągów przez godziny, które są "post meridiem" (po południu).

RFC1123Pattern

Pobiera niestandardowy ciąg formatu dla wartości czasu opartej na specyfikacji Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123.

ShortDatePattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości daty krótkiej.

ShortestDayNames

Pobiera lub ustawia tablicę ciągów najkrótszych unikatowych skróconych nazw dni skojarzonych z bieżącym DateTimeFormatInfo obiektem.

ShortTimePattern

Pobiera lub ustawia niestandardowy ciąg formatu na krótką wartość czasu.

SortableDateTimePattern

Pobiera niestandardowy ciąg formatu dla wartości daty i godziny sortowania.

TimeSeparator

Pobiera lub ustawia ciąg, który oddziela składniki czasu, czyli godzinę, minuty i sekundy.

UniversalSortableDateTimePattern

Pobiera ciąg formatu niestandardowego dla uniwersalnego, sortowalnego ciągu daty i godziny zgodnie z definicją iso 8601.

YearMonthPattern

Pobiera lub ustawia niestandardowy ciąg formatu dla wartości roku i miesiąca.

Metody

Clone()

Tworzy płytkią kopię obiektu DateTimeFormatInfo.

Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.

(Odziedziczone po Object)
GetAbbreviatedDayName(DayOfWeek)

Zwraca nazwę specyficzną dla kultury skróconą nazwę określonego dnia tygodnia na podstawie kultury skojarzonej z bieżącym DateTimeFormatInfo obiektem.

GetAbbreviatedEraName(Int32)

Zwraca ciąg zawierający skróconą nazwę określonej ery, jeśli istnieje skrót.

GetAbbreviatedMonthName(Int32)

Zwraca nazwę specyficzną dla kultury skróconą nazwę określonego miesiąca na podstawie kultury skojarzonej z bieżącym DateTimeFormatInfo obiektem.

GetAllDateTimePatterns()

Zwraca wszystkie standardowe wzorce, w których można sformatować wartości daty i godziny.

GetAllDateTimePatterns(Char)

Zwraca wszystkie wzorce, w których można sformatować wartości daty i godziny przy użyciu określonego standardowego ciągu formatu.

GetDayName(DayOfWeek)

Zwraca pełną nazwę określonej kultury określonego dnia tygodnia na podstawie kultury skojarzonej z bieżącym DateTimeFormatInfo obiektem.

GetEra(String)

Zwraca liczbę całkowitą reprezentującą określoną erę.

GetEraName(Int32)

Zwraca ciąg zawierający nazwę określonej ery.

GetFormat(Type)

Zwraca obiekt określonego typu, który udostępnia usługę formatowania daty i godziny.

GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetInstance(IFormatProvider)

DateTimeFormatInfo Zwraca obiekt skojarzony z określonym IFormatProviderelementem .

GetMonthName(Int32)

Zwraca pełną nazwę określonej kultury określonego miesiąca na podstawie kultury skojarzonej z bieżącym DateTimeFormatInfo obiektem.

GetShortestDayName(DayOfWeek)

Uzyskuje najkrótszą skróconą nazwę dnia dla określonego dnia tygodnia skojarzonego z bieżącym DateTimeFormatInfo obiektem.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
ReadOnly(DateTimeFormatInfo)

Zwraca otokę tylko do DateTimeFormatInfo odczytu.

SetAllDateTimePatterns(String[], Char)

Ustawia niestandardowe ciągi formatu daty i godziny odpowiadające określonym ciągom formatu standardowego.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)

Jawne implementacje interfejsu

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Wypełnia element SerializationInfo danymi wymaganymi do serializacji obiektu docelowego.

Dotyczy

Zobacz też