DateTimeFormatInfo 类

定义

提供有关日期和时间值格式的区域性特定信息。

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
继承
DateTimeFormatInfo
属性
实现

示例

以下示例使用反射获取英语 (美国) 区域性的对象的属性DateTimeFormatInfo。 它显示包含自定义格式字符串并使用这些字符串显示格式化日期的属性的值。

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

注解

类的属性 DateTimeFormatInfo 包含用于格式化或分析日期和时间值的区域性特定的信息,例如:

  • 用于设置日期值格式的模式。

  • 用于设置时间值的格式的模式。

  • 星期几的名称。

  • 年份月份的名称。

  • The A.M. 和 P.M. 时间值中使用的指定符。

  • 表示日期的日历。

本部分内容:

实例化 DateTimeFormatInfo 对象

对象 DateTimeFormatInfo 可以表示固定区域性、特定区域性、中性区域性或当前区域性的格式约定。 本部分讨论如何实例化每种类型的 DateTimeFormatInfo 对象。

实例化固定区域性的 DateTimeFormatInfo 对象

固定区域性表示不区分区域性的文化。 它基于英语,但不基于任何特定的英语国家/地区。 虽然特定区域性的数据可以是动态的,可以更改以反映新的文化约定或用户首选项,但固定区域性的数据不会更改。 可以通过以下方式实例化表示 DateTimeFormatInfo 固定区域性的格式约定的对象:

以下示例使用上述每个方法实例化 DateTimeFormatInfo 表示固定区域性的对象。 然后,它指示对象是否为只读。

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

实例化特定区域性的 DateTimeFormatInfo 对象

特定区域性表示在特定国家/地区说的语言。 例如,en-US 是表示美国中说英语的特定区域性,en-CA 是表示加拿大英语的特定区域性。 可以通过以下方式实例化表示 DateTimeFormatInfo 特定区域性的格式约定的对象:

以下示例说明了实例化 DateTimeFormatInfo 对象的每个方法,并指示生成的对象是否为只读。

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

实例化非特定区域性的 DateTimeFormatInfo 对象

中性区域性表示独立于国家/地区的区域性或语言;它通常是一个或多个特定区域性的父级。 例如,Fr 是法语和 fr-FR 区域性的父区域性的中性文化。 可以实例化表示 DateTimeFormatInfo 中性区域性的格式约定的对象,其方式与创建 DateTimeFormatInfo 表示特定区域性的格式约定的对象相同。 此外,可以通过从特定区域性DateTimeFormatInfo的属性检索中性区域性并检索其CultureInfo.DateTimeFormat属性返回的对象来检索DateTimeFormatInfo中性区域性CultureInfo.Parent的对象。 除非父区域性表示固定区域性,否则返回 DateTimeFormatInfo 的对象是可读/写的。 下面的示例演示了实例化 DateTimeFormatInfo 表示中性区域性的对象的方法。

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

备注

在.NET Framework版本 1.0 到 .NET Framework 3.5 中,尝试检索DateTimeFormatInfo反映中性区域性的格式约定的对象会NotSupportedException引发异常。

但是,中性文化缺乏特定于区域性的格式信息,因为它独立于特定国家/地区。 .NET Framework不用泛型值填充DateTimeFormatInfo对象,而是返回一个DateTimeFormatInfo对象,该对象反映特定区域性的格式设置约定,该约定是中性区域性的子区域性。 例如, DateTimeFormatInfo 中性 en 区域性的对象反映了 en-US 区域性的格式约定, DateTimeFormatInfo fr 区域性的对象反映了 fr-FR 区域性的格式约定。

可以使用如下所示的代码来确定特定区域性的格式设置约定中性区域性所代表的格式约定。 该示例使用反射将中性区域性的属性与特定子区域性的属性进行比较 DateTimeFormatInfo 。 如果两个日历是相同的日历类型,则认为两个日历是等效的,如果它们的属性具有相同的值,则 GregorianCalendar.CalendarType 为公历日历。

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

实例化当前区域性的 DateTimeFormatInfo 对象

可以通过以下方式实例化表示 DateTimeFormatInfo 当前区域性的格式约定的对象:

以下示例使用上述每个方法实例化 DateTimeFormatInfo 表示当前区域性的格式约定的对象。 然后,它指示对象是否为只读。

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

可以创建一个可 DateTimeFormatInfo 写对象,该对象以下列方式之一表示当前区域性的约定:

下面的示例演示了实例化读/写 DateTimeFormatInfo 对象的每种方法,并显示其 IsReadOnly 属性的值。

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

在Windows中,用户可以通过控制面板的区域 和语言 应用程序替代用于设置格式和分析操作的一些DateTimeFormatInfo属性值。 例如,区域性为英语 (美国) 的用户可以选择使用采用 HH:mm:ss) 格式的 24 小时制 (显示长时间值,而不是采用 h:mm:ss tt) 格式的默认 12 小时制 (。 DateTimeFormatInfo以前面讨论的方式检索的对象都反映了这些用户替代。 如果这是不可取的,则可以创建一个NumberFormatInfo对象,该对象不反映用户重写 (,并且通过调用CultureInfo.CultureInfo(String, Boolean)构造函数并提供参数的值false``useUserOverride来读取/写入,而不是只读) 。 以下示例演示了当前区域性为英语 (美国) 且长时间模式已从 h:mm:ss tt 的默认值更改为 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 和动态数据

用于设置类提供的 DateTimeFormatInfo 日期和时间值的区域性特定数据是动态的,就像类提供的文化数据一 CultureInfo 样。 不应对与特定CultureInfo对象关联的对象的值的DateTimeFormatInfo稳定性做出任何假设。 只有固定区域性提供的数据及其关联的 DateTimeFormatInfo 对象是稳定的。 其他数据可以在应用程序会话之间或在应用程序运行时发生更改。 有四个主要的更改来源:

  • 系统更新。 文化首选项,如首选日历或习惯日期和时间格式随时间变化。 发生这种情况时,Windows 更新包括对特定区域性的DateTimeFormatInfo属性值的更改。

  • 替换区域性。 该 CultureAndRegionInfoBuilder 类可用于替换现有区域性的数据。

  • 对属性值进行级联更改。 许多与区域性相关的属性可以在运行时更改,这反过来又会导致 DateTimeFormatInfo 数据发生更改。 例如,可以通过编程方式或通过用户操作更改当前区域性。 发生这种情况时, DateTimeFormatInfo 属性返回 CurrentInfo 的对象将更改为与当前区域性关联的对象。 同样,区域性的日历可能会更改,这可能会导致大量 DateTimeFormatInfo 属性值发生更改。

  • 用户首选项。 应用程序的用户可能会选择通过控制面板中的区域和语言选项替代与当前系统区域性关联的某些值。 例如,用户可以选择以不同的格式显示日期。 CultureInfo.UseUserOverride如果该属性设置为 true,则对象的属性DateTimeFormatInfo也会从用户设置中检索。 例如,如果用户设置与 (对象关联的 CultureInfo 区域性不兼容,例如,如果所选日历不是属性) 指示 OptionalCalendars 的日历之一,则方法的结果和属性的值是未定义的。

为了最大程度地减少数据不一致的可能性,创建对象时会初始化对象的所有用户可重写属性 DateTimeFormatInfo 。 仍然存在不一致的可能性,因为对象创建和用户替代过程都不是原子的,相关值在对象创建过程中可能会更改。 然而,这种情况应该极其罕见。

可以控制用户替代是否反映在 DateTimeFormatInfo 表示与系统区域性相同的区域性的对象中。 下表列出了可以检索对象的方式 DateTimeFormatInfo ,并指示生成的对象是否反映用户替代。

CultureInfo 和 DateTimeFormatInfo 对象的源 反映用户替代
CultureInfo.CurrentCulture.DateTimeFormat 属性
DateTimeFormatInfo.CurrentInfo 属性
CultureInfo.CreateSpecificCulture 方法
CultureInfo.GetCultureInfo 方法
CultureInfo.CultureInfo(String) 构造函数
CultureInfo.CultureInfo(String, Boolean) 构造函数 取决于参数的值useUserOverride

除非有令人信服的理由这样做,否则在客户端应用程序中使用对象来格式化和分析用户输入或显示数据时 DateTimeFormatInfo ,应遵循用户替代。 对于服务器应用程序或无人参与的应用程序,不应。 但是,如果使用 DateTimeFormatInfo 对象显式或隐式保存字符串形式的日期和时间数据,则应使用 DateTimeFormatInfo 反映固定区域性的格式约定的对象,或者应指定无论区域性如何使用的自定义日期和时间格式字符串。

设置日期和时间的格式

对象 DateTimeFormatInfo 在所有日期和时间格式设置操作中隐式或显式使用。 其中包括对以下方法的调用:

所有日期和时间格式设置操作都使用 IFormatProvider 实现。 接口 IFormatProvider 包含单个方法 IFormatProvider.GetFormat(Type)。 此回调方法将传递一个 Type 对象,该对象表示提供格式设置信息所需的类型。 该方法返回该类型的实例,或者 null 如果无法提供该类型的实例。 .NET Framework包括两IFormatProvider个用于设置日期和时间格式的实现:

IFormatProvider如果未显式向格式化方法提供实现,CultureInfo则使用表示当前区域性的属性返回CultureInfo.CurrentCulture的对象。

以下示例演示了接口与DateTimeFormatInfo类在格式设置操作中IFormatProvider之间的关系。 它定义一个自定义 IFormatProvider 实现,其 GetFormat 方法显示格式设置操作请求的对象的类型。 如果请求对象 DateTimeFormatInfo ,该方法将为 DateTimeFormatInfo 当前区域性提供对象。 如示例的输出所示,该方法 Decimal.ToString(IFormatProvider) 请求对象 DateTimeFormatInfo 提供格式设置信息,而 String.Format(IFormatProvider, String, Object[]) 方法请求 NumberFormatInfoDateTimeFormatInfo 对象以及 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

设置字符串和 DateTimeFormatInfo 属性的格式

DateTimeFormatInfo 对象包含三种类型的属性,这些属性用于设置日期和时间值的格式操作:

标准日期和时间格式字符串(如“d”、“D”、“f”和“F”)是对应于特定DateTimeFormatInfo格式模式属性的别名。 大多数 自定义日期和时间格式字符串 都与格式设置操作插入到结果流的字符串或子字符串相关。 下表列出了标准和自定义日期和时间格式说明符及其关联 DateTimeFormatInfo 属性。 有关如何使用这些格式说明符的详细信息,请参阅 标准日期和时间格式字符串 以及 自定义日期和时间格式字符串。 请注意,每个标准格式字符串对应于其 DateTimeFormatInfo 值为自定义日期和时间格式字符串的属性。 此自定义格式字符串中的单个说明符又对应于其他 DateTimeFormatInfo 属性。 该表仅 DateTimeFormatInfo 列出标准格式字符串是别名的属性,并且不会列出可由分配给这些别名属性的自定义格式字符串访问的属性。 此外,表仅列出对应于 DateTimeFormatInfo 属性的自定义格式说明符。

格式说明符 关联的属性
“d” (短日期;标准格式字符串) ShortDatePattern,用于定义结果字符串的整体格式。
“D” (长日期;标准格式字符串) LongDatePattern,用于定义结果字符串的整体格式。
“f” (完整日期/短时间;标准格式字符串) LongDatePattern,用于定义结果字符串的日期组件的格式。

ShortTimePattern,用于定义结果字符串的时间分量的格式。
“F” (完整日期/长时间;标准格式字符串) LongDatePattern,用于定义结果字符串的日期组件的格式。

LongTimePattern,用于定义结果字符串的时间分量的格式。
“g” (常规日期/短时间;标准格式字符串) ShortDatePattern,用于定义结果字符串的日期组件的格式。

ShortTimePattern,用于定义结果字符串的时间分量的格式。
“G” (常规日期/长时间;标准格式字符串) ShortDatePattern,用于定义结果字符串的日期组件的格式。

LongTimePattern,用于定义结果字符串的时间分量的格式。
“M”、“m” (月/天;标准格式字符串) MonthDayPattern,用于定义结果字符串的整体格式。
“O”、“o” (往返日期/时间;标准格式字符串) 无。
“R”、“r” (RFC1123;标准格式字符串) RFC1123Pattern,用于定义符合 RFC 1123 标准的结果字符串。 属性为只读属性。
“s” (可排序日期/时间;标准格式字符串) SortableDateTimePattern,用于定义符合 ISO 8601 标准的结果字符串。 属性为只读属性。
“t” (短时间;标准格式字符串) ShortTimePattern,用于定义结果字符串的整体格式。
“T” (较长时间;标准格式字符串) LongTimePattern,用于定义结果字符串的整体格式。
“u” (通用可排序日期/时间;标准格式字符串) UniversalSortableDateTimePattern,用于定义符合 ISO 8601 标准的结果字符串,以便协调世界时。 属性为只读属性。
“U” (通用完整日期/时间;标准格式字符串) FullDateTimePattern,用于定义结果字符串的整体格式。
“Y”、“y” (年月:标准格式字符串) YearMonthPattern,用于定义结果字符串的整体格式。
“ddd” (自定义格式说明符) AbbreviatedDayNames,以在结果字符串中包含星期几的缩写名称。
“g”、“gg” (自定义格式说明符) GetEraName调用该方法以在结果字符串中插入纪元名称。
“MMM” (自定义格式说明符) AbbreviatedMonthNames,以在结果字符串中包含缩写的月份名称。
“MMMM” (自定义格式说明符) MonthNames 或者 MonthGenitiveNames,在结果字符串中包含完整月份名称。
“t” (自定义格式说明符) AMDesignator 或者 PMDesignator,在结果字符串中包含 AM/PM 指示符的第一个字符。
“tt” (自定义格式说明符) AMDesignator 或者 PMDesignator,在结果字符串中包含完整的 AM/PM 指示符。
“:” (自定义格式说明符) TimeSeparator,以在结果字符串中包含时间分隔符。
“/” (自定义格式说明符) DateSeparator,以在结果字符串中包含日期分隔符。

修改 DateTimeFormatInfo 属性

可以通过修改可 DateTimeFormatInfo 写对象的关联属性来更改日期和时间格式字符串生成的结果字符串。 若要确定对象是否 DateTimeFormatInfo 可写,请使用该 IsReadOnly 属性。 以这种方式自定义 DateTimeFormatInfo 对象:

  1. 创建要修改其格式约定的对象读/写副本 DateTimeFormatInfo 。 (请参阅 实例化 DateTimeFormatInfo 对象 部分.)

  2. 修改用于生成所需结果字符串的属性或属性。 (有关如何使用 DateTimeFormatInfo 属性来定义结果字符串的格式设置方法的信息,请参阅上一部分: 设置字符串格式和 DateTimeFormatInfo 属性。)

  3. 使用在调用格式设置方法时创建的自定义 DateTimeFormatInfo 对象作为 IFormatProvider 参数。

还有两种方法可以更改结果字符串的格式:

  • 可以使用 CultureAndRegionInfoBuilder 该类来定义具有唯一名称的区域性 (具有唯一名称的区域性,并补充现有区域性) 或替换区域性 (使用区域性而不是特定区域性) 。 你可以以编程方式保存和访问此区域性,就像.NET Framework支持的任何CultureInfo对象一样。

  • 如果结果字符串不区分区域性且不遵循预定义格式,则可以使用自定义日期和时间格式字符串。 例如,如果要序列化格式为 YYYYMMDDHMMss 的日期和时间数据,可以通过将自定义格式字符串传递给方法来生成结果字符串,并且可以通过调用DateTime.ParseExact该方法将结果字符串DateTime.ToString(String)转换回值DateTime

更改短日期模式

以下示例更改由“d” (短日期) 标准格式字符串生成的结果字符串的格式。 它将 en-US 或英语 (美国) 区域性的关联ShortDatePattern属性从默认的“M/d/yyyy”更改为“yyy'-”MM“-”dd“,并使用”d“标准格式字符串在更改属性前后ShortDatePattern显示日期。

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

更改日期分隔符

以下示例更改表示 fr-FR 区域性的格式设置约定的对象中的 DateTimeFormatInfo 日期分隔符。 该示例使用“g”标准格式字符串在更改属性前后 DateSeparator 显示日期。

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

更改日期名称缩写和长日期模式

在某些情况下,长日期模式(通常显示全天和月份名称以及月份和年份的天数)可能太长。 以下示例缩短 en-US 区域性的长日期模式,以返回一个字符或两个字符的日期名称缩写,后跟日号、月份名称缩写和年份。 它通过向数组分配较短的日名称缩写 AbbreviatedDayNames ,以及修改分配给 LongDatePattern 该属性的自定义格式字符串来执行此操作。 这会影响“D”和“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

通常,对属性的更改 LongDatePattern 也会影响 FullDateTimePattern 属性,而该属性又定义了“F”标准格式字符串返回的结果字符串。 为了保留原始完整日期和时间模式,该示例在修改属性后LongDatePattern重新分配分配给FullDateTimePattern属性的原始自定义格式字符串。

从 12 小时制更改为 24 小时制

对于.NET Framework中的许多区域性,时间是使用 12 小时制和 AM/PM 设计器表示的。 下面的示例定义了一个 ReplaceWith24HourClock 方法,该方法将使用 12 小时制的任何时间格式替换为使用 24 小时制的格式。

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

该示例使用正则表达式修改格式字符串。 正则表达式模式 @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) 的定义如下:

模式 描述
^ 从字符串开头开始匹配。
(?<openAMPM>\s*t+\s*)? 匹配零个或多个空格字符的零个或一个匹配项,后跟字母“t”一次或多次,后跟零个或多个空格字符。 此捕获组命名 openAMPM
(?(openAMPM) h+(?<nonHours>[^ht]+)$ openAMPM如果组具有匹配项,则匹配字母“h”一次或多次,后跟一个或多个既不是“h”又“t”的字符。 匹配项在字符串末尾结束。 在“h”之后捕获的所有字符都包含在名为 “h” 的 nonHours捕获组中。
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) openAMPM如果组没有匹配项,则匹配字母“h”一次或多次,后跟一个或多个既不是“h”又不是“t”的字符,后跟零个或多个空格字符。 最后,匹配字母“t”的一个或多个匹配项。 在“h”之后和空格和“t”之前捕获的所有字符都包含在名为“ nonHoursh”的捕获组中。

nonHours捕获组包含自定义日期和时间格式字符串的第二个组件以及任何时间分隔符符号。 替换模式 HH${nonHours} 将子字符串“HH”追加到这些元素。

显示和更改日期中的纪元

以下示例将“g”自定义格式说明符添加到 LongDatePattern 表示 en-US 区域性的格式约定的对象的属性。 此添加会影响以下三个标准格式字符串:

  • “D” (长日期) 标准格式字符串,该字符串直接映射到 LongDatePattern 属性。

  • “f” (完整日期/短时间) 标准格式字符串,这将生成连接由 LongDatePatternShortTimePattern 属性生成的子字符串的结果字符串。

  • “F” (完整日期/长时间) 标准格式字符串,该字符串直接映射到 FullDateTimePattern 属性。 由于我们尚未显式设置此属性值,因此它通过连接 LongDatePatternLongTimePattern 属性来动态生成。

该示例还演示如何更改日历具有单个纪元的文化的纪元名称。 在这种情况下,en-US 区域性使用由对象表示 GregorianCalendar 的公历。 该 GregorianCalendar 类支持一个命名为 A.D 的单个纪元。 (安妮诺·多米尼) 。 该示例将纪元名称更改为 C.E。 (Common Era) ,方法是将分配给 FullDateTimePattern 属性的格式字符串中的“g”自定义格式说明符替换为文本字符串。 必须使用文本字符串,因为 era 名称通常由GetEraName.NET Framework或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

分析日期和时间字符串

分析涉及将日期和时间的字符串表示形式转换为 DateTimeDateTimeOffset 值。 这两种类型包括用于支持分析操作的方法Parse``TryParse``ParseExactTryParseExact方法。 和Parse``TryParse方法转换可以具有多种格式的字符串,而ParseExact需要TryParseExact字符串具有定义的格式或格式。 如果分析操作失败,Parse并引发异常,而TryParse返回TryParseExact``falseParseExact

分析方法隐式或显式使用 DateTimeStyles 枚举值来确定哪些样式元素 (,如前导、尾随或内部空白) 可以存在于要分析的字符串中,以及如何解释分析的字符串或任何缺失元素。 如果在调用Parse或方法时未提供DateTimeStyles值,则默认值为DateTimeStyles.AllowWhiteSpaces,这是包含DateTimeStyles.AllowLeadingWhiteDateTimeStyles.AllowTrailingWhite标志的DateTimeStyles.AllowInnerWhite复合TryParse样式。 ParseExact对于和TryParseExact方法,默认值为DateTimeStyles.None;输入字符串必须与特定的自定义日期和时间格式字符串精确对应。

分析方法还隐式或显式使用一个 DateTimeFormatInfo 对象,该对象定义可分析的字符串中可能发生的特定符号和模式。 如果未提供 DateTimeFormatInfo 对象, DateTimeFormatInfo 则默认使用当前区域性的对象。 有关分析日期和时间字符串的详细信息,请参阅各个分析方法,例如DateTime.ParseDateTime.TryParseDateTimeOffset.ParseExactDateTimeOffset.TryParseExact

以下示例演示了分析日期和时间字符串的区域性敏感性质。 它尝试使用 en-US、en-GB、fr-FR 和 fi-FI 区域性的约定来分析两个日期字符串。 2014 年 8 月 18 日在美国区域性中解释为 8/18 的日期在其他三种区域性中引发 FormatException 异常,因为 18 被解释为月号。 2015年1月2日被分析为美国文化第一个月的第二天,但作为剩余文化的第二个月的第一天。

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

日期和时间字符串通常出于两个原因进行分析:

  • 将用户输入转换为日期和时间值。

  • 往返日期和时间值;也就是说,反序列化以前序列化为字符串的日期和时间值。

以下各节更详细地讨论了这两项操作。

分析用户字符串

分析用户输入的日期和时间字符串时,应始终实例 DateTimeFormatInfo 化反映用户的文化设置的对象,包括用户可能所做的任何自定义。 否则,日期和时间对象可能具有不正确的值。 有关如何实例化 DateTimeFormatInfo 反映用户文化自定义的对象的信息,请参阅 DateTimeFormatInfo 和动态数据 部分。

下面的示例演示了分析操作之间的差异,该操作反映用户文化设置和不区分。 在这种情况下,默认系统区域性为 en-US,但用户已使用控制面板、区域和语言 将短日期模式从默认的“M/d/yy”更改为“yy/MM/dd”。 当用户输入反映用户设置的字符串,并且该字符串由一个 DateTimeFormatInfo 对象分析,该对象也反映用户设置 (替代) 时,分析操作将返回正确的结果。 但是,当字符串由 DateTimeFormatInfo 反映标准 en-US 区域性设置的对象分析时,分析方法会引发异常 FormatException ,因为它将 14 解释为月份数,而不是年份的最后两位数。

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

序列化和反序列化日期和时间数据

序列化的日期和时间数据预计将往返;也就是说,所有序列化和反序列化的值都应相同。 如果日期和时间值表示单个时间刻,则反序列化值应表示时间中的同一时刻,而不考虑还原它的系统的区域性或时区。 若要成功往返日期和时间数据,必须使用属性返回 InvariantInfo 的固定区域性的约定来生成和分析数据。 格式设置和分析操作不应反映默认区域性的约定。 如果使用默认区域性设置,则数据可移植性严格限制:它只能在区域性特定的设置与序列化线程相同的线程上成功反序列化。 在某些情况下,这意味着数据甚至不能在同一系统上成功序列化和反序列化。

如果日期和时间值的时间组件很重要,则还应使用“o”或“r” 标准格式字符串将其转换为 UTC 并序列化。 然后,可以通过调用分析方法并向其传递适当的格式字符串以及固定区域性作为 provider 参数来还原时间数据。

以下示例演示日期和时间值的往返过程。 它在观察美国太平洋时间及其当前区域性为 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)

它将布鲁塞尔、哥本哈根、马德里和巴黎时区的系统上的数据反序列化,其当前文化为 fr-FR。 还原的日期比原始日期晚 9 小时,这反映了从 UTC 落后 8 小时到 UTC 之前的一个小时的时区调整。 原始日期和还原日期都表示相同的时间刻度。

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

构造函数

DateTimeFormatInfo()

初始化不依赖于区域性的(固定的)DateTimeFormatInfo 类的新可写实例。

属性

AbbreviatedDayNames

获取或设置 String 类型的一维数组,它包含周中各天的区域性特定的缩写名称。

AbbreviatedMonthGenitiveNames

获取或设置与当前 DateTimeFormatInfo 对象关联的月份缩写名称的字符串数组。

AbbreviatedMonthNames

获取或设置一维字符串数组,它包含各月的特定于区域性的缩写名称。

AMDesignator

获取或设置表示处于“上午”(中午前)的各小时的字符串指示符。

Calendar

获取或设置用于当前区域性的日历。

CalendarWeekRule

获取或设置一个值,该值指定使用哪个规则确定该年的第一个日历周。

CurrentInfo

获取基于当前区域性对值进行格式设置的只读的 DateTimeFormatInfo 对象。

DateSeparator

获取或设置分隔日期中各组成部分(即年、月、日)的字符串。

DayNames

获取或设置一维字符串数组,它包含该周中各天的特定于区域性的完整名称。

FirstDayOfWeek

获取或设置一周的第一天。

FullDateTimePattern

为长日期和长时间值获取或设置自定义格式字符串。

InvariantInfo

获取不依赖于区域性的(固定)默认只读的 DateTimeFormatInfo 对象。

IsReadOnly

获取一个值,该值指示 DateTimeFormatInfo 对象是否为只读。

LongDatePattern

获取或设置长日期值的自定义格式字符串。

LongTimePattern

为长时间值获取或设置自定义格式字符串。

MonthDayPattern

获取或设置月份和日期值的自定义格式字符串。

MonthGenitiveNames

获取或设置与当前 DateTimeFormatInfo 对象关联的月份名称的字符串数组。

MonthNames

获取或设置 String 类型的一维数组,它包含月份的区域性特定的全名。

NativeCalendarName

获取与当前 DateTimeFormatInfo 对象关联的本机日历名称。

PMDesignator

获取或设置表示处于“下午”(中午后)的各小时的字符串指示符。

RFC1123Pattern

获取自定义的格式字符串,该字符串用于基于 Internet 工程任务组 (IETF) 征求意见文档 (RFC) 1123 规范的时间值。

ShortDatePattern

获取或设置短日期值的自定义格式字符串。

ShortestDayNames

获取或设置与当前 DateTimeFormatInfo 对象关联的唯一最短日期缩写名称的字符串数组。

ShortTimePattern

获取或设置短时间值的自定义格式字符串。

SortableDateTimePattern

获取可排序数据和时间值的自定义格式字符串。

TimeSeparator

获取或设置分隔时间中各组成部分(即小时、分钟和秒钟)的字符串。

UniversalSortableDateTimePattern

获取 ISO 8601 定义的通用的可排序日期和时间字符串的自定义格式字符串。

YearMonthPattern

获取或设置年份和月份值的自定义格式字符串。

方法

Clone()

创建 DateTimeFormatInfo 的浅表副本。

Equals(Object)

确定指定对象是否等于当前对象。

(继承自 Object)
GetAbbreviatedDayName(DayOfWeek)

基于与当前 DateTimeFormatInfo 对象关联的区域性,返回周中指定日期的区域性特定的缩写名称。

GetAbbreviatedEraName(Int32)

返回包含指定纪元的缩写名称的字符串(如果缩写名称存在)。

GetAbbreviatedMonthName(Int32)

基于与当前 DateTimeFormatInfo 对象关联的区域性,返回指定月份的区域性特定的缩写名称。

GetAllDateTimePatterns()

返回可用于对日期和时间值进行格式设置的所有标准模式。

GetAllDateTimePatterns(Char)

返回可在其中使用指定标准格式字符串对日期和时间值进行格式设置的所有模式。

GetDayName(DayOfWeek)

基于与当前 DateTimeFormatInfo 对象关联的区域性,返回周中指定日期的区域性特定的全名。

GetEra(String)

返回表示指定纪元的整数。

GetEraName(Int32)

返回包含指定纪元名称的字符串。

GetFormat(Type)

返回指定类型的对象,它提供日期和时间格式化服务。

GetHashCode()

作为默认哈希函数。

(继承自 Object)
GetInstance(IFormatProvider)

返回与指定 IFormatProvider 关联的 DateTimeFormatInfo 对象。

GetMonthName(Int32)

基于与当前 DateTimeFormatInfo 对象关联的区域性,返回指定月份的区域性特定的全名。

GetShortestDayName(DayOfWeek)

获取与当前 DateTimeFormatInfo 对象关联的周中指定日期的最短日期缩写名称。

GetType()

获取当前实例的 Type

(继承自 Object)
MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 Object)
ReadOnly(DateTimeFormatInfo)

返回只读的 DateTimeFormatInfo 包装。

SetAllDateTimePatterns(String[], Char)

设置对应于指定的标准格式字符串的自定义日期和时间格式字符串。

ToString()

返回表示当前对象的字符串。

(继承自 Object)

显式接口实现

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

使用序列化目标对象所需的数据填充 SerializationInfo。

适用于

另请参阅