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. 與下午 時間值中使用的指定值。

  • 用來表示日期的行事曆。

本節內容:

具現化 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 代表特定文化特性之格式設定慣例的物件相同。 此外,您可以從特定 CultureInfo.Parent 文化特性的屬性擷取中性文化特性,並擷取其 CultureInfo.DateTimeFormat 屬性傳回的物件,以擷取 DateTimeFormatInfo 中性文化 DateTimeFormatInfo 特性的物件。 除非父文化特性代表不可變的文化特性,否則傳 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中,使用者可以透過 主控台 中的 Region and Language 應用程式覆寫格式化和剖析作業中使用的部分 DateTimeFormatInfo 屬性值。 例如,文化特性為英文 (美國) 的使用者可能會選擇 (使用 HH:mm:ss) 格式顯示長時間值,而不是使用 h:mm:ss tt) 格式的預設 12 小時制 (。 以 DateTimeFormatInfo 先前討論的方式擷取的物件全都反映這些使用者覆寫。 如果這是不想要的,您可以建立 NumberFormatInfo 物件,該物件不會反映使用者覆寫 (,而且也是可讀寫的,而不是透過呼叫 CultureInfo.CultureInfo(String, Boolean) 建構函式並提供 引數值的 false useUserOverride ,而不是唯讀) 。 下列範例說明目前文化特性為英文 (美國) 的系統,其長時間模式已從 h:mm:sstt 的預設值變更為 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 Update包含特定文化特性屬性值的變更 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. 使用您在呼叫格式化方法時建立為引數的 IFormatProvider 自訂 DateTimeFormatInfo 物件。

有兩種方式可以變更結果字串的格式:

  • 您可以使用 CultureAndRegionInfoBuilder 類別來定義自訂文化特性 (具有唯一名稱的文化特性,以及補充現有文化特性) 或取代文化特性 (使用的文化特性,而不是特定文化特性) 。 您可以以程式設計方式儲存和存取此文化特性,就像.NET Framework支援的任何 CultureInfo 物件一樣。

  • 如果結果字串不區分文化特性,且未遵循預先定義的格式,您可以使用自訂日期和時間格式字串。 例如,如果您要以 YYYYYMMDDHmmss 格式序列化日期和時間資料,您可以藉由將自訂格式字串傳遞至 DateTime.ToString(String) 方法來產生結果字串,而且您可以呼叫 DateTime.ParseExact 方法,將結果字串轉換回 DateTime 值。

變更簡短日期模式

下列範例會變更 「d」 (簡短日期) 標準格式字串所產生的結果字串格式。 它會將 en-US 或英文 (美國) 文化特性的相關 ShortDatePattern 屬性從預設值 「M/d/yyyy」 變更為 「yyyy'-」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

變更日期分隔符號

下列範例會變更 物件中的 DateTimeFormatInfo 日期分隔符號,此字元代表 fr-FR 文化特性的格式設定慣例。 此範例會使用 「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 定義方法,以使用 24 小時制的格式取代任何使用 12 小時制的時間格式。

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」 之後擷取的所有字元都會包含在名為 nonHours 的擷取群組中。
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) openAMPM如果群組沒有相符專案,請比對字母 「h」 一或多次,後面接著一或多個不是 「h」 或 「t」 的字元,後面接著零個或多個空白字元。 最後,比對一或多個字母 「t」。 在 「h」 和空白字元和 「t」 之前擷取的所有字元都會包含在名為 nonHours 的擷取群組中。

nonHours 取群組包含分鐘,而且可能是自訂日期和時間格式字串的第二個元件,以及任何時間分隔符號符號。 取代模式 HH${nonHours} 會將子字串 「HH」 前面加上這些元素。

顯示和變更日期中的紀元

下列範例會將 「g」 自訂格式規範新增至 LongDatePattern 代表 en-US 文化特性之格式慣例的物件 屬性。 此新增會影響下列三個標準格式字串:

  • 「D」 (完整日期) 標準格式字串,它會直接對應至 LongDatePattern 屬性。

  • 「f」 (完整日期/簡短時間) 標準格式字串,其會產生結果字串,串連 和 ShortTimePattern 屬性所產生的 LongDatePattern 子字串。

  • 「F」 (完整日期/完整時間) 標準格式字串,其會直接對應至 FullDateTimePattern 屬性。 因為我們尚未明確設定這個屬性值,所以會藉由串連 LongDatePatternLongTimePattern 屬性來動態產生。

此範例也會示範如何變更行事曆具有單一紀元的文化特性的紀元名稱。 在此情況下,en-US 文化特性會使用以 物件表示 GregorianCalendar 的西曆。 類別 GregorianCalendar 支援名為 A.D 的單一紀元。 (Anno Domini) 。 此範例會將紀元名稱變更為 C.E. (Common Era) ,將指派給 FullDateTimePattern 屬性的格式字串中的 「g」 自訂格式規範取代為常值字串。 需要使用常值字串,因為紀元名稱通常是由 方法從 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 值。 這兩種類型都包含 ParseTryParseParseExactTryParseExact 方法來支援剖析作業。 ParseTryParse 方法會轉換可具有各種格式的字串,而 ParseExactTryParseExact 要求字串具有定義的格式或格式。 如果剖析作業失敗, ParseParseExact 擲回例外狀況,而 則會 TryParseTryParseExactfalse

剖析方法會隱含或明確使用 DateTimeStyles 列舉值來判斷哪些樣式專案 (例如前置、尾端或內部空白字元,) 可以存在於要剖析的字串中,以及如何解譯剖析的字串或任何遺漏的專案。 如果您在呼叫 Parse 或 方法時未提供 DateTimeStyles 值,預設值為 DateTimeStyles.AllowWhiteSpaces ,這是包含 DateTimeStyles.AllowLeadingWhiteDateTimeStyles.AllowTrailingWhiteDateTimeStyles.AllowInnerWhite 旗標的複合 TryParse 樣式。 ParseExact針對 和 TryParseExact 方法,預設值為 DateTimeStyles.None ;輸入字串必須精確對應至特定的自訂日期和時間格式字串。

剖析方法也會隱含或明確使用 DateTimeFormatInfo 物件,該物件定義可在要剖析的字串中發生的特定符號和模式。 如果您未提供 DateTimeFormatInfo 物件, DateTimeFormatInfo 預設會使用目前文化特性的物件。 如需剖析日期和時間字串的詳細資訊,請參閱個別剖析方法,例如 DateTime.ParseDateTime.TryParseDateTimeOffset.ParseExactDateTimeOffset.TryParseExact

下列範例說明剖析日期和時間字串的文化特性。 它會嘗試使用 en-US、en-GB、fr-FR 和 fi-FI 文化特性的慣例來剖析兩個日期字串。 在 en-US 文化特性中解譯為 8/18/2014 的日期會擲回其他三個 FormatException 文化特性中的例外狀況,因為 18 會解譯為月份號碼。 1/2/2015 會剖析為 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 是由也會反映使用者設定的物件剖析, (覆寫) 時,剖析作業會傳回正確的結果。 不過,當字串是由 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。 還原的日期比原始日期晚九小時,反映從 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

取得或設定 "ante meridiem" (正午以前) 小時的字串指示項。

Calendar

取得或設定目前文化特性所使用的曆法。

CalendarWeekRule

取得或設定數值,指定要使用哪一個規則 (Rule) 來決定一年中的第一個日曆週。

CurrentInfo

取得根據目前文化特性格式化值的唯讀 DateTimeFormatInfo 物件。

DateSeparator

取得或設定分隔日期組成部分 (即年、月和日) 的字串。

DayNames

取得或設定包含特定文化特性之一週日期完整名稱的一維字串陣列。

FirstDayOfWeek

取得或設定一週的第一天。

FullDateTimePattern

取得或設定完整日期和時間值的自訂格式字串。

InvariantInfo

取得與文化特性無關 (非變異) 的預設唯讀 DateTimeFormatInfo 物件。

IsReadOnly

取得值,這個值表示 DateTimeFormatInfo 物件是否唯讀。

LongDatePattern

取得或設定完整日期值的自訂格式字串。

LongTimePattern

取得或設定完整時間值的自訂格式字串。

MonthDayPattern

取得或設定月份和日值的自訂格式字串。

MonthGenitiveNames

取得或設定字串陣列,這個陣列包含與目前 DateTimeFormatInfo 物件關聯的月份名稱。

MonthNames

取得或設定包含特定文化特性之月份完整名稱的一維陣列 (型別為 String)。

NativeCalendarName

取得行事曆的原生 (Native) 名稱,這個行事曆與目前 DateTimeFormatInfo 物件關聯。

PMDesignator

取得或設定 "post meridiem" (正午以後) 小時的字串指示項。

RFC1123Pattern

取得時間值的自訂格式字串,這個字串是根據網際網路工程任務推動小組 (Internet Engineering Task Force,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)

傳回與指定 DateTimeFormatInfo 關聯的 IFormatProvider 物件。

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 中。

適用於

另請參閱