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 包含特定于区域性的信息,用于设置或分析日期和时间值,如下所示:

  • 用于格式化日期值的模式。

  • 用于格式化时间值的模式。

  • 一周中各天的名称。

  • 年中的月份的名称。

  • 上午 和 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.Parent ,并检索 DateTimeFormatInfo 其属性返回的对象 CultureInfo.DateTimeFormat 。 除非父区域性表示固定区域性,否则返回的 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 异常。

但是,非特定区域性缺少区域性特定的格式设置信息,因为它与特定的国家/地区无关。 DateTimeFormatInfo.NET Framework 返回一个 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 通过 "控制面板" 的 "区域和语言" 应用程序覆盖用于格式化和分析操作的某些属性值。 例如,如果用户的区域性为英语 (美国) 可能会选择使用24小时制 (以 HH: mm: ss 格式显示长时间值,而不是采用格式 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 。 不应对 DateTimeFormatInfo 与特定对象关联的对象的值的稳定性做出任何假设 CultureInfo 。 只有固定区域性提供的数据及其关联的对象才 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 使用表示当前区域性的属性返回的对象。

下面的示例演示了 IFormatProvider DateTimeFormatInfo 在格式设置操作中接口和类之间的关系。 它定义了一个自定义实现,该 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" (month/day;标准格式字符串) 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" (自定义格式说明) MonthNamesMonthGenitiveNames ,以在结果字符串中包括完整的月份名称。
"t" (自定义格式说明) AMDesignatorPMDesignator或 ,以在结果字符串中包括 AM/PM 表示符的第一个字符。
"tt" (自定义格式说明) AMDesignatorPMDesignator ,以在结果字符串中包括完整的 AM/PM 表示符。
":" (自定义格式说明) TimeSeparator,以在结果字符串中包括时间分隔符。
"/" (自定义格式说明) DateSeparator,以在结果字符串中包括日期分隔符。

修改 DateTimeFormatInfo 属性

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

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

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

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

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

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

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

更改短日期模式

以下示例使用标准格式字符串更改"d" (生成) 字符串的格式。 它将 en-US 或英语 (美国) 区域性的关联属性从默认值 ShortDatePattern "M/d/yyyy"更改为"yyyyy'-"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"标准格式字符串返回的结果字符串。 为了保留原始的完整日期和时间模式,该示例在修改 属性后重新分配分配给 属性 FullDateTimePattern LongDatePattern 的原始自定义格式字符串。

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

对于 .NET Framework 中的许多区域性,使用 12 小时制和 AM/PM 表示符来表示时间。 下面的示例定义了一个 方法,该方法将使用 12 小时制的任何时间格式替换为使用 ReplaceWith24HourClock 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]+)$ 如果组具有匹配项,则匹配字母"h"一次或多次,后跟一个或多个既不是 openAMPM "h"也不是"t"的字符。 匹配在字符串的末尾结束。 在"h"之后捕获的所有字符都包含在名为 的捕获组中 nonHours
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) 如果组没有匹配项,请匹配字母"h"一次或多次,后跟一个或多个既不是 openAMPM "h"也不是"t"的字符,后跟零个或多个空白字符。 最后,匹配字母"t"的一个或多个匹配项。 在"h"之后以及空格和"t"之前捕获的所有字符都包含在名为 的捕获组中 nonHours

捕获组包含自定义日期和时间格式字符串的分钟(可能为第二个分量) nonHours 以及任何时间分隔符符号。 替换模式 HH${nonHours} 将子字符串"HH"预置到这些元素。

显示和更改日期中的纪元

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

该示例还演示如何更改日历为单个纪元的区域性的纪元名称。 在这种情况下,en-US 区域性使用公历,该日历由 对象 GregorianCalendar 表示。 类 GregorianCalendar 支持一个纪元,它的名称为 A.D。 (Anno Domini) 。 该示例将纪元名称更改为 C.E。 (Common Era) ,将分配给 属性的格式字符串中的"g"自定义格式说明器 FullDateTimePattern 替换为文本字符串。 使用文本字符串是必需的,因为纪元名称通常由 方法从 .NET Framework 或 Windows 操作系统提供的区域性表中的私有数据 GetEraName 返回。

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 ParseExact TryParseExact 方法来支持分析操作。 和 方法转换可以具有各种格式的字符串,而 和 要求 Parse TryParse ParseExact TryParseExact 该字符串具有定义的格式或格式。 如果分析操作失败,并 Parse ParseExact 引发异常,则 和 TryParse TryParseExact 返回 false

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

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

下面的示例说明了分析日期和时间字符串的区分区域性的性质。 它尝试使用 en-US、en-GB、fr-FR 和 fi-FI 区域性的约定分析两个日期字符串。 在 en-US 区域性中解释为 8/18/2014 的日期在其他三个区域性中引发异常,因为 18 被解释为 FormatException 月份号。 2015/1/2 分析为 en-US 区域性中第一个月的第二天,但在其余区域性中则分析为第二个月的第一天。

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,但用户已使用 控制面板、Region 和 Language 将短日期模式从默认值"M/d/yyyy"更改为"yy/MM/dd"。 当用户输入反映用户设置的字符串,并且该字符串由同时反映用户设置的对象分析 (重写) ,分析操作将返回 DateTimeFormatInfo 正确的结果。 但是,当字符串由反映标准 en-US 文化设置的对象分析时,分析方法会引发异常,因为它将 DateTimeFormatInfo 14 解释为月数,而不是一年的最后两 FormatException 位数字。

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 和分析数据。 格式设置和分析操作不应反映默认区域性的约定。 如果使用默认文化设置,则数据的可移植性受到严格限制;它只能在其特定于文化的设置与序列化它的线程的设置相同的线程上成功反序列化。 在某些情况下,这意味着数据甚至无法在同一系统上成功序列化和反序列化。

如果日期和时间值的时间部分重要,则还应将其转换为 UTC,然后使用"o"或"r"标准格式字符串 进行序列化。 然后,可以通过调用分析方法并传递适当的格式字符串以及固定区域性作为参数来还原 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。

适用于

另请参阅