DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo Class

Definizione

Fornisce informazioni specifiche delle impostazioni cultura relative al formato dei valori di data e ora.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
Ereditarietà
DateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfo
Attributi
Implementazioni

Esempi

Nell'esempio seguente usa la reflection per ottenere le proprietà del DateTimeFormatInfo oggetto delle impostazioni cultura inglese (Stati Uniti).The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Visualizza il valore della proprietà che contengono stringhe di formato personalizzato e Usa tali stringhe per visualizzare le date formattate.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

Commenti

Le proprietà del DateTimeFormatInfo classe contengono informazioni specifiche delle impostazioni cultura per la formattazione o l'analisi dei valori di data e ora simile al seguente:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • I modelli usati per formattare i valori delle date.The patterns used to format date values.

  • I modelli usati per formattare i valori di ora.The patterns used to format time values.

  • I nomi dei giorni della settimana.The names of the days of the week.

  • I nomi dei mesi dell'anno.The names of the months of the year.

  • Il mattino.The A.M. A.M. /p.m.and P.M. identificatori usati nei valori di tempo.designators used in time values.

  • Calendario in cui le date sono espresse.The calendar in which dates are expressed.

Contenuto della sezione:In this section:

Creare un'istanza di un oggetto DateTimeFormatInfoInstantiating a DateTimeFormatInfo object

Oggetto DateTimeFormatInfo oggetto può rappresentare le convenzioni di formattazione delle impostazioni cultura invarianti, impostazioni cultura specifiche, alcune impostazioni cultura o le impostazioni cultura correnti.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. Questa sezione illustra come creare un'istanza di ogni tipo di DateTimeFormatInfo oggetto.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Creare un'istanza di un oggetto DateTimeFormatInfo per la lingua ingleseInstantiating a DateTimeFormatInfo object for the invariant culture

La lingua inglese rappresenta impostazioni cultura che è indipendente dalla lingua.The invariant culture represents a culture that is culture-insensitive. È basata sulla lingua inglese, ma non su qualsiasi specifico inglese paese.It is based on the English language, but not on any specific English-speaking country/region. Anche se i dati delle impostazioni cultura specifiche possono essere dinamici e possono cambiare in modo da riflettere le preferenze dell'utente o convenzioni culturali nuovo, non modifica i dati delle impostazioni cultura invarianti.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. È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione della cultura invariabile nei modi seguenti:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

L'esempio seguente usa ognuno di questi metodi per creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le impostazioni cultura invarianti.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Quindi, indica se l'oggetto è di sola lettura.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      

Creare un'istanza di un oggetto DateTimeFormatInfo per impostazioni cultura specificheInstantiating a DateTimeFormatInfo object for a specific culture

Impostazioni cultura specifiche rappresenta un linguaggio che è parlato in un determinato paese/area geografica.A specific culture represents a language that is spoken in a particular country/region. Ad esempio, en-US rappresenta impostazioni cultura specifiche che rappresenta la lingua inglese parlata negli Stati Uniti ed en-autorità di certificazione è delle impostazioni cultura specifiche che rappresenta la lingua inglese parlata in Canada.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. È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura specifiche nei modi seguenti:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

L'esempio seguente illustra ognuno di questi modi per creare un'istanza di un DateTimeFormatInfo dell'oggetto e indica se l'oggetto risultante è di sola lettura.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

Creare un'istanza di un oggetto DateTimeFormatInfo per alcune impostazioni culturaInstantiating a DateTimeFormatInfo object for a neutral culture

Alcune impostazioni cultura rappresenta delle impostazioni cultura o una lingua indipendente da un paese/area geografica; in genere è l'elemento padre di una o più impostazioni cultura specifiche.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. Fr è ad esempio, alcune impostazioni cultura per la lingua francese e l'elemento padre delle impostazioni cultura fr-FR.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura neutra nello stesso modo in cui si crea un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura specifiche.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. Inoltre, è possibile recuperare alcune impostazioni cultura DateTimeFormatInfo oggetto mediante il recupero di alcune impostazioni cultura da una lingua specifica CultureInfo.Parent proprietà e il recupero il DateTimeFormatInfo oggetto restituito dal relativo CultureInfo.DateTimeFormat proprietà.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. A meno che le impostazioni cultura padre rappresenta le impostazioni cultura invariabili, restituita DateTimeFormatInfo oggetto è di lettura/scrittura.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. L'esempio seguente illustra questi modi di un'istanza di un DateTimeFormatInfo oggetto che rappresenta una lingua neutra.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       

Nota

Nelle versioni di .NET Framework 1.0 tramite .NET Framework 3.5.NET Framework 3.5, il tentativo di recuperare una DateTimeFormatInfo genera un'eccezione che riflette le convenzioni di formattazione delle impostazioni cultura neutre un NotSupportedException eccezione.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.

Tuttavia, alcune impostazioni cultura non dispone di informazioni di formattazione specifiche delle impostazioni cultura, perché è indipendente da un paese/area geografica specifico.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. Invece di popolare il DateTimeFormatInfo dell'oggetto con valori di tipo generici, .NET Framework restituisce un DateTimeFormatInfo oggetto che riflette le convenzioni di formattazione di uno specifico delle impostazioni cultura che è un figlio di impostazioni cultura di sistema.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. Ad esempio, il DateTimeFormatInfo dell'oggetto per la lingua neutra en riflette le convenzioni di formattazione delle impostazioni cultura en-US e il DateTimeFormatInfo dell'oggetto per le impostazioni cultura fr riflettono le convenzioni di formattazione delle impostazioni cultura 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.

È possibile usare codice simile al seguente per determinare le convenzioni di formattazione che specifica impostazione cultura rappresenta impostazioni cultura neutre.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. L'esempio Usa la reflection per confrontare il DateTimeFormatInfo proprietà delle impostazioni cultura neutra con le proprietà delle impostazioni cultura figlio specifico.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Prende in considerazione due calendari essere equivalenti se fossero lo stesso tipo di calendario e, per gregoriano calendari, se i GregorianCalendar.CalendarType proprietà hanno valori identici.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
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

Creare un'istanza di un oggetto DateTimeFormatInfo per le impostazioni cultura correntiInstantiating a DateTimeFormatInfo object for the current culture

È possibile creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura correnti nei modi seguenti:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

L'esempio seguente usa ognuno di questi metodi per creare un'istanza di un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura correnti.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Quindi, indica se l'oggetto è di sola lettura.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

È possibile creare scrivibile DateTimeFormatInfo oggetto che rappresenta le convenzioni delle impostazioni cultura del thread corrente in uno dei modi seguenti:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

L'esempio seguente illustra ogni modo di un'istanza di lettura/scrittura DateTimeFormatInfo dell'oggetto e visualizza il valore della relativa IsReadOnly proprietà.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

In Windows, è possibile ignorare alcune delle DateTimeFormatInfo i valori delle proprietà utilizzati nella formattazione e l'analisi delle operazioni tramite il paese e lingua applicazioni nel Pannello di controllo.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. Ad esempio, un utente le cui impostazioni cultura è inglese (Stati Uniti) potrebbe scegliere di visualizzare lungo i valori di tempo usando un formato a 24 ore (nel formato hh: mm:) anziché l'impostazione predefinita a 12 ore (nel formato 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). Il DateTimeFormatInfo gli oggetti recuperati nei modi descritti in precedenza riflettono questi override dell'utente.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Se questo è opportuna, è possibile creare un NumberFormatInfo oggetto che non rifletta utente esegue l'override (e anche è lettura/scrittura anziché di sola lettura) chiamando il CultureInfo.CultureInfo(String, Boolean) costruttore e specificando un valore pari false per il useUserOverride argomento.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. L'esempio seguente illustra questo per un sistema con impostazioni cultura correnti sono inglese (Stati Uniti) e il cui modello molto tempo è stato modificato il valore predefinito h:mm: ss tt in HH: mm:.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 e dynamic dataDateTimeFormatInfo and dynamic data

I dati specifici delle impostazioni cultura per la formattazione di valori di data e ora forniti dal DateTimeFormatInfo classe è dinamica, esattamente come dati relative alle impostazioni cultura forniti dal CultureInfo classe.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. È consigliabile non apportare supposizioni sulla stabilità dei valori per DateTimeFormatInfo gli oggetti che sono associati con particolare CultureInfo oggetti.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Solo i dati forniti da a essa associati e le impostazioni cultura invarianti DateTimeFormatInfo oggetto è stabile.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Altri dati possono cambiare tra le sessioni dell'applicazione o addirittura mentre l'applicazione è in esecuzione.Other data can change between application sessions or even while your application is running. Sono disponibili quattro principali fonti di modifica:There are four major sources of change:

  • Aggiornamenti del sistema.System updates. Le preferenze culturali, ad esempio il calendario preferito o consueta formati data e ora cambiano nel tempo.Cultural preferences such as the preferred calendar or customary date and time formats change over time. In questo caso, Windows Update contiene modifiche al sistema il DateTimeFormatInfo valore della proprietà per una specifica impostazione cultura.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Impostazioni cultura sostitutive.Replacement cultures. Il CultureAndRegionInfoBuilder classe può essere utilizzata per sostituire i dati di una lingua esistente.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Le modifiche ai valori delle proprietà di propagazione.Cascading changes to property values. Un numero di proprietà relative alla lingua può cambiare in fase di esecuzione che, a sua volta, fa sì che DateTimeFormatInfo la modifica dei dati.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Le impostazioni cultura correnti, ad esempio, può essere modificata a livello di codice o tramite un'azione utente.For example, the current culture can be changed either programmatically or through user action. In questo caso, il DateTimeFormatInfo oggetto restituito dal CurrentInfo proprietà viene impostata su un oggetto associato a impostazioni cultura correnti.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. Allo stesso modo, può cambiare un calendario delle impostazioni cultura, ciò potrebbe comportare modifiche a numerose DateTimeFormatInfo i valori delle proprietà.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Preferenze dell'utente.User preferences. Gli utenti dell'applicazione potrebbero scegliere di eseguire l'override di alcuni dei valori associati con le impostazioni cultura correnti del sistema tramite le opzioni internazionali e della lingua nel Pannello di controllo.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. Ad esempio, gli utenti potrebbero scegliere di visualizzare la data in un formato diverso.For example, users might choose to display the date in a different format. Se il CultureInfo.UseUserOverride è impostata su true, le proprietà del DateTimeFormatInfo oggetto viene recuperato anche dalle impostazioni dell'utente.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Se le impostazioni utente non sono compatibili con le impostazioni cultura associate le CultureInfo oggetto (ad esempio, se il calendario selezionato non è uno dei calendari specificati dal OptionalCalendars proprietà), i risultati dei metodi e i valori delle proprietà non sono definiti.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.

Per ridurre al minimo la possibilità di dati incoerenti, tutte le proprietà sottoponibile a override dall'utente di un DateTimeFormatInfo oggetto vengono inizializzate quando viene creato l'oggetto.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. È ancora presente la possibilità di incoerenza, perché la creazione di oggetti, né il processo di sostituzione dell'utente è di tipo atomico e possono modificare i valori pertinenti durante la creazione di oggetti.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. Tuttavia, questa situazione sia estremamente rara.However, this situation should be extremely rare.

È possibile controllare se l'utente esegue l'override vengono riflesse nelle DateTimeFormatInfo gli oggetti che rappresentano le stesse impostazioni cultura come impostazioni cultura del sistema.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. La tabella seguente elenca i modi in cui un DateTimeFormatInfo oggetto possono essere recuperato e indica se l'oggetto risultante riflette l'override dell'utente.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Origine dell'oggetto CultureInfo e DateTimeFormatInfoSource of CultureInfo and DateTimeFormatInfo object Riflette l'override dell'utenteReflects user overrides
ProprietàCultureInfo.CurrentCulture.DateTimeFormat CultureInfo.CurrentCulture.DateTimeFormat property Yes
ProprietàDateTimeFormatInfo.CurrentInfo DateTimeFormatInfo.CurrentInfo property Yes
Metodo CultureInfo.CreateSpecificCultureCultureInfo.CreateSpecificCulture method Yes
Metodo CultureInfo.GetCultureInfoCultureInfo.GetCultureInfo method NoNo
Costruttore CultureInfo.CultureInfo(String)CultureInfo.CultureInfo(String) constructor Yes
Costruttore CultureInfo.CultureInfo(String, Boolean)CultureInfo.CultureInfo(String, Boolean) constructor Dipende dal valore di useUserOverride parametroDepends on value of useUserOverride parameter

A meno che non vi è un valido motivo per agire diversamente, è necessario rispettare le sostituzioni utente quando si usa il DateTimeFormatInfo oggetto nelle applicazioni client la formattazione e analisi dell'input utente o per visualizzare i dati.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. Per le applicazioni server o automatica, è consigliabile non.For server applications or unattended applications, you should not. Tuttavia, se si usa la DateTimeFormatInfo uno dell'oggetto in modo esplicito o implicito per rendere persistenti i dati di data e ora in formato stringa, è necessario utilizzare un DateTimeFormatInfo che riflette le convenzioni di formattazione delle impostazioni cultura invarianti, oppure è necessario specificare un stringa che utilizza indipendentemente dalle impostazioni cultura di formato data e ora personalizzato.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.

Formattazione di date e oreFormatting dates and times

Oggetto DateTimeFormatInfo oggetto viene usato in modo implicito o esplicito in tutte le date e le operazioni di formattazione dell'ora.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Sono incluse le chiamate ai metodi seguenti:These include calls to the following methods:

Usare tutti i data e ora effettuare operazioni di formattazione di un IFormatProvider implementazione.All date and time formatting operations make use of an IFormatProvider implementation. Il IFormatProvider interfaccia include un solo metodo, IFormatProvider.GetFormat(Type).The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Questo metodo di callback viene passato un Type oggetto che rappresenta il tipo necessario per fornire informazioni di formattazione.This callback method is passed a Type object that represents the type needed to provide formatting information. Il metodo restituisce un'istanza di quel tipo o null se non può fornire un'istanza del tipo.The method returns either an instance of that type or null if it cannot provide an instance of the type. .NET Framework include due IFormatProvider implementazioni per la formattazione di date e ore:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Se un' IFormatProvider implementazione non viene fornita a un metodo di formattazione in modo esplicito, il CultureInfo oggetto restituito dal CultureInfo.CurrentCulture proprietà che rappresenta le impostazioni cultura del thread corrente viene utilizzata.If 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.

Nell'esempio seguente viene illustrata la relazione tra il IFormatProvider interfaccia e DateTimeFormatInfo classe nelle operazioni di formattazione.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Definisce una classe personalizzata IFormatProvider implementazione cui GetFormat metodo visualizza il tipo di oggetto richiesto dall'operazione di formattazione.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. Se sta richiedendo un DateTimeFormatInfo dell'oggetto, il metodo fornisce il DateTimeFormatInfo oggetto per impostazioni cultura del thread corrente.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Come l'output illustrato nell'esempio, il Decimal.ToString(IFormatProvider) le richieste di metodo una DateTimeFormatInfo oggetto da fornire informazioni di formattazione, mentre le String.Format(IFormatProvider, String, Object[]) le richieste di metodo NumberFormatInfo e DateTimeFormatInfo oggetti, nonché un ICustomFormatter implementazione.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

Le stringhe di formato e le proprietà DateTimeFormatInfoFormat strings and DateTimeFormatInfo properties

Il DateTimeFormatInfo oggetto include tre tipi di proprietà che vengono usate nelle operazioni con valori di data e ora di formattazione:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

Il stringhe di formato di data e ora standard, ad esempio "d", "D", "f" e "F", sono alias che corrispondono a particolare DateTimeFormatInfo proprietà del modello di formato.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. La maggior parte delle stringhe di formato di data e ora personalizzato sono correlate a stringhe o le sottostringhe che un'operazione di formattazione inserisce nel flusso di risultati.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. Nella tabella seguente sono elencate la data standard e personalizzata e gli identificatori di formato di ora e i relativi DateTimeFormatInfo proprietà.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Per informazioni dettagliate su come usare questi identificatori di formato, vedere Standard Date and Time Format Strings e Custom Date and Time Format Strings.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Si noti che ogni stringa di formato standard corrisponde a un DateTimeFormatInfo proprietà il cui valore è una stringa di formato di ora e Data personalizzata.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Gli identificatori individuali in questa stringa di formato personalizzato è a sua volta corrispondano a altro DateTimeFormatInfo proprietà.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. Nella tabella sono elencate solo le DateTimeFormatInfo le proprietà per il quale le stringhe di formato standard sono alias e non non le proprietà di elenco che possono essere raggiunta tramite stringhe di formato personalizzate assegnate a tali proprietà con alias.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. Inoltre, la tabella elenca solo gli identificatori di formato personalizzate che corrispondono a DateTimeFormatInfo proprietà.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

Identificatore di formatoFormat specifier Proprietà associateAssociated properties
"d" (modello di data breve; stringa di formato standard)"d" (short date; standard format string) ShortDatePattern, per definire il formato complessivo della stringa di risultato.ShortDatePattern, to define the overall format of the result string.
"D" (data estesa; stringa di formato standard)"D" (long date; standard format string) LongDatePattern, per definire il formato complessivo della stringa di risultato.LongDatePattern, to define the overall format of the result string.
"f" (formato data / runtime; standard a breve stringa di formato)"f" (full date / short time; standard format string) LongDatePattern, per definire il formato del componente Data della stringa di risultato.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern, per definire il formato del componente ora della stringa di risultato.ShortTimePattern, to define the format of the time component of the result string.
"F" (formato data / lungo tempo; stringa di formato standard)"F" (full date / long time; standard format string) LongDatePattern, per definire il formato del componente Data della stringa di risultato.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern, per definire il formato del componente ora della stringa di risultato.LongTimePattern, to define the format of the time component of the result string.
"g" (generale data / ora breve; stringa di formato standard)"g" (general date / short time; standard format string) ShortDatePattern, per definire il formato del componente Data della stringa di risultato.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern, per definire il formato del componente ora della stringa di risultato.ShortTimePattern, to define the format of the time component of the result string.
"G" (Data generale / prolungata è runtime; standard stringa di formato)"G" (general date / long time; standard format string) ShortDatePattern, per definire il formato del componente Data della stringa di risultato.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern, per definire il formato del componente ora della stringa di risultato.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (mese/giorno; stringa di formato standard)"M", "m" (month/day; standard format string) MonthDayPattern, per definire il formato complessivo della stringa di risultato.MonthDayPattern, to define the overall format of the result string.
"O", "o" (eseguire il round trip data/ora; stringa di formato standard)"O", "o" (round-trip date/time; standard format string) Nessuno.None.
"R", "r" (RFC1123; stringa di formato standard)"R", "r" (RFC1123; standard format string) RFC1123Pattern, per definire una stringa di risultato conforme allo standard RFC 1123.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. La proprietà è in sola lettura.The property is read-only.
"s" (Data/ora ordinabile; stringa di formato standard)"s" (sortable date/time; standard format string) SortableDateTimePattern, per definire una stringa di risultato conforme allo standard ISO 8601.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. La proprietà è in sola lettura.The property is read-only.
"t" (ora breve; stringa di formato standard)"t" (short time; standard format string) ShortTimePattern, per definire il formato complessivo della stringa di risultato.ShortTimePattern, to define the overall format of the result string.
"T" (ora estesa; stringa di formato standard)"T" (long time; standard format string) LongTimePattern, per definire il formato complessivo della stringa di risultato.LongTimePattern, to define the overall format of the result string.
"u" (Data/ora ordinabile universale; stringa di formato standard)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, per definire una stringa di risultato conforme allo standard ISO 8601 di coordinated universal time.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. La proprietà è in sola lettura.The property is read-only.
"U" (Data/ora completa universale; stringa di formato standard)"U" (universal full date/time; standard format string) FullDateTimePattern, per definire il formato complessivo della stringa di risultato.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (mese e anno; stringa di formato standard)"Y", "y" (year month; standard format string) YearMonthPattern, per definire il formato complessivo della stringa di risultato.YearMonthPattern, to define the overall format of the result string.
"ddd" (identificatore di formato personalizzato)"ddd" (custom format specifier) AbbreviatedDayNames, per includere il nome abbreviato del giorno della settimana nella stringa di risultato.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "gg" (identificatore di formato personalizzato)"g", "gg" (custom format specifier) Le chiamate di GetEraName metodo per inserire il nome dell'era nella stringa di risultato.Calls the GetEraName method to insert the era name in the result string.
"MMM" (identificatore di formato personalizzato)"MMM" (custom format specifier) AbbreviatedMonthNames, per includere il nome del mese abbreviato nella stringa di risultato.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (identificatore di formato personalizzato)"MMMM" (custom format specifier) MonthNames o MonthGenitiveNames, includere il nome completo del mese nella stringa di risultato.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (identificatore di formato personalizzato)"t" (custom format specifier) AMDesignator o PMDesignator, includere il primo carattere dell'indicatore AM/PM nella stringa di risultato.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"tt" (identificatore di formato personalizzato)"tt" (custom format specifier) AMDesignator o PMDesignator, includere l'indicatore AM/PM completo nella stringa di risultato.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (identificatore di formato personalizzato)":" (custom format specifier) TimeSeparator, per includere il separatore dell'ora nella stringa di risultato.TimeSeparator, to include the time separator in the result string.
"/" (identificatore di formato personalizzato)"/" (custom format specifier) DateSeparator, per includere il separatore della data nella stringa di risultato.DateSeparator, to include the date separator in the result string.

Modifica delle proprietà DateTimeFormatInfoModifying DateTimeFormatInfo properties

È possibile modificare la stringa di risultato prodotta da stringhe di formato data e ora modificando le proprietà associate di scrivibile DateTimeFormatInfo oggetto.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. Per determinare se un DateTimeFormatInfo oggetto sia accessibile in scrittura, usare il IsReadOnly proprietà.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. Per personalizzare un DateTimeFormatInfo oggetto in questo modo:To customize a DateTimeFormatInfo object in this way:

  1. Creare una copia di lettura/scrittura di un DateTimeFormatInfo oggetto cui si desidera modificare le convenzioni di formattazione.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Vedere la un'istanza di un oggetto DateTimeFormatInfo sezione.)(See the Instantiating a DateTimeFormatInfo object section.)

  2. Modificare le proprietà che vengono utilizzati per produrre la stringa di risultato desiderato.Modify the property or properties that are used to produce the desired result string. (Per informazioni sull'uso dei metodi come formattazione DateTimeFormatInfo delle proprietà per definire le stringhe di risultato, vedere la sezione precedente stringhe di formato e le proprietà DateTimeFormatInfo.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Usare l'oggetto personalizzato DateTimeFormatInfo creato come oggetto di IFormatProvider argomenti nelle chiamate ai metodi di formattazione.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Esistono altri due modi per modificare il formato di una stringa di risultato:There are two other ways to change the format of a result string:

  • È possibile usare il CultureAndRegionInfoBuilder classe per definire le impostazioni cultura personalizzata (cultura di impostazioni cultura che ha un nome univoco e che lo integrano esistente) o impostazioni cultura di sostituzione (uno che viene usato invece di impostazioni cultura specifiche).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). È possibile salvare e accedere a queste impostazioni cultura a livello di codice come si farebbe con qualsiasi CultureInfo oggetto supportato da .NET Framework.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Se la stringa di risultato non distinzione delle impostazioni cultura e non segue un formato predefinito, è possibile usare una stringa di formato di ora e Data personalizzata.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. Ad esempio, se si sta serializzando dati data e ora nel formato aaaammgghhmmss, è possibile generare la stringa di risultato passando la stringa di formato personalizzato per il DateTime.ToString(String) metodo ed è possibile convertire la stringa di risultato a un DateTime valore chiamando il DateTime.ParseExact (metodo).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.

Modifica del modello di data breveChanging the short date pattern

Nell'esempio seguente modifica il formato di una stringa di risultato prodotta da stringa di formato standard "d" (Data breve).The following example changes the format of a result string produced by the "d" (short date) standard format string. Modifica l'oggetto associato ShortDatePattern proprietà per le impostazioni cultura inglese (Stati Uniti) dall'impostazione predefinita "G/aaaa" a en-US "yyyy'-" MM"-"dd"e Usa la stringa di formato standard"d"per visualizzare la data prima e dopo il ShortDatePattern proprietà è stato modificato.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

Modificare il separatore della dataChanging the date separator character

L'esempio seguente modifica il carattere separatore di data in un DateTimeFormatInfo oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura fr-FR.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. L'esempio Usa la stringa di formato standard "g" per visualizzare la data prima e dopo il DateSeparator proprietà viene modificata.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

Modifica delle abbreviazioni dei nomi di giorno e il modello di data estesaChanging day name abbreviations and the long date pattern

In alcuni casi, il modello di data estesa, che generalmente vengono visualizzati il giorno completo e nome del mese e il numero del giorno del mese e anno, potrebbe essere troppo lungo.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. Nell'esempio seguente consente di abbreviare il modello di data estesa per le impostazioni cultura en-US restituire un'abbreviazione nome giornata di uno o due caratteri seguiti dal numero di giorni, l'abbreviazione del nome mese e anno.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. A tale scopo, assegnare più breve abbreviazioni dei nomi di giorni per il AbbreviatedDayNames della matrice e da modificando la stringa di formato personalizzato assegnata per il LongDatePattern proprietà.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. Questo problema riguarda le stringhe di risultato restituite da "D" e stringhe di formato standard "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

In genere, la modifica per il LongDatePattern influisce anche sulla proprietà di FullDateTimePattern proprietà, che a sua volta definisce la stringa di risultato restituita dalla stringa di formato standard "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. Per conservare l'originale completo modello di data e ora, nell'esempio riassegna la stringa di formato personalizzato originale assegnata al FullDateTimePattern proprietà dopo il LongDatePattern proprietà viene modificata.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.

La modifica da un formato a 12 ore in un formato a 24 oreChanging from a 12-hour clock to a 24-hour clock

Per molte impostazioni cultura in .NET Framework, il tempo viene espresso utilizzando un formato a 12 ore e un indicatore AM/PM.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. L'esempio seguente definisce un ReplaceWith24HourClock metodo che sostituisce qualsiasi formato di ora che usa un formato a 12 ore con un formato che usa un formato a 24 ore.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

L'esempio Usa un'espressione regolare per modificare la stringa di formato.The example uses a regular expression to modify the format string. Criterio di espressione regolare @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) viene definito come segue:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

ModelloPattern DescrizioneDescription
^ Inizia la ricerca della corrispondenza all'inizio della stringa.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Occorrenza di corrispondenza zero o uno di zero o più spazi caratteri, seguita dalla lettera "t" uno o più volte seguiti da zero o più caratteri spazio vuoto.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. Questo gruppo di acquisizione viene denominato openAMPM.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Se il openAMPM gruppo abbia una corrispondenza, la lettera "h" uno o più corrispondenze, seguita da uno o più caratteri che non sono "h" o "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". La corrispondenza termina alla fine della stringa.The match ends at the end of the string. Tutti i caratteri acquisiti al termine di "h" sono incluse in un gruppo di acquisizione denominato nonHours.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Se il openAMPM gruppo non esiste una corrispondenza, far corrispondere la lettera "h" una o più volte, seguite da uno o più caratteri che non sono "h" o "t", seguito da zero o più caratteri spazio vuoto.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. Infine, corrisponde a uno o più occorrenze della lettera "t".Finally, match one or more occurrences of the letter "t". Tutti i caratteri acquisiti dopo "h" e prima di spazi vuoti e "t" sono incluse in un gruppo di acquisizione denominato nonHours.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

Il nonHours gruppo di acquisizione contiene al minuto ed eventualmente il secondo componente di una data personalizzata e una stringa di formato di ora, insieme con qualsiasi simbolo di separatore di ora.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. Il criterio di sostituzione HH${nonHours} antepone la sottostringa "HH" a questi elementi.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Visualizzazione e modifica l'era in una dataDisplaying and changing the era in a date

L'esempio seguente aggiunge l'identificatore di formato personalizzato "g" per il LongDatePattern proprietà di un oggetto che rappresenta le convenzioni di formattazione delle impostazioni cultura 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. Questa aggiunta interessa le tre stringhe di formato standard seguenti:This addition affects the following three standard format strings:

  • La stringa di formato standard "D" (data estesa), che esegue il mapping direttamente al LongDatePattern proprietà.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • "f" (formato data / breve tempo) stringa di formato standard, che produce una stringa che concatena le sottostringhe prodotte dal LongDatePattern e ShortTimePattern proprietà.The "f" (full date / short time) standard format string, which produces a result string that concatenates the substrings produced by the LongDatePattern and ShortTimePattern properties.

  • "F" (formato data / ora estesa) stringa di formato standard, che esegue il mapping direttamente al FullDateTimePattern proprietà.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Perché non è stato impostato in modo esplicito il valore della proprietà, viene generato in modo dinamico tramite la concatenazione di LongDatePattern e LongTimePattern proprietà.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

Nell'esempio viene inoltre illustrato come modificare il nome dell'era per una lingua il cui calendario ha una sola era.The example also shows how to change the era name for a culture whose calendar has a single era. In questo caso, le impostazioni cultura en-US utilizzano il calendario gregoriano, che è rappresentato da un GregorianCalendar oggetto.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. Il GregorianCalendar classe supporta una sola era, denomina D.C.The GregorianCalendar class supports a single era, which it names A.D. (Cristiana di).(Anno Domini). Nell'esempio viene modificato il nome dell'era a E.V.The example changes the era name to C.E. (DC Era) sostituendo l'identificatore di formato personalizzato "g" nella stringa di formato assegnata per il FullDateTimePattern proprietà con una valore letterale stringa.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. L'uso di una stringa letterale è necessario, poiché è in genere restituisce il nome dell'era la GetEraName metodo dai dati privati nelle tabelle delle impostazioni cultura fornite da .NET Framework o del sistema operativo 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

Analisi di stringhe di data e oraParsing date and time strings

L'analisi consente di convertire la rappresentazione di stringa di data e ora per un DateTime o DateTimeOffset valore.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Entrambi questi tipi includono il Parse, TryParse, ParseExact, e TryParseExact metodi per supportare le operazioni di analisi.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Il Parse e TryParse metodi consentono di convertire una stringa che può avere un'ampia gamma di formati, mentre ParseExact e TryParseExact è necessaria la stringa di un formato definito o formati.The 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. Se l'operazione di analisi ha esito negativo, Parse e ParseExact genera un'eccezione, mentre TryParse e TryParseExact restituiscono false.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Usano i metodi di analisi in modo implicito o esplicito un DateTimeStyles valore di enumerazione per determinare quali elementi di stile (ad esempio spazi vuoti iniziali, finali o interno) può essere presenti nella stringa da analizzare e come interpretare la stringa analizzata o qualsiasi mancante elementi.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. Se non si specifica un DateTimeStyles valore quando si chiama il Parse oppure TryParse metodo, il valore predefinito è DateTimeStyles.AllowWhiteSpaces, che è uno stile composito che include il DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite, e DateTimeStyles.AllowInnerWhite flag.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. Per il ParseExact e TryParseExact metodi, il valore predefinito è DateTimeStyles.None; la stringa di input deve corrispondere esattamente a una determinata data e ora di stringa di formato personalizzato.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.

Usano i metodi di analisi anche in modo implicito o esplicito un DateTimeFormatInfo oggetto che definisce i simboli specifici e pattern che può verificarsi nella stringa da analizzare.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. Se non si specifica un DateTimeFormatInfo oggetti, il DateTimeFormatInfo per impostazioni cultura del thread corrente verrà usata per impostazione predefinita dell'oggetto.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Per altre informazioni sull'analisi di stringhe di data e ora, vedere i singoli metodi di analisi, ad esempio DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact, e 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.

L'esempio seguente illustra la natura di distinzione delle impostazioni cultura di analisi stringhe di data e ora.The following example illustrates the culture-sensitive nature of parsing date and time strings. Prova a analizzare due stringhe di data usando le convenzioni del en-US, en-GB, fr-FR e le impostazioni cultura 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. La data in cui viene interpretata come 8 fino al 18 maggio 2014 in en-US culture genera un FormatException eccezione altri tre impostazioni cultura in quanto 18 viene interpretato come numero del mese.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 o 2015 viene analizzato come il secondo giorno del mese prima le impostazioni cultura en-US, ma come primo giorno del mese secondo le impostazioni cultura rimanenti.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

Le stringhe di data e ora in genere vengono analizzate per due motivi:Date and time strings are typically parsed for two reasons:

  • Per convertire l'input dell'utente in un valore di data e ora.To convert user input into a date and time value.

  • Eseguire il round trip di un valore di data e ora; vale a dire, per deserializzare un valore di data e ora che in precedenza è stato serializzato come stringa.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

Le sezioni seguenti illustrano queste due operazioni in modo più dettagliato.The following sections discuss these two operations in greater detail.

Analisi di stringhe utenteParsing user strings

Quando si analizza le stringhe di data e ora di input dall'utente, è consigliabile creare sempre un DateTimeFormatInfo che riflette le impostazioni relative alla lingua dell'utente, incluse tutte le personalizzazioni apportate all'utente.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. In caso contrario, l'oggetto di data e ora può avere valori non corretti.Otherwise, the date and time object may have incorrect values. Per informazioni su come creare un'istanza di un DateTimeFormatInfo oggetto che rifletta le personalizzazioni relative alla lingua dell'utente, vedere la DateTimeFormatInfo e dynamic data sezione.For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

Nell'esempio seguente viene illustrata la differenza tra un'operazione di analisi che riflette le impostazioni relative alle impostazioni cultura utente e una che non sono presenti.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. In questo caso, la lingua del sistema predefinito è en-US, ma l'utente ha usato Pannello di controllo paese e lingua per modificare il modello di data breve da quello predefinito di "G/aaaa" a "AA/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". Quando l'utente immette una stringa che riflette le impostazioni utente e la stringa viene analizzata da un DateTimeFormatInfo che riflette le impostazioni dell'utente (sostituzioni), l'operazione di analisi restituisce un risultato corretto.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. Tuttavia, quando la stringa viene analizzata da un DateTimeFormatInfo oggetto che riflette le impostazioni cultura en-US standard, il metodo genera di analisi una FormatException eccezione poiché interpreta 14 come il numero del mese, non le ultime due cifre dell'anno.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

La serializzazione e deserializzazione dei dati di data e oraSerializing and deserializing date and time data

Serializzare i dati di data e ora devono eseguire il round trip; vale a dire tutti serializzati e deserializzati valori devono essere identici.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Se un valore di data e ora rappresenta un singolo momento, il valore deserializzato deve rappresentare lo stesso momento nel tempo indipendentemente dal fuso orario del sistema in cui è stato ripristinato o delle impostazioni cultura.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. Per eseguire il round trip a data e ora correttamente, è necessario usare le convenzioni delle impostazioni cultura invariabili, che viene restituito dal InvariantInfo proprietà, per generare e analizzare i dati.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. Le operazioni di formattazione e analisi non dovrebbero mai riflettono le convenzioni delle impostazioni cultura predefinite.The formatting and parsing operations should never reflect the conventions of the default culture. Se si usano le impostazioni relative alle impostazioni cultura predefinite, la portabilità dei dati è limitata esclusivamente; può essere deserializzato solo su un thread le cui impostazioni cultura specifiche sono identiche a quelle del thread in cui è stato serializzato.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. In alcuni casi, ciò significa che i dati non possono anche essere correttamente serializzati e deserializzati nello stesso sistema.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Se il componente della fase di un valore di data e ora è significativo, deve anche essere convertito nell'ora UTC e serializzato utilizzando la "o" o "r" stringa di formato standard.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. I dati ora possono essere ripristinati chiamando un metodo di analisi e passandolo della stringa formato appropriato con le impostazioni cultura invarianti come il provider argomento.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.

Nell'esempio seguente illustra il processo di un valore di data e ora round trip.The following example illustrates the process of round-tripping a date and time value. Serializzazione di una data e ora in un sistema che osserva degli Stati Uniti Fuso orario del Pacifico e le cui impostazioni cultura corrente sono 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)

Deserializza i dati in un sistema nel fuso orario di Bruxelles, Copenaghen, Madrid e Parigi e il cui correnti sono impostazioni cultura 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. La data ripristinata è nove ore avanti rispetto alla data originale, che riflette la regolazione del fuso orario da otto ore rispetto all'ora UTC su un'ora avanti rispetto a 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. Data originale e la data ripristinata rappresentano entrambi nello stesso momento nel tempo.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

Costruttori

DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo() DateTimeFormatInfo()

Inizializza una nuova istanza modificabile della classe DateTimeFormatInfo che è indipendente dalle impostazioni cultura associate alla lingua inglese.Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Proprietà

AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames

Ottiene o imposta una matrice unidimensionale di tipo String contenente i nomi abbreviati dei giorni della settimana specifici delle impostazioni cultura.Gets or sets a one-dimensional array of type String containing the culture-specific abbreviated names of the days of the week.

AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames AbbreviatedMonthGenitiveNames

Ottiene o imposta una matrice di stringhe di nomi abbreviati dei mesi associati all'oggetto DateTimeFormatInfo corrente.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames

Ottiene o imposta una matrice di stringhe unidimensionale contenente i nomi abbreviati dei mesi specifici delle impostazioni cultura.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator AMDesignator AMDesignator AMDesignator

Ottiene o imposta l'indicatore di stringa per le ore "ante meridiem" (prima di mezzogiorno).Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar Calendar Calendar Calendar

Ottiene o imposta il calendario da utilizzare per le impostazioni cultura correnti.Gets or sets the calendar to use for the current culture.

CalendarWeekRule CalendarWeekRule CalendarWeekRule CalendarWeekRule

Ottiene o imposta un valore che specifica la regola utilizzata per determinare la prima settimana di calendario dell'anno.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Ottiene un oggetto DateTimeFormatInfo di sola lettura che formatta i valori in base alle impostazioni cultura correnti.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator DateSeparator DateSeparator DateSeparator

Ottiene o imposta la stringa che separa i componenti di una data, ovvero l'anno, il mese e il giorno.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames DayNames DayNames DayNames

Ottiene o imposta una matrice di stringa unidimensionale contenente i nomi estesi dei giorni della settimana specifici delle impostazioni cultura.Gets or sets a one-dimensional string array that contains the culture-specific full names of the days of the week.

FirstDayOfWeek FirstDayOfWeek FirstDayOfWeek FirstDayOfWeek

Ottiene o imposta il primo giorno della settimana.Gets or sets the first day of the week.

FullDateTimePattern FullDateTimePattern FullDateTimePattern FullDateTimePattern

Ottiene o imposta la stringa di formato personalizzata per un valore di data e ora estese.Gets or sets the custom format string for a long date and long time value.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Ottiene l'oggetto DateTimeFormatInfo predefinito in sola lettura indipendente dalle impostazioni cultura associate alla lingua inglese.Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ottiene un valore che indica se l'oggetto DateTimeFormatInfo è in sola lettura.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern LongDatePattern LongDatePattern LongDatePattern

Ottiene o imposta la stringa di formato personalizzata per un valore di data estesa.Gets or sets the custom format string for a long date value.

LongTimePattern LongTimePattern LongTimePattern LongTimePattern

Ottiene o imposta la stringa di formato personalizzata per un valore di ora estesa.Gets or sets the custom format string for a long time value.

MonthDayPattern MonthDayPattern MonthDayPattern MonthDayPattern

Ottiene o imposta la stringa di formato personalizzata per un valore di mese e giorno.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames

Ottiene o imposta una matrice di stringhe di nomi di mesi associata all'oggetto DateTimeFormatInfo corrente.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames MonthNames MonthNames MonthNames

Ottiene o imposta una matrice unidimensionale di tipo String contenente i nomi estesi dei mesi specifici delle impostazioni cultura.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName NativeCalendarName NativeCalendarName NativeCalendarName

Ottiene il nome nativo del calendario associato all'oggetto DateTimeFormatInfo corrente.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator PMDesignator PMDesignator PMDesignator

Ottiene o imposta l'indicatore di stringa per le ore "post meridiem" (dopo mezzogiorno).Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern RFC1123Pattern RFC1123Pattern RFC1123Pattern

Ottiene la stringa di formato personalizzata per un valore di data e ora basato sulla specifica IETF (Internet Engineering Task Force) RFC (Request for Comments) 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 ShortDatePattern ShortDatePattern ShortDatePattern

Ottiene o imposta la stringa di formato personalizzata per un valore di data breve.Gets or sets the custom format string for a short date value.

ShortestDayNames ShortestDayNames ShortestDayNames ShortestDayNames

Ottiene o imposta una matrice di stringhe dei nomi univoci dei giorni abbreviati più corti associati all'oggetto DateTimeFormatInfo corrente.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern ShortTimePattern ShortTimePattern ShortTimePattern

Ottiene o imposta la stringa di formato personalizzata per un valore di ora breve.Gets or sets the custom format string for a short time value.

SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern

Ottiene la stringa di formato personalizzata per un valore ordinabile di data e ora.Gets the custom format string for a sortable date and time value.

TimeSeparator TimeSeparator TimeSeparator TimeSeparator

Ottiene o imposta la stringa che separa i componenti dell'ora, ovvero l'ora, i minuti e i secondi.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern

Ottiene la stringa di formato personalizzato per una stringa di data e ora ordinabile e universale, come definito da ISO 8601.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern YearMonthPattern YearMonthPattern YearMonthPattern

Ottiene o imposta la stringa di formato personalizzata per un valore di anno e mese.Gets or sets the custom format string for a year and month value.

Metodi

Clone() Clone() Clone() Clone()

Crea una copia superficiale di DateTimeFormatInfo.Creates a shallow copy of the DateTimeFormatInfo.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek) GetAbbreviatedDayName(DayOfWeek)

Restituisce il nome abbreviato specifico delle impostazioni cultura del giorno della settimana specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente.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) GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32) GetAbbreviatedEraName(Int32)

Restituisce la stringa contenente il nome abbreviato dell'era specificata, a condizione che esista un'abbreviazione.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32) GetAbbreviatedMonthName(Int32)

Restituisce il nome abbreviato specifico delle impostazioni cultura del mese specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetAllDateTimePatterns() GetAllDateTimePatterns() GetAllDateTimePatterns() GetAllDateTimePatterns()

Restituisce tutti i modelli standard nei quali possono essere formattati i valori di data e ora.Returns all the standard patterns in which date and time values can be formatted.

GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char) GetAllDateTimePatterns(Char)

Restituisce tutti i modelli standard nei quali possono essere formattati i valori di data e ora mediante la stringa di formato standard specificato.Returns all the patterns in which date and time values can be formatted using the specified standard format string.

GetDayName(DayOfWeek) GetDayName(DayOfWeek) GetDayName(DayOfWeek) GetDayName(DayOfWeek)

Restituisce il nome completo specifico delle impostazioni cultura del giorno della settimana specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente.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) GetEra(String) GetEra(String) GetEra(String)

Restituisce l'intero che rappresenta l'era specificata.Returns the integer representing the specified era.

GetEraName(Int32) GetEraName(Int32) GetEraName(Int32) GetEraName(Int32)

Restituisce la stringa contenente il nome dell'era specificata.Returns the string containing the name of the specified era.

GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Restituisce un oggetto del tipo specificato che fornisce un servizio di formattazione data e ora.Returns an object of the specified type that provides a date and time formatting service.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider)

Restituisce l'oggetto DateTimeFormatInfo associato all'oggetto IFormatProvider specificato.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

GetMonthName(Int32) GetMonthName(Int32) GetMonthName(Int32) GetMonthName(Int32)

Restituisce il nome completo specifico delle impostazioni cultura del mese specificato in base alle impostazioni cultura associate all'oggetto DateTimeFormatInfo corrente.Returns the culture-specific full name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek) GetShortestDayName(DayOfWeek)

Ottiene il nome del giorno abbreviato più corto per un giorno della settimana specificato associato all'oggetto DateTimeFormatInfo corrente.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo) ReadOnly(DateTimeFormatInfo)

Restituisce un wrapper DateTimeFormatInfo di sola lettura.Returns a read-only DateTimeFormatInfo wrapper.

SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char) SetAllDateTimePatterns(String[], Char)

Imposta le stringhe di formato di data e ora che corrispondono a una stringa di formato standard specificata.Sets the custom date and time format strings that correspond to a specified standard format string.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Implementazioni dell'interfaccia esplicita

ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Si applica a

Vedi anche