DateTimeFormatInfo Třída

Definice

Poskytuje informace specifické pro jazykovou verzi týkající se formátu hodnot data a času.Provides culture-specific information about the format of date and time values.

public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
Dědičnost
DateTimeFormatInfo
Atributy
Implementuje

Příklady

Následující příklad používá reflexi k získání vlastností DateTimeFormatInfo objektu pro anglickou (USA) jazykovou verzi.The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Zobrazuje hodnotu těchto vlastností, které obsahují řetězce vlastního formátu a používají tyto řetězce k zobrazení formátovaných dat.It displays the value of those properties that contain custom format strings and uses those strings to display formatted dates.

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

public class Example
{
   public static void Main()
   {
      // Get the properties of an en-US DateTimeFormatInfo object.
      DateTimeFormatInfo dtfi = CultureInfo.GetCultureInfo("en-US").DateTimeFormat;
      Type typ = dtfi.GetType();
      PropertyInfo[] props = typ.GetProperties();
      DateTime value = new DateTime(2012, 5, 28, 11, 35, 0); 
      
      foreach (var prop in props) {
         // Is this a format pattern-related property?
         if (prop.Name.Contains("Pattern")) {
            string fmt = prop.GetValue(dtfi, null).ToString();
            Console.WriteLine("{0,-33} {1} \n{2,-37}Example: {3}\n", 
                              prop.Name + ":", fmt, "",
                              value.ToString(fmt)); 
         }
      }
   }
}
// The example displays the following output:
//    FullDateTimePattern:              dddd, MMMM dd, yyyy h:mm:ss tt
//                                         Example: Monday, May 28, 2012 11:35:00 AM
//    
//    LongDatePattern:                  dddd, MMMM dd, yyyy
//                                         Example: Monday, May 28, 2012
//    
//    LongTimePattern:                  h:mm:ss tt
//                                         Example: 11:35:00 AM
//    
//    MonthDayPattern:                  MMMM dd
//                                         Example: May 28
//    
//    RFC1123Pattern:                   ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
//                                         Example: Mon, 28 May 2012 11:35:00 GMT
//    
//    ShortDatePattern:                 M/d/yyyy
//                                         Example: 5/28/2012
//    
//    ShortTimePattern:                 h:mm tt
//                                         Example: 11:35 AM
//    
//    SortableDateTimePattern:          yyyy'-'MM'-'dd'T'HH':'mm':'ss
//                                         Example: 2012-05-28T11:35:00
//    
//    UniversalSortableDateTimePattern: yyyy'-'MM'-'dd HH':'mm':'ss'Z'
//                                         Example: 2012-05-28 11:35:00Z
//    
//    YearMonthPattern:                 MMMM, yyyy
//                                         Example: May, 2012
Imports System.Globalization
Imports System.Reflection

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

Poznámky

Vlastnosti DateTimeFormatInfo třídy obsahují informace specifické pro jazykovou verzi pro formátování nebo analýzu hodnot data a času, například následující:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Vzorce používané k formátování hodnot dataThe patterns used to format date values.

  • Vzory používané pro formátování časových hodnot.The patterns used to format time values.

  • Názvy dnů v týdnu.The names of the days of the week.

  • Názvy měsíců v roce.The names of the months of the year.

  • Dop.The A.M. a odpoledne.and P.M. specifikátory použité v časových hodnotách.designators used in time values.

  • Kalendář, ve kterém jsou vyjádřena kalendářní dataThe calendar in which dates are expressed.

V této části:In this section:

Vytvoření instance objektu DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

DateTimeFormatInfo Objekt může představovat konvence formátování invariantní jazykové verze, konkrétní jazykové verze, neutrální jazykové verze nebo aktuální jazykové verze.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. Tato část popisuje, jak vytvořit instanci každého typu DateTimeFormatInfo objektu.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Vytvoření instance objektu DateTimeFormatInfo pro invariantní jazykovou verziInstantiating a DateTimeFormatInfo object for the invariant culture

Invariantní jazyková verze představuje jazykovou verzi, která není závislá na jazykové verzi.The invariant culture represents a culture that is culture-insensitive. Vychází z anglického jazyka, ale ne na konkrétní zemi nebo oblast hovořící v angličtině.It is based on the English language, but not on any specific English-speaking country/region. I když mohou být data konkrétních kultur dynamická a mohou se změnit tak, aby odrážela nové kulturní konvence nebo uživatelské preference, data neutrální jazykové verze se nezmění.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Můžete vytvořit instanci DateTimeFormatInfo objektu, který představuje konvence formátování invariantní jazykové verze, následujícími způsoby:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Následující příklad používá každou z těchto metod pro vytvoření instance DateTimeFormatInfo objektu, který představuje invariantní jazykovou verzi.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Pak určuje, zda je objekt určen jen pro čtení.It then indicates whether the object is read-only.

System.Globalization.DateTimeFormatInfo dtfi; 

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

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

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

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

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

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

Vytvoření instance objektu DateTimeFormatInfo pro konkrétní jazykovou verziInstantiating a DateTimeFormatInfo object for a specific culture

Konkrétní jazyková verze představuje jazyk, který se používá v konkrétní zemi nebo oblasti.A specific culture represents a language that is spoken in a particular country/region. Například en-US je specifická jazyková verze, která představuje anglický jazyk používaný v USA a en-CA je specifická jazyková verze, která představuje anglický jazyk používaný v Kanadě.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Můžete vytvořit instanci DateTimeFormatInfo objektu, který představuje konvence formátování konkrétní jazykové verze, a to následujícími způsoby:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Následující příklad znázorňuje každý z těchto způsobů vytvoření instance DateTimeFormatInfo objektu a označuje, zda je výsledný objekt jen pro čtení.The following example illustrates each of these ways to instantiate a DateTimeFormatInfo object and indicates whether the resulting object is read-only.

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

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

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

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

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

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

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

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

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


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

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

Vytvoření instance objektu DateTimeFormatInfo pro neutrální jazykovou verziInstantiating a DateTimeFormatInfo object for a neutral culture

Neutrální kultura představuje jazykovou verzi nebo jazyk, který je nezávislý na zemi nebo oblasti; obvykle je nadřazeným prvkem jedné nebo více konkrétních kultur.A neutral culture represents a culture or language that is independent of a country/region; it is typically the parent of one or more specific cultures. Například fr je neutrální jazyková verze pro francouzský jazyk a nadřazená jazyková verze fr-FR.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. DateTimeFormatInfo MůžeteDateTimeFormatInfo vytvořit instanci objektu, který představuje konvence formátování neutrální jazykové verze, stejným způsobem jako objekt, který představuje konvence formátování konkrétní jazykové verze.You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a neutral culture in the same ways that you create a DateTimeFormatInfo object that represents the formatting conventions of a specific culture. Kromě toho můžete DateTimeFormatInfo načíst objekt neutrální jazykové verze načtením neutrální jazykové verze z konkrétní CultureInfo.Parent jazykové verze a načtením DateTimeFormatInfo objektu vráceného CultureInfo.DateTimeFormat vlastností.In addition, you can retrieve a neutral culture's DateTimeFormatInfo object by retrieving a neutral culture from a specific culture's CultureInfo.Parent property and retrieving the DateTimeFormatInfo object returned by its CultureInfo.DateTimeFormat property. Pokud nadřazená jazyková verze představuje invariantní jazykovou verzi DateTimeFormatInfo , vrácený objekt je pro čtení a zápis.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. Následující příklad znázorňuje tyto způsoby vytváření instancí DateTimeFormatInfo objektu, který představuje neutrální jazykovou verzi.The following example illustrates these ways of instantiating a DateTimeFormatInfo object that represents a neutral culture.

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

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

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

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

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

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

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

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

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

Poznámka

V .NET Framework verzích 1,0 až .NET Framework 3.5.NET Framework 3.5, pokus o DateTimeFormatInfo načtení objektu, který odráží konvence formátování neutrální jazykové verze, vyvolá NotSupportedException výjimku.In the .NET Framework versions 1.0 through .NET Framework 3.5.NET Framework 3.5, trying to retrieve a DateTimeFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Neutrální jazyková verze však nemá informace o formátování specifické pro jazykovou verzi, protože je nezávislá na konkrétní zemi nebo oblasti.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. Místo naplnění DateTimeFormatInfo objektu obecnými hodnotami .NET Framework DateTimeFormatInfo vrátí objekt, který odráží konvence formátování konkrétní jazykové verze, která je podřízenou neutrální jazykové verzi.Instead of populating the DateTimeFormatInfo object with generic values, the .NET Framework returns a DateTimeFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Například DateTimeFormatInfo objekt pro neutrální jazykovou verzi odráží konvence formátování jazykové verze en-US DateTimeFormatInfo a objekt pro jazykovou verzi fr odráží konvence formátování jazykové verze fr-fr.For example, the DateTimeFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the DateTimeFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Můžete použít kód podobný následujícímu k určení, které konkrétní jazykové konvence formátování neutrální jazykové verze představuje.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. V příkladu se používá reflexe DateTimeFormatInfo k porovnání vlastností neutrální jazykové verze s vlastnostmi konkrétní podřízené jazykové verze.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Považuje se za ekvivalent dvou kalendářů, pokud se jedná o stejný typ kalendáře a v případě gregoriánských kalendářů, pokud jejich GregorianCalendar.CalendarType vlastnosti mají stejné hodnoty.It considers two calendars to be equivalent if they are the same calendar type and, for Gregorian calendars, if their GregorianCalendar.CalendarType properties have identical values.

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

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

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

      foreach (var ci in cultures) {
         bool match = true;     
         // Get the DateTimeFormatInfo for a specific culture.
         DateTimeFormatInfo specificDtfi = ci.DateTimeFormat;
         // Compare the property values of the two.
         foreach (var prop in properties) {
            // We're not interested in the value of IsReadOnly.     
            if (prop.Name == "IsReadOnly") continue;
            
            // For arrays, iterate the individual elements to see if they are the same.
            if (prop.PropertyType.IsArray) { 
               IList nList = (IList) prop.GetValue(dtfi, null);
               IList sList = (IList) prop.GetValue(specificDtfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
Console.WriteLine("   Different n in {2} array for {0} and {1}", name, ci.Name, prop.Name);
                  break;
               } 

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) { 
                     match = false;
Console.WriteLine("   {0} value different for {1} and {2}", prop.Name, name, ci.Name);                     
                     break;
                  }     
               }
               
               if (! match) break;
            }
            // Get non-array values.
            else {
               Object specificValue = prop.GetValue(specificDtfi);
               Object neutralValue = prop.GetValue(dtfi);
                               
               // Handle comparison of Calendar objects.
               if (prop.Name == "Calendar") { 
                  // The cultures have a different calendar type.
                  if (specificValue.ToString() != neutralValue.ToString()) {
Console.WriteLine("   Different calendar types for {0} and {1}", name, ci.Name);
                     match = false;
                     break;
                  }
                   
                  if (specificValue is GregorianCalendar) {
                     if (((GregorianCalendar) specificValue).CalendarType != ((GregorianCalendar) neutralValue).CalendarType) {
Console.WriteLine("   Different Gregorian calendar types for {0} and {1}", name, ci.Name);
                        match = false;
                        break;
                     }
                  }
               }
               else if (! specificValue.Equals(neutralValue)) {
                  match = false;
Console.WriteLine("   Different {0} values for {1} and {2}", prop.Name, name, ci.Name);                  
                  break;   
               }
            }        
         }
         if (match) {
            Console.WriteLine("DateTimeFormatInfo object for '{0}' matches '{1}'", 
                              name, ci.Name);
            hasOneMatch = true;
         }                                       
      }
      if (! hasOneMatch)
         Console.WriteLine("DateTimeFormatInfo object for '{0}' --> No Match", name);            

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

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

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

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

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

Vytvoření instance objektu DateTimeFormatInfo pro aktuální jazykovou verziInstantiating a DateTimeFormatInfo object for the current culture

Můžete vytvořit instanci DateTimeFormatInfo objektu, který představuje konvence formátování aktuální jazykové verze, následujícími způsoby:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

Následující příklad používá každou z těchto metod pro vytvoření instance DateTimeFormatInfo objektu, který představuje konvence formátování aktuální jazykové verze.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Pak určuje, zda je objekt určen jen pro čtení.It then indicates whether the object is read-only.

DateTimeFormatInfo dtfi;

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

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

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

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

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

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

Můžete vytvořit zapisovatelný DateTimeFormatInfo objekt, který představuje konvence aktuální jazykové verze vlákna, jedním z následujících způsobů:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

Následující příklad znázorňuje každý způsob vytvoření instance objektu pro čtení a zápis DateTimeFormatInfo a zobrazuje hodnotu jeho IsReadOnly vlastnosti.The following example illustrates each way of instantiating a read/write DateTimeFormatInfo object and displays the value of its IsReadOnly property.

using System;
using System.Globalization;

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

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

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

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

V systému Windows může uživatel přepsat některé DateTimeFormatInfo hodnoty vlastností používané při formátování a analýze operací prostřednictvím aplikace oblast a jazyk v Ovládacích panelech.In Windows, the user can override some of the DateTimeFormatInfo property values used in formatting and parsing operations through the Region and Language application in Control Panel. Například uživatel, jehož jazyková verze je angličtina (USA), se může rozhodnout zobrazit hodnoty dlouhého času pomocí 24 hodin (ve formátu HH: mm: SS) místo výchozích 12 hodinových hodin (ve formátu h:mm: SS TT).For example, a user whose culture is English (United States) might choose to display long time values using a 24-hour clock (in the format HH:mm:ss) instead of the default 12-hour clock (in the format h:mm:ss tt). DateTimeFormatInfo Objekty načtené různými způsoby, které jsou popsány dříve, odrážejí tato přepsání uživatele.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Pokud je to nežádoucí NumberFormatInfo , můžete vytvořit objekt, který neodráží přepsání uživatele (a také místo jen pro čtení) CultureInfo.CultureInfo(String, Boolean) voláním konstruktoru a false zadáním hodnoty pro useUserOverride argument.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and is also read/write instead of read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. Následující příklad znázorňuje toto pro systém, jehož aktuální jazyková verze je English (USA) a jehož vzor dlouhého času byl změněn z výchozí hodnoty h:mm: SS TT na HH: mm: ss.The following example illustrates this for a system whose current culture is English (United States) and whose long time pattern has been changed from the default of h:mm:ss tt to HH:mm:ss.

using System;
using System.Globalization;

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

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

DateTimeFormatInfo a dynamická dataDateTimeFormatInfo and dynamic data

Data specifická pro jazykovou verzi pro formátování hodnot data a času poskytnutých DateTimeFormatInfo třídou jsou dynamická, stejně jako kulturní data poskytovaná CultureInfo třídou.The culture-specific data for formatting date and time values provided by the DateTimeFormatInfo class is dynamic, just like cultural data provided by the CultureInfo class. Neměli byste vytvářet předpoklady o stabilitě hodnot pro DateTimeFormatInfo objekty, které jsou spojeny s konkrétními CultureInfo objekty.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Pouze data poskytnutá neutrální jazykovou verzí a přidruženým DateTimeFormatInfo objektem jsou stabilní.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Další data se můžou měnit mezi aplikačními relacemi nebo i v době, kdy je vaše aplikace spuštěná.Other data can change between application sessions or even while your application is running. Existují čtyři hlavní zdroje změn:There are four major sources of change:

  • Aktualizace systému.System updates. Jazykové preference, jako je preferovaný kalendář nebo vlastní formáty data a času, se v průběhu času mění.Cultural preferences such as the preferred calendar or customary date and time formats change over time. Pokud k tomu dojde, web Windows Update obsahuje změny DateTimeFormatInfo hodnoty vlastnosti pro konkrétní jazykovou verzi.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Náhradní kultury.Replacement cultures. CultureAndRegionInfoBuilder Třídu lze použít k nahrazení dat stávající jazykové verze.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Kaskádové změny hodnot vlastností.Cascading changes to property values. Množství vlastností, které se týkají jazykové verze, se může v době běhu změnit, což naopak způsobí DateTimeFormatInfo změnu dat.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Aktuální jazykovou verzi lze například změnit programově nebo prostřednictvím akce uživatele.For example, the current culture can be changed either programmatically or through user action. Pokud k tomu dojde, DateTimeFormatInfo objekt vrácený CurrentInfo vlastností se změní na objekt přidružený k aktuální jazykové verzi.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. Podobně se může kalendář jazykové verze změnit, což může vést ke změnám množství DateTimeFormatInfo hodnot vlastností.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Předvolby uživateleUser preferences. Uživatelé vaší aplikace se mohou rozhodnout přepsat některé z hodnot přidružených k aktuální jazykové verzi systému prostřednictvím možností místní a jazykové nastavení v Ovládacích panelech.Users of your application might choose to override some of the values associated with the current system culture through the regional and language options in Control Panel. Uživatelé se například můžou rozhodnout zobrazit datum v jiném formátu.For example, users might choose to display the date in a different format. Pokud je truevlastnost nastavena na hodnotu DateTimeFormatInfo , vlastnosti objektu jsou také načteny z uživatelského nastavení. CultureInfo.UseUserOverrideIf the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Pokud je nastavení uživatele nekompatibilní s jazykovou verzí přidruženou CultureInfo k objektu (například pokud vybraný kalendář není jedním z kalendářů, který je určen OptionalCalendars vlastností), výsledky metod a hodnoty vlastností nejsou definovány.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars indicated by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Chcete-li minimalizovat možnost nekonzistentních dat, jsou při vytvoření objektu inicializovány všechny DateTimeFormatInfo vlastnosti objektu, který lze přepsat uživatelem.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Stále existuje možnost nekonzistence, protože vytvoření objektu ani proces přepsání uživatele není atomické a relevantní hodnoty mohou být při vytváření objektu změněny.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic and the relevant values can change during object creation. Tato situace by však měla být extrémně zřídka.However, this situation should be extremely rare.

Můžete určit, zda se přepisy uživatele odrazí v DateTimeFormatInfo objektech, které představují stejnou jazykovou verzi jako jazyková verze systému.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. V následující tabulce jsou uvedeny způsoby, kterými DateTimeFormatInfo lze objekt načíst, a určuje, zda výsledný objekt odráží přepsání uživatele.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Zdroj objektu CultureInfo a DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Odráží přepsání uživatelů.Reflects user overrides
CultureInfo.CurrentCulture.DateTimeFormatmajetekCultureInfo.CurrentCulture.DateTimeFormat property AnoYes
DateTimeFormatInfo.CurrentInfomajetekDateTimeFormatInfo.CurrentInfo property AnoYes
CultureInfo.CreateSpecificCultureMetodaCultureInfo.CreateSpecificCulture method AnoYes
CultureInfo.GetCultureInfoMetodaCultureInfo.GetCultureInfo method NeNo
CultureInfo.CultureInfo(String)BeginRequestEventArgsCultureInfo.CultureInfo(String) constructor AnoYes
CultureInfo.CultureInfo(String, Boolean)BeginRequestEventArgsCultureInfo.CultureInfo(String, Boolean) constructor Závisí na hodnotě useUserOverride parametruDepends on value of useUserOverride parameter

Pokud neexistují přesvědčivé důvody v jiném smyslu, měli byste respektovat přepsání uživatelů při použití DateTimeFormatInfo objektu v klientských aplikacích k formátování a analýze vstupu uživatele nebo k zobrazení dat.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the DateTimeFormatInfo object in client applications to format and parse user input or to display data. Pro serverové aplikace nebo bezobslužné aplikace byste neměli.For server applications or unattended applications, you should not. Nicméně pokud DateTimeFormatInfo používáte objekt buď explicitně nebo implicitně k uchování dat data a času ve formě řetězce, měli byste buď DateTimeFormatInfo použít objekt, který odráží konvence formátování neutrální jazykové verze, nebo byste měli zadat řetězec vlastního formátu data a času, který použijete bez ohledu na jazykovou verzi.However, if you are using the DateTimeFormatInfo object either explicitly or implicitly to persist date and time data in string form, you should either use a DateTimeFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom date and time format string that you use regardless of culture.

Formátování data a časuFormatting dates and times

DateTimeFormatInfo Objekt se používá implicitně nebo explicitně ve všech operacích formátování data a času.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Mezi ně patří volání následujících metod:These include calls to the following methods:

Všechny operace IFormatProvider formátování data a času využívají implementaci.All date and time formatting operations make use of an IFormatProvider implementation. Rozhraní obsahuje jedinou metodu, IFormatProvider.GetFormat(Type). IFormatProviderThe IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Tato metoda zpětného volání je Type předána objekt, který představuje typ potřebný k poskytnutí informací o formátování.This callback method is passed a Type object that represents the type needed to provide formatting information. Metoda vrátí buď instanci tohoto typu, nebo null Pokud nemůže poskytnout instanci typu.The method returns either an instance of that type or null if it cannot provide an instance of the type. .NET Framework obsahuje dvě IFormatProvider implementace formátování data a času:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Pokud není CultureInfo CultureInfo.CurrentCulture implementována metoda formátování explicitně, je použit objekt vrácený vlastností, která představuje aktuální jazykovou verzi vlákna. IFormatProviderIf an IFormatProvider implementation is not provided to a formatting method explicitly, the CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Následující příklad znázorňuje vztah mezi IFormatProvider rozhraním a třídou v rámci DateTimeFormatInfo formátování operací.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Definuje vlastní IFormatProvider implementaci, jejíž GetFormat Metoda zobrazuje typ objektu, který požaduje operace formátování.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. Pokud vyžaduje DateTimeFormatInfo objekt, metoda DateTimeFormatInfo poskytuje objekt pro aktuální jazykovou verzi vlákna.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Jak ukazuje výstup z příkladu, Decimal.ToString(IFormatProvider) metoda DateTimeFormatInfo požaduje objekt, který poskytuje informace o String.Format(IFormatProvider, String, Object[]) formátování, zatímco požadavky NumberFormatInfo ICustomFormatter metody a objekty a DateTimeFormatInfo také provádění.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a DateTimeFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

using System;
using System.Globalization;

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

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

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

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

Formátování řetězců a vlastností DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

DateTimeFormatInfo Objekt obsahuje tři druhy vlastností, které se používají při formátování operací s hodnotami data a času:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

Standardní formátovací řetězce data a času, například "d", "d", "f" a "f", jsou aliasy, které odpovídají konkrétním DateTimeFormatInfo vlastnostem vzoru formátu.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. Většina vlastních formátovacích řetězců data a času souvisí s řetězci nebo podřetězci, které operace formátování vloží do výsledného datového proudu.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. Následující tabulka uvádí standardní a vlastní specifikátory formátu data a času a jejich přidružené DateTimeFormatInfo vlastnosti.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Podrobnosti o tom, jak používat tyto specifikátory formátu, naleznete v tématu Standardní řetězce formátu data a času a Vlastní řetězce formátu data a času.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Všimněte si, že každý standardní formátovací řetězec odpovídá DateTimeFormatInfo vlastnosti, jejíž hodnota je řetězec vlastního formátu data a času.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Jednotlivé specifikátory v tomto vlastním formátovacím řetězci zase odpovídají dalším DateTimeFormatInfo vlastnostem.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. Tabulka obsahuje seznam pouze DateTimeFormatInfo vlastností, pro které standardní formátovací řetězce jsou aliasy, a nezobrazuje seznam vlastností, které jsou k nim přistupné pomocí vlastních formátovacích řetězců přiřazených k těmto vlastnostem s aliasem.The table lists only the DateTimeFormatInfo properties for which the standard format strings are aliases, and does not list properties that may be accessed by custom format strings assigned to those aliased properties. Kromě toho tabulka uvádí pouze vlastní specifikátory formátu, které odpovídají DateTimeFormatInfo vlastnostem.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Specifikátor formátuFormat specifier Přidružené vlastnostiAssociated properties
"d" (krátké datum; standardní formátovací řetězec)"d" (short date; standard format string) ShortDatePattern, chcete-li definovat celkový formát výsledného řetězce.ShortDatePattern, to define the overall format of the result string.
"D" (dlouhé datum; standardní formátovací řetězec)"D" (long date; standard format string) LongDatePattern, chcete-li definovat celkový formát výsledného řetězce.LongDatePattern, to define the overall format of the result string.
"f" (celé datum/krátký čas; řetězec standardního formátu)"f" (full date / short time; standard format string) LongDatePattern, chcete-li definovat formát komponenty data výsledného řetězce.LongDatePattern, to define the format of the date component of the result string.

ShortTimePatternpro definování formátu času komponenty výsledného řetězce.ShortTimePattern, to define the format of the time component of the result string.
"F" (úplné datum/dlouhý čas; řetězec standardního formátu)"F" (full date / long time; standard format string) LongDatePattern, chcete-li definovat formát komponenty data výsledného řetězce.LongDatePattern, to define the format of the date component of the result string.

LongTimePatternpro definování formátu času komponenty výsledného řetězce.LongTimePattern, to define the format of the time component of the result string.
"g" (Obecné datum/krátký čas; řetězec standardního formátu)"g" (general date / short time; standard format string) ShortDatePattern, chcete-li definovat formát komponenty data výsledného řetězce.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePatternpro definování formátu času komponenty výsledného řetězce.ShortTimePattern, to define the format of the time component of the result string.
"G" (Obecné datum/dlouhý čas; řetězec standardního formátu)"G" (general date / long time; standard format string) ShortDatePattern, chcete-li definovat formát komponenty data výsledného řetězce.ShortDatePattern, to define the format of the date component of the result string.

LongTimePatternpro definování formátu času komponenty výsledného řetězce.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (měsíc/den; standardní formátovací řetězec)"M", "m" (month/day; standard format string) MonthDayPattern, chcete-li definovat celkový formát výsledného řetězce.MonthDayPattern, to define the overall format of the result string.
"O", "o" (datum/čas zpátečního přenosu; řetězec standardního formátu)"O", "o" (round-trip date/time; standard format string) ŽádnéNone.
"R", "r" (RFC1123; řetězec standardního formátu)"R", "r" (RFC1123; standard format string) RFC1123Pattern, k definování výsledného řetězce, který odpovídá standardu RFC 1123.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. Vlastnost je určena jen pro čtení.The property is read-only.
"s" (seřaditelné datum a čas; řetězec standardního formátu)"s" (sortable date/time; standard format string) SortableDateTimePattern, k definování výsledného řetězce, který odpovídá standardu ISO 8601.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. Vlastnost je určena jen pro čtení.The property is read-only.
"t" (krátký čas; řetězec standardního formátu)"t" (short time; standard format string) ShortTimePattern, chcete-li definovat celkový formát výsledného řetězce.ShortTimePattern, to define the overall format of the result string.
"T" (dlouhý čas; řetězec standardního formátu)"T" (long time; standard format string) LongTimePattern, chcete-li definovat celkový formát výsledného řetězce.LongTimePattern, to define the overall format of the result string.
"u" (univerzální seřaditelné datum a čas; standardní formátovací řetězec)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, k definování výsledného řetězce, který odpovídá standardu ISO 8601 pro koordinovaný světový čas.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. Vlastnost je určena jen pro čtení.The property is read-only.
"U" (univerzální úplné datum/čas; řetězec standardního formátu)"U" (universal full date/time; standard format string) FullDateTimePattern, chcete-li definovat celkový formát výsledného řetězce.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (rok v měsíci; standardní formátovací řetězec)"Y", "y" (year month; standard format string) YearMonthPattern, chcete-li definovat celkový formát výsledného řetězce.YearMonthPattern, to define the overall format of the result string.
"ddd" (specifikátor vlastního formátu)"ddd" (custom format specifier) AbbreviatedDayNames, pokud chcete do výsledného řetězce zahrnout zkrácený název dne v týdnu.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "GG" (specifikátor vlastního formátu)"g", "gg" (custom format specifier) GetEraName Volá metodu pro vložení názvu období do výsledného řetězce.Calls the GetEraName method to insert the era name in the result string.
"MMM" (specifikátor vlastního formátu)"MMM" (custom format specifier) AbbreviatedMonthNames, pokud chcete do výsledného řetězce zahrnout zkrácený název měsíce.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (specifikátor vlastního formátu)"MMMM" (custom format specifier) MonthNamesnebo MonthGenitiveNames, pokud chcete do výsledného řetězce zahrnout celý název měsíce.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (specifikátor vlastního formátu)"t" (custom format specifier) AMDesignatornebo PMDesignator, pokud chcete do výsledného řetězce zahrnout první znak označení dopoledne/odpoledne.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"tt" (specifikátor vlastního formátu)"tt" (custom format specifier) AMDesignatornebo PMDesignator, pokud chcete do výsledného řetězce zahrnout celé označení dopoledne/odpoledne.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (specifikátor vlastního formátu)":" (custom format specifier) TimeSeparator, chcete-li zahrnout oddělovač času ve výsledném řetězci.TimeSeparator, to include the time separator in the result string.
"/" (specifikátor vlastního formátu)"/" (custom format specifier) DateSeparator, chcete-li do výsledného řetězce zahrnout oddělovač data.DateSeparator, to include the date separator in the result string.

Změna vlastností DateTimeFormatInfoModifying DateTimeFormatInfo properties

Výsledný řetězec vyprodukovaný řetězci formátu data a času lze změnit úpravou přidružených vlastností objektu, který lze zapisovat DateTimeFormatInfo .You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. Chcete-li zjistit DateTimeFormatInfo , zda je objekt zapisovatelný IsReadOnly , použijte vlastnost.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. Postup pro přizpůsobení DateTimeFormatInfo objektu tímto způsobem:To customize a DateTimeFormatInfo object in this way:

  1. Vytvořte kopii DateTimeFormatInfo objektu pro čtení a zápis, jejíž konvence formátování chcete upravit.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Viz část vytvoření instance objektu DateTimeFormatInfo .)(See the Instantiating a DateTimeFormatInfo object section.)

  2. Upravte vlastnost nebo vlastnosti, které se používají k výrobě požadovaného výsledného řetězce.Modify the property or properties that are used to produce the desired result string. (Informace o tom, jak metody formátování DateTimeFormatInfo používají vlastnosti k definování výsledných řetězců, najdete v předchozí části, formátování řetězců a DateTimeFormatInfo vlastností.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Použijte vlastní DateTimeFormatInfo objekt, který jste vytvořili IFormatProvider jako argument v volání metod formátování.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Existují dva způsoby, jak změnit formát výsledného řetězce:There are two other ways to change the format of a result string:

  • CultureAndRegionInfoBuilder Třídu lze použít k definování vlastní jazykové verze (jazyková verze, která má jedinečný název a doplňuje stávající jazykové verze), nebo nahrazující jazykové verze (ta, která se používá místo konkrétní jazykové verze).You can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture). Tuto jazykovou verzi můžete ukládat programově stejným způsobem jako jakýkoli CultureInfo objekt podporovaný .NET Framework.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Pokud výsledný řetězec není závislý na jazykové verzi a nedodržuje předdefinovaný formát, můžete použít vlastní řetězec formátu data a času.If the result string is not culture-sensitive and doesn't follow a predefined format, you can use a custom date and time format string. Například pokud provádíte serializaci dat data a času ve formátu rrrrmmddhhmmss, můžete vygenerovat výsledný řetězec předáním řetězce vlastního formátu do DateTime.ToString(String) metody a můžete převést výsledný řetězec zpět DateTime na hodnotu voláním DateTime.ParseExact metoda.For example, if you are serializing date and time data in the format YYYYMMDDHHmmss, you can generate the result string by passing the custom format string to the DateTime.ToString(String) method, and you can convert the result string back to a DateTime value by calling the DateTime.ParseExact method.

Změna vzorce krátkého formátu dataChanging the short date pattern

Následující příklad změní formát výsledného řetězce vytvořeného pomocí standardního formátovacího řetězce "d" (krátký datum).The following example changes the format of a result string produced by the "d" (short date) standard format string. Změní přidruženou ShortDatePattern vlastnost pro jazykovou verzi en-US nebo English (USA) z výchozí hodnoty "M/d/rrrr" na "rrrr"-"mm"-"dd" a používá standardní formátovací řetězec "d" k zobrazení data před i ShortDatePattern po vlastnosti. upraven.It changes the associated ShortDatePattern property for the en-US or English (United States) culture from its default of "M/d/yyyy" to "yyyy'-"MM"-"dd" and uses the "d" standard format string to display the date both before and after the ShortDatePattern property is changed.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 8, 18); 
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      
      Console.WriteLine("Before modifying DateTimeFormatInfo object: ");
      Console.WriteLine("{0}: {1}\n", dtfi.ShortDatePattern, 
                                    dateValue.ToString("d", enUS));

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

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

Změna znaku oddělovače dataChanging the date separator character

Následující příklad změní znak oddělovače data v DateTimeFormatInfo objektu, který představuje konvence formátování jazykové verze fr-fr.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. V příkladu se používá standardní formátovací řetězec "g" k zobrazení data před i po DateSeparator změně vlastnosti.The example uses the "g" standard format string to display the date both before and after the DateSeparator property is changed.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 08, 28); 
      CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
      DateTimeFormatInfo dtfi = frFR.DateTimeFormat;
      
      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
      
      // Modify the date separator.
      dtfi.DateSeparator = "-";
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
   }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 18/08/2013 00:00
//       After modifying the DateSeparator property: 18-08-2013 00:00
Imports System.Globalization

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

Změna zkratek názvů dnů a vzorku dlouhého formátu dataChanging day name abbreviations and the long date pattern

V některých případech může být příliš dlouhý vzor dlouhého data, který obvykle zobrazuje úplný název dne a měsíce spolu s číslem dne v měsíci a rokem.In some cases, the long date pattern, which typically displays the full day and month name along with the number of the day of the month and the year, may be too long. Následující příklad zkracuje vzor dlouhého data pro jazykovou verzi en-US, aby vrátila zkratku názvu dne se dvěma znaky, a za nímž následuje číslo dne, zkratka názvu měsíce a rok.The following example shortens the long date pattern for the en-US culture to return a one-character or two-character day name abbreviation followed by the day number, the month name abbreviation, and the year. Provede to přiřazením kratších zkratek názvu k AbbreviatedDayNames poli a úpravou vlastního formátovacího řetězce přiřazeného LongDatePattern k vlastnosti.It does this by assigning shorter day name abbreviations to the AbbreviatedDayNames array, and by modifying the custom format string assigned to the LongDatePattern property. To má vliv na výsledné řetězce vracené standardními formátovacími řetězci "D" a "f".This affects the result strings returned by the "D" and "f" standard format strings.

using System;
using System.Globalization;

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

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

      Console.WriteLine();
      
      // We don't want to change the FullDateTimePattern, so we need to save it.
      String originalFullDateTimePattern = dtfi.FullDateTimePattern;
      
      // Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
      dtfi.FullDateTimePattern = originalFullDateTimePattern;
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));

   }
}
// The example displays the following output:
//       D: Tuesday, July 09, 2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tuesday, July 09, 2013 12:00 AM
//       
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM
Imports System.Globalization

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

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

Změna LongDatePattern vlastnosti má obvykle FullDateTimePattern vliv na vlastnost, která zase definuje výsledný řetězec vrácený řetězcem standardního formátu "F".Ordinarily, the change to the LongDatePattern property also affects the FullDateTimePattern property, which in turn defines the result string returned by the "F" standard format string. Chcete-li zachovat původní vzor úplného data a času, pak tento příklad znovu přiřadí původní řetězec vlastního formátu přiřazený FullDateTimePattern vlastnosti LongDatePattern po změně vlastnosti.To preserve the original full date and time pattern, the example reassigns the original custom format string assigned to the FullDateTimePattern property after the LongDatePattern property is modified.

Změna z 12hodinového formátu na 24hodinový formátChanging from a 12-hour clock to a 24-hour clock

Pro mnoho kultur v .NET Framework je čas vyjádřen pomocí 12 hodin a označení dopoledne/odpoledne.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. Následující příklad definuje ReplaceWith24HourClock metodu, která nahrazuje libovolný formát času, který používá 12 hodinový formát, který používá 24hodinový čas.The following example defines a ReplaceWith24HourClock method that replaces any time format that uses a 12-hour clock with a format that uses a 24-hour clock.

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

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

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

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

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

V příkladu je použit regulární výraz pro úpravu formátovacího řetězce.The example uses a regular expression to modify the format string. Vzor @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) regulárního výrazu je definován následujícím způsobem:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

VzorPattern PopisDescription
^ Zahajte shodu na začátku řetězce.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Porovná žádný nebo jeden výskyt nula nebo více prázdných znaků následovaných jednou nebo vícekrát písmenem "t" a následovaný žádným nebo více prázdnými znaky.Match zero or one occurrence of zero or more white-space characters, followed by the letter "t" one or more times, followed by zero or more white-space characters. Tato zachytávající skupina je openAMPMpojmenována.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Pokud má openAMPM skupina shodu, porovnává písmeno "h" jednou nebo vícekrát následovaný jedním nebo více znaky, které nejsou "h" ani "t".If the openAMPM group has a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t". Porovnávání končí na konci řetězce.The match ends at the end of the string. Všechny znaky zachycené po "h" jsou zahrnuty do zachytávající skupiny nonHourss názvem.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) openAMPM Pokud skupina nemá shodu, porovná písmeno "h" jednou nebo vícekrát následovaný jedním nebo více znaky, které nejsou "h" ani "t", za kterými následuje nula nebo více prázdných znaků.If the openAMPM group does not have a match, match the letter "h" one or more times, followed by one or more characters that are neither "h" nor "t", followed by zero or more white-space characters. Nakonec porovnává jeden nebo více výskytů písmena "t".Finally, match one or more occurrences of the letter "t". Všechny znaky zachycené po "h" a před mezerami a "t" jsou zahrnuty do zachytávající skupiny s názvem nonHours.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

nonHours Zachytávající skupina obsahuje minutu a pravděpodobně druhou komponentu vlastního formátovacího řetězce data a času spolu se symboly oddělovače času.The nonHours capturing group contains the minute and possibly the second component of a custom date and time format string, along with any time separator symbols. Vzor HH${nonHours} pro nahrazení předřadí do těchto prvků dílčí řetězec "HH".The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Zobrazení a změna éry v datuDisplaying and changing the era in a date

Následující příklad přidá Specifikátor vlastního formátu "g" do LongDatePattern vlastnosti objektu, který představuje konvence formátování jazykové verze en-US.The following example adds the "g" custom format specifier to the LongDatePattern property of an object that represents the formatting conventions of the en-US culture. Toto sčítání má vliv na následující tři standardní formátovací řetězce:This addition affects the following three standard format strings:

  • Standardní formátovací řetězec "D" (dlouhý datum), který se mapuje přímo na LongDatePattern vlastnost.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • Standardní formátovací řetězec "f" (plný datum/krátký čas), který vytváří výsledný řetězec, který zřetězí podřetězce vytvořené LongDatePattern vlastnostmi a. ShortTimePatternThe "f" (full date / short time) standard format string, which produces a result string that concatenates the substrings produced by the LongDatePattern and ShortTimePattern properties.

  • Standardní formátovací řetězec "F" (plný datum/dlouhý čas), který se mapuje přímo na FullDateTimePattern vlastnost.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Vzhledem k LongDatePattern tomu, že tato hodnota vlastnosti nebyla explicitně nastavena, je generována dynamicky zřetězením vlastností LongTimePattern a.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

Příklad také ukazuje, jak změnit název období pro jazykovou verzi, jejíž kalendář má jedno období.The example also shows how to change the era name for a culture whose calendar has a single era. V tomto případě jazyková verze en-US používá gregoriánský kalendář, který je reprezentován GregorianCalendar objektem.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. GregorianCalendar Třída podporuje jedno období, pro které se pojmenuje n.l.The GregorianCalendar class supports a single era, which it names A.D. (Anno Domini).(Anno Domini). V příkladu se změní název posouzení období na 0001The example changes the era name to C.E. (Běžný životní postup) nahrazením specifikátoru vlastního formátu "g" ve formátovacím řetězci, který FullDateTimePattern je přiřazen k vlastnosti s řetězcovým literálem.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. Použití řetězcového literálu je nezbytné, protože název období je obvykle vrácen GetEraName metodou z privátních dat v tabulkách jazykové verze dodanými .NET Framework nebo operačním systémem Windows.The use of a literal string is necessary, because the era name is typically returned by the GetEraName method from private data in the culture tables supplied by either the .NET Framework or the Windows operating system.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 5, 18, 13, 30, 0);
      String[] formats = { "D", "f", "F" };      
      
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      DateTimeFormatInfo dtfi = enUS.DateTimeFormat;
      String originalLongDatePattern = dtfi.LongDatePattern;

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

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

      Console.WriteLine();
      
      // Change A.D. to C.E. (for Common Era)
      dtfi.LongDatePattern = originalLongDatePattern + @" 'C.E.'";
      foreach (var fmt in formats)
         Console.WriteLine(dateValue.ToString(fmt, dtfi));

   }
}
// The example displays the following output:
//       Saturday, May 18, 2013
//       Saturday, May 18, 2013 1:30 PM
//       Saturday, May 18, 2013 1:30:00 PM
//       
//       Saturday, May 18, 2013 A.D.
//       Saturday, May 18, 2013 A.D. 1:30 PM
//       Saturday, May 18, 2013 A.D. 1:30:00 PM
//       
//       Saturday, May 18, 2013 C.E.
//       Saturday, May 18, 2013 C.E. 1:30 PM
//       Saturday, May 18, 2013 C.E. 1:30:00 PM
Imports System.Globalization

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

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

Analýza řetězců data a časuParsing date and time strings

Analýza zahrnuje převod řetězcové reprezentace data a času na DateTime hodnotu nebo. DateTimeOffsetParsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Oba tyto Parsetypy obsahují TryParseExact metody, TryParse, ParseExacta pro podporu analytických operací.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. ParseExact TryParseExact Metody a TryParsepřevádějí řetězec, který může mít různé formáty, zatímco a vyžaduje, aby řetězec měl definovaný formát nebo formáty. ParseThe Parse and TryParse methods convert a string that can have a variety of formats, whereas ParseExact and TryParseExact require that the string have a defined format or formats. Pokud operace analýzy neproběhne úspěšně Parse , ParseExact vyvolejte výjimku, zatímco TryParse a TryParseExact vrátí false.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Metody analýzy implicitně nebo explicitně používají DateTimeStyles hodnotu výčtu k určení, které prvky stylu (například počáteční, koncové nebo vnitřní prázdné znaky) mohou být k dispozici v řetězci, který má být analyzován, a jak interpretovat analyzovaný řetězec nebo všechny chybějící elementu.The parsing methods implicitly or explicitly use a DateTimeStyles enumeration value to determine which style elements (such as leading, trailing, or inner white space) can be present in the string to be parsed, and how to interpret the parsed string or any missing elements. Pokud nezadáte DateTimeStyles hodnotu při DateTimeStyles.AllowTrailingWhite DateTimeStyles.AllowLeadingWhite DateTimeStyles.AllowWhiteSpaces Parse volání metody nebo TryParse , výchozí hodnota je, což je složený styl, který obsahuje příznaky, a DateTimeStyles.AllowInnerWhite .If you don't provide a DateTimeStyles value when you call the Parse or TryParse method, the default is DateTimeStyles.AllowWhiteSpaces, which is a composite style that includes the DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, and DateTimeStyles.AllowInnerWhite flags. Pro metody ParseExact a TryParseExact jeDateTimeStyles.Nonevýchozí hodnota; vstupní řetězec musí přesně odpovídat konkrétnímu řetězci vlastního formátu data a času.For the ParseExact and TryParseExact methods, the default is DateTimeStyles.None; the input string must correspond precisely to a particular custom date and time format string.

Metody analýzy také implicitně nebo explicitně používají DateTimeFormatInfo objekt, který definuje konkrétní symboly a vzory, které mohou nastat v řetězci, který má být analyzován.The parsing methods also implicitly or explicitly use a DateTimeFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Pokud DateTimeFormatInfo objekt neposkytnete DateTimeFormatInfo , je ve výchozím nastavení použit objekt pro aktuální jazykovou verzi vlákna.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Další informace o analýze řetězců data a času naleznete v tématu jednotlivé metody analýzy, DateTime.Parsenapříklad, DateTime.TryParse, DateTimeOffset.ParseExacta DateTimeOffset.TryParseExact.For more information about parsing date and time strings, see the individual parsing methods, such as DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, and DateTimeOffset.TryParseExact.

Následující příklad ukazuje povahu pro analýzu řetězců data a času zohledňující jazykovou verzi.The following example illustrates the culture-sensitive nature of parsing date and time strings. Snaží se analyzovat dva řetězce data pomocí konvencí kultur en-US, en-GB, fr-FR a Fi-FI.It tries to parse two date strings by using the conventions of the en-US, en-GB, fr-FR, and fi-FI cultures. Datum, které je interpretováno jako 8/18/2014 v jazykové verzi en-US, FormatException vyvolá výjimku v ostatních třech jazykových verzích, protože 18 je interpretováno jako číslo měsíce.The date that is interpreted as 8/18/2014 in the en-US culture throws a FormatException exception in the other three cultures because 18 is interpreted as the month number. 1/2/2015 se analyzuje jako druhý den prvního měsíce v kultuře en-US, ale jako první den druhého měsíce ve zbývajících jazykových verzích.1/2/2015 is parsed as the second day of the first month in the en-US culture, but as the first day of the second month in the remaining cultures.

using System;
using System.Globalization;

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

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

Řetězce data a času jsou obvykle analyzovány ze dvou důvodů:Date and time strings are typically parsed for two reasons:

  • Pro převod vstupu uživatele na hodnotu data a času.To convert user input into a date and time value.

  • K přenosu hodnoty data a času; To znamená, že k deserializaci hodnoty data a času, která byla dříve serializována jako řetězec.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

Následující části podrobněji popisují tyto dvě operace.The following sections discuss these two operations in greater detail.

Analýza uživatelských řetězcůParsing user strings

Při analýze řetězce data a času, který uživatel zadá, byste měli vždy vytvořit instanci DateTimeFormatInfo objektu, který odráží kulturní nastavení uživatele, včetně všech vlastních nastavení, která uživatel mohl udělat.When you parse date and time strings input by the user, you should always instantiate a DateTimeFormatInfo object that reflects the user's cultural settings, including any customizations the user may have made. V opačném případě může mít objekt data a času nesprávné hodnoty.Otherwise, the date and time object may have incorrect values. Informace o tom, jak vytvořit instanci DateTimeFormatInfo objektu, který odráží přizpůsobení kulturního prostředí uživatele, najdete v části DateTimeFormatInfo and Dynamic Data .For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

Následující příklad znázorňuje rozdíl mezi operací analýzy, která odráží nastavení kultury uživatele a druhý, který ne.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. V tomto případě je výchozí jazyková verze systému en-US, ale uživatel použil ovládací panely, oblast a jazyk ke změně vzoru krátkého data z výchozí hodnoty "M/d/rrrr" na "RR/mm/dd".In this case, the default system culture is en-US, but the user has used Control Panel, Region and Language to change the short date pattern from its default of "M/d/yyyy" to "yy/MM/dd". Když uživatel zadá řetězec, který odráží uživatelská nastavení, a řetězec je analyzován pomocí DateTimeFormatInfo objektu, který také odráží uživatelská nastavení (přepsání), operace analýzy vrátí správný výsledek.When the user enters a string that reflects user settings, and the string is parsed by a DateTimeFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Nicméně, pokud je řetězec analyzován pomocí DateTimeFormatInfo objektu, který odráží standardní kulturní nastavení en-US, metoda analýzy FormatException vyvolá výjimku, protože interpretuje hodnotu 14 jako číslo měsíce, nikoli poslední dvě číslice roku.However, when the string is parsed by a DateTimeFormatInfo object that reflects standard en-US cultural settings, the parsing method throws a FormatException exception because it interprets 14 as the number of the month, not the last two digits of the year.

using System;
using System.Globalization;

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

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

Serializace a deserializace údajů data a časuSerializing and deserializing date and time data

Očekává se, že data serializovaného data a času se odcestují. To znamená, že všechny serializované a deserializované hodnoty by měly být identické.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Pokud hodnota data a času představuje jediný okamžik v čase, deserializovaná hodnota by měla představovat stejný okamžik v čase bez ohledu na jazykovou verzi nebo časové pásmo systému, na kterém byla obnovena.If a date and time value represents a single moment in time, the deserialized value should represent the same moment in time regardless of the culture or time zone of the system on which it was restored. K úspěšnému přenosu dat data a času je nutné použít konvence invariantní jazykové verze, která je vrácena InvariantInfo vlastností, pro generování a analýzu dat.To round-trip date and time data successfully, you must use the conventions of the invariant culture, which is returned by the InvariantInfo property, to generate and parse the data. Operace formátování a analýzy by nikdy neměly odrážet konvence výchozí jazykové verze.The formatting and parsing operations should never reflect the conventions of the default culture. Pokud použijete výchozí kulturní nastavení, přenositelnost dat se striktně omezí; lze ji úspěšně deserializovat pouze v vlákně, jejichž nastavení specifické pro jazykovou verzi je identické s hodnotami vlákna, na kterých byla serializována.If you use default cultural settings, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose cultural-specific settings are identical to those of the thread on which it was serialized. V některých případech to znamená, že data nelze ani úspěšně serializovat a deserializovat ve stejném systému.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Pokud je časová komponenta hodnoty data a času podstatná, měla by být také převedena na UTC a serializována pomocí standardního formátovacího řetězce"o" nebo "r".If the time component of a date and time value is significant, it should also be converted to UTC and serialized by using the "o" or "r" standard format string. Časová data se pak dají obnovit voláním metody analýzy a předáním příslušného formátovacího řetězce spolu s invariantní jazykové verze jako provider argumentem.The time data can then be restored by calling a parsing method and passing it the appropriate format string along with the invariant culture as the provider argument.

Následující příklad znázorňuje proces Round-Trip hodnoty data a času.The following example illustrates the process of round-tripping a date and time value. V systému je serializováno datum a čas, který dodržuje USA. Tichomoří a jeho aktuální kultura je en-US.It serializes a date and time on a system that observes U.S. Pacific time and whose current culture is en-US.

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

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

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

Deserializace dat v systému v Bruselu, Kodani, Madrid a v Paříži časovém pásmu a jehož aktuální jazyková verze je fr-FR.It deserializes the data on a system in the Brussels, Copenhagen, Madrid and Paris time zone and whose current culture is fr-FR. Obnovené datum je devět hodin později než původní datum, které odráží úpravu časového pásma od osmi hodin za UTC po jednu hodinu před časem UTC.The restored date is nine hours later than the original date, which reflects the time zone adjustment from eight hours behind UTC to one hour ahead of UTC. Původní datum i obnovené datum reprezentují stejný okamžik v čase.Both the original date and the restored date represent the same moment in time.

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

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

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

Konstruktory

DateTimeFormatInfo()

Inicializuje novou zapisovatelnou instanci DateTimeFormatInfo třídy, která je nezávislé na jazykové verzi (invariantní).Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Vlastnosti

AbbreviatedDayNames

Získává nebo nastavuje jednorozměrné pole typu String obsahující zkrácené názvy dnů v týdnu specifické pro jazykovou verzi.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames

Získá nebo nastaví pole řetězců zkrácených názvů měsíců přidružených k aktuálnímu DateTimeFormatInfo objektu.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames

Získá nebo nastaví jednorozměrné pole řetězců obsahující zkrácené názvy měsíců specifické pro jazykovou verzi.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator

Získá nebo nastaví označení řetězce pro hodiny, které jsou "ante meridiem" (před polednem).Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar

Získá nebo nastaví kalendář, který má být použit pro aktuální jazykovou verzi.Gets or sets the calendar to use for the current culture.

CalendarWeekRule

Získává nebo nastavuje hodnotu, která určuje, které pravidlo se použije k určení prvního kalendářního týdne v roce.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo

Získá objekt jen DateTimeFormatInfo pro čtení, který formátuje hodnoty na základě aktuální jazykové verze.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator

Získá nebo nastaví řetězec, který odděluje součásti data, to znamená rok, měsíc a den.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames

Získá nebo nastaví jednorozměrné pole řetězců, které obsahuje celé názvy dnů v týdnu specifické pro jazykovou verzi.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek

Získá nebo nastaví první den v týdnu.Gets or sets the first day of the week.

FullDateTimePattern

Získá nebo nastaví řetězec vlastního formátu pro hodnotu dlouhého data a dlouhého času.Gets or sets the custom format string for a long date and long time value.

InvariantInfo

Získá výchozí objekt jen DateTimeFormatInfo pro čtení, který je nezávislý na jazykové verzi (invariantní).Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly

Načte hodnotu, která označuje, DateTimeFormatInfo zda je objekt určen jen pro čtení.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern

Získá nebo nastaví řetězec vlastního formátu pro hodnotu dlouhého data.Gets or sets the custom format string for a long date value.

LongTimePattern

Získá nebo nastaví řetězec vlastního formátu pro dlouhou časovou hodnotu.Gets or sets the custom format string for a long time value.

MonthDayPattern

Získá nebo nastaví řetězec vlastního formátu pro hodnotu měsíce a dne.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames

Získá nebo nastaví pole řetězců pro názvy měsíců přidružené k aktuálnímu DateTimeFormatInfo objektu.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames

Získává nebo nastavuje jednorozměrné pole typu String obsahující celé názvy měsíců specifické pro jazykovou verzi.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName

Získá nativní název kalendáře přidruženého k aktuálnímu DateTimeFormatInfo objektu.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator

Získá nebo nastaví označení řetězce pro hodiny, které jsou "post meridiem" (po poledne).Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern

Získá řetězec vlastního formátu pro časovou hodnotu, která je založena na specifikaci RFC (Internet Engineering Task Force) pro komentáře 1123.Gets the custom format string for a time value that is based on the Internet Engineering Task Force (IETF) Request for Comments (RFC) 1123 specification.

ShortDatePattern

Získá nebo nastaví řetězec vlastního formátu pro hodnotu krátkého data.Gets or sets the custom format string for a short date value.

ShortestDayNames

Získá nebo nastaví pole řetězců krátkých jedinečných názvů dnů spojených s aktuálním DateTimeFormatInfo objektem.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern

Získá nebo nastaví řetězec vlastního formátu pro krátkou časovou hodnotu.Gets or sets the custom format string for a short time value.

SortableDateTimePattern

Získá vlastní řetězec formátu pro hodnotu řazení data a času.Gets the custom format string for a sortable date and time value.

TimeSeparator

Získá nebo nastaví řetězec, který odděluje komponenty času, tj. hodiny, minuty a sekundy.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern

Získá řetězec vlastního formátu pro univerzální, seřaditelné datum a čas, jak je definováno normou ISO 8601.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern

Získá nebo nastaví řetězec vlastního formátu pro hodnotu roku a měsíce.Gets or sets the custom format string for a year and month value.

Metody

Clone()

Vytvoří kopii v DateTimeFormatInfochráněném umístění.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetAbbreviatedDayName(DayOfWeek)

Vrátí zkrácený název určený pro jazykovou verzi určeného dne v týdnu na základě jazykové verze přidružené k aktuálnímu DateTimeFormatInfo objektu.Returns the culture-specific abbreviated name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetAbbreviatedEraName(Int32)

Vrátí řetězec obsahující zkrácený název zadaného období, pokud existuje zkratka.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32)

Vrátí zkrácený název určený pro jazykovou verzi zadaného měsíce na základě jazykové verze přidružené k aktuálnímu DateTimeFormatInfo objektu.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns()

Vrátí všechny standardní vzory, ve kterých lze formátovat hodnoty data a času.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char)

Vrátí všechny vzory, ve kterých lze hodnoty data a času formátovat pomocí zadaného standardního formátovacího řetězce.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek)

Vrátí úplný název určený ke konkrétní jazykové verzi zadaného dne v týdnu na základě jazykové verze přidružené k aktuálnímu DateTimeFormatInfo objektu.Returns the culture-specific full name of the specified day of the week based on the culture associated with the current DateTimeFormatInfo object.

GetEra(String)

Vrátí celé číslo představující zadané období.Returns the integer representing the specified era.

GetEraName(Int32)

Vrátí řetězec obsahující název zadaného období.Returns the string containing the name of the specified era.

GetFormat(Type)

Vrátí objekt zadaného typu, který poskytuje službu formátování data a času.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetInstance(IFormatProvider)

Vrátí objekt přidružený k určenému IFormatProvider. DateTimeFormatInfoReturns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32)

Vrátí úplný název určený pro jazykovou verzi zadaného měsíce na základě jazykové verze přidružené k aktuálnímu DateTimeFormatInfo objektu.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek)

Získá nejkratší zkrácený název dne pro zadaný den v týdnu, který je přidružený k aktuálnímu DateTimeFormatInfo objektu.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
ReadOnly(DateTimeFormatInfo)

Vrátí obálku určenou jen DateTimeFormatInfo pro čtení.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char)

Nastaví vlastní řetězce formátu data a času, které odpovídají zadanému standardnímu formátovacímu řetězci.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Platí pro

Viz také