DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo DateTimeFormatInfo Class

Definition

Stellt kulturabhängige Informationen zum Format von Datum und Zeitangaben bereit.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
Vererbung
DateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfoDateTimeFormatInfo
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird die Reflektion verwendet, um die DateTimeFormatInfo Eigenschaften des-Objekts für die Kultur Englisch (USA) zu erhalten.The following example uses reflection to get the properties of the DateTimeFormatInfo object for the English (United States) culture. Es zeigt den Wert dieser Eigenschaften an, die benutzerdefinierte Format Zeichenfolgen enthalten, und verwendet diese Zeichen folgen zum Anzeigen formatierter Datumsangaben.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

Hinweise

Die Eigenschaften DateTimeFormatInfo der-Klasse enthalten kulturspezifische Informationen zum Formatieren oder zum Formatieren von Datums-und Uhrzeitwerten wie den folgenden:The properties of the DateTimeFormatInfo class contain culture-specific information for formatting or parsing date and time values such as the following:

  • Die Muster zum Formatieren von Datums Werten.The patterns used to format date values.

  • Die zum Formatieren von Zeitwerten verwendeten Muster.The patterns used to format time values.

  • Die Namen der Wochentage.The names of the days of the week.

  • Die Namen der Monate des Jahrs.The names of the months of the year.

  • Der UhrThe A.M. und PMand P.M. in Zeitwerten verwendete Kenn Zeichner.designators used in time values.

  • Der Kalender, in dem Datumsangaben ausgedrückt werden.The calendar in which dates are expressed.

In diesem AbschnittIn this section:

Instanziieren eines DateTimeFormatInfo-ObjektsInstantiating a DateTimeFormatInfo object

Ein DateTimeFormatInfo -Objekt kann die Formatierungs Konventionen der invarianten Kultur, einer bestimmten Kultur, einer neutralen Kultur oder der aktuellen Kultur darstellen.A DateTimeFormatInfo object can represent the formatting conventions of the invariant culture, a specific culture, a neutral culture, or the current culture. In diesem Abschnitt wird erläutert, wie jeder DateTimeFormatInfo Objekttyp instanziiert wird.This section discusses how to instantiate each type of DateTimeFormatInfo object.

Instanziieren eines DateTimeFormatInfo-Objekts für die invariante KulturInstantiating a DateTimeFormatInfo object for the invariant culture

Die invariante Kultur stellt eine Kultur dar, die Kultur unabhängig ist.The invariant culture represents a culture that is culture-insensitive. Es basiert auf der englischen Sprache, aber nicht auf einem bestimmten englischsprachigen Land/einer bestimmten Region.It is based on the English language, but not on any specific English-speaking country/region. Obwohl die Daten bestimmter Kulturen dynamisch sein können und sich ändern können, um neue Kultur Konventionen oder Benutzereinstellungen widerzuspiegeln, ändern sich die Daten der invarianten Kultur nicht.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. Sie können ein DateTimeFormatInfo -Objekt, das die Formatierungs Konventionen der invarianten Kultur darstellt, auf folgende Weise instanziieren:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Im folgenden Beispiel wird jede dieser Methoden verwendet, um ein DateTimeFormatInfo -Objekt zu instanziieren, das die invariante Kultur darstellt.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the invariant culture. Anschließend gibt es an, ob das Objekt schreibgeschützt ist.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      

Instanziieren eines DateTimeFormatInfo-Objekts für eine bestimmte KulturInstantiating a DateTimeFormatInfo object for a specific culture

Eine bestimmte Kultur stellt eine Sprache dar, die in einem bestimmten Land oder einer bestimmten Region gesprochen wird.A specific culture represents a language that is spoken in a particular country/region. Beispielsweise ist "en-US" eine bestimmte Kultur, die die in der USA gesprochene Englische Sprache darstellt, und "en-ca" ist eine bestimmte Kultur, die die in Kanada gesprochene Englische Sprache darstellt.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. Sie können ein DateTimeFormatInfo -Objekt, das die Formatierungs Konventionen einer bestimmten Kultur darstellt, auf folgende Weise instanziieren:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Das folgende Beispiel veranschaulicht jede dieser Möglichkeiten zum Instanziieren eines DateTimeFormatInfo -Objekts und gibt an, ob das resultierende-Objekt schreibgeschützt ist.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

Instanziieren eines DateTimeFormatInfo-Objekts für eine neutrale KulturInstantiating a DateTimeFormatInfo object for a neutral culture

Eine neutrale Kultur stellt eine Kultur oder Sprache dar, die unabhängig von einem Land bzw. einer Region ist. Es ist in der Regel das übergeordnete Element einer oder mehrerer spezifischer Kulturen.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. Beispielsweise ist fr eine neutrale Kultur für die französische Sprache und das übergeordnete Element der fr-FR-Kultur.For example, Fr is a neutral culture for the French language and the parent of the fr-FR culture. Sie können ein DateTimeFormatInfo -Objekt, das die Formatierungs Konventionen einer neutralen Kultur darstellt, auf die gleiche Weise instanziieren, DateTimeFormatInfo wie Sie ein-Objekt erstellen, das die Formatierungs Konventionen einer bestimmten Kultur darstellt.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. Darüber hinaus können Sie das-Objekt einer neutralen Kultur DateTimeFormatInfo abrufen, indem Sie eine neutrale Kultur aus der-Eigenschaft einer bestimmten Kultur abrufen und das DateTimeFormatInfo -Objekt abrufen, CultureInfo.DateTimeFormat das von der- CultureInfo.Parent Eigenschaft zurückgegeben wird.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. Wenn die übergeordnete Kultur nicht die invariante Kultur darstellt, DateTimeFormatInfo ist das zurückgegebene Objekt Lese-/Schreibzugriff.Unless the parent culture represents the invariant culture, the returned DateTimeFormatInfo object is read/write. Im folgenden Beispiel werden diese Methoden zum Instanziieren eines DateTimeFormatInfo -Objekts veranschaulicht, das eine neutrale Kultur darstellt.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       

Hinweis

In den .NET Framework Versionen 1,0 bis .NET Framework 3,5.NET Framework 3.5wird beim Versuch, ein DateTimeFormatInfo -Objekt abzurufen, das die Formatierungs Konventionen einer neutralen Kultur NotSupportedException widerspiegelt, eine-Ausnahme ausgelöst.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.

Bei einer neutralen Kultur gibt es jedoch keine kulturspezifischen Formatierungsinformationen, da Sie von einem bestimmten Land/einer bestimmten Region unabhängig ist.However, a neutral culture lacks culture-specific formatting information, because it is independent of a specific country/region. Anstatt das DateTimeFormatInfo Objekt mit generischen Werten aufzufüllen, gibt die .NET Framework ein DateTimeFormatInfo -Objekt zurück, das die Formatierungs Konventionen einer bestimmten Kultur widerspiegelt, die der neutralen Kultur untergeordnet ist.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. Beispielsweise reflektiert das DateTimeFormatInfo -Objekt für die neutrale Kultur "en-US" die Formatierungs Konventionen der Kultur "en DateTimeFormatInfo -US", und das-Objekt für die FR-Kultur reflektiert die Formatierungs Konventionen der Kultur "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.

Sie können Code wie den folgenden verwenden, um zu bestimmen, welche Formatierungs Konventionen der jeweiligen Kultur eine neutrale Kultur darstellt.You can use code like the following to determine which specific culture's formatting conventions a neutral culture represents. Das Beispiel verwendet Reflektion, um DateTimeFormatInfo die Eigenschaften einer neutralen Kultur mit den Eigenschaften einer bestimmten untergeordneten Kultur zu vergleichen.The example uses reflection to compare the DateTimeFormatInfo properties of a neutral culture with the properties of a specific child culture. Dabei werden zwei Kalender als gleichwertig betrachtet, wenn Sie denselben Kalendertyp aufweisen, und bei Gregorianischen Kalendern GregorianCalendar.CalendarType , wenn deren Eigenschaften identische Werte aufweisen.It considers two calendars to be equivalent if they are the same calendar type and, for Gregorian calendars, if their GregorianCalendar.CalendarType properties have identical values.

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

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

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

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

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

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

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

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

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

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

Instanziieren eines DateTimeFormatInfo-Objekts für die aktuelle KulturInstantiating a DateTimeFormatInfo object for the current culture

Sie können ein DateTimeFormatInfo -Objekt, das die Formatierungs Konventionen der aktuellen Kultur darstellt, auf folgende Weise instanziieren:You can instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture in the following ways:

Im folgenden Beispiel wird jede dieser Methoden verwendet, um ein DateTimeFormatInfo -Objekt zu instanziieren, das die Formatierungs Konventionen der aktuellen Kultur darstellt.The following example uses each of these methods to instantiate a DateTimeFormatInfo object that represents the formatting conventions of the current culture. Anschließend gibt es an, ob das Objekt schreibgeschützt ist.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

Sie können ein beschreibbares DateTimeFormatInfo Objekt, das die Konventionen der aktuellen Thread Kultur darstellt, auf eine der folgenden Weisen erstellen:You can create a writable DateTimeFormatInfo object that represents the conventions of the current thread culture in one of these ways:

Das folgende Beispiel veranschaulicht jede Methode zum Instanziieren eines Lese-/Schreibobjekts DateTimeFormatInfo und zeigt den Wert seiner IsReadOnly -Eigenschaft an.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 kann der Benutzer einige DateTimeFormatInfo der Eigenschaftswerte, die bei Formatierungs-und Verarbeitungsvorgängen verwendet werden, über die Regions-und sprach Anwendung in der Systemsteuerung überschreiben.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. Ein Benutzer, dessen Kultur Englisch (USA) ist, kann z. b. die Verwendung eines 24-Stunden-Tags (im Format hh: mm: SS) anstelle der standardmäßigen 12-Stunden-Uhrzeit (im Format h:mm: SS TT) zum Anzeigen von langen Zeitwerten wählen.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). Die DateTimeFormatInfo Objekte, die in den zuvor erläuterten Methoden abgerufen wurden, spiegeln diese Benutzer Überschreibungen wider.The DateTimeFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Wenn dies nicht erwünscht ist, können Sie ein NumberFormatInfo false -Objekt erstellen, das keine Benutzer Überschreibungen widerspiegelt (und auch Lese-/Schreibzugriff anstelle von schreibgeschützt CultureInfo.CultureInfo(String, Boolean) ist), indem Sie den-Konstruktor useUserOverride aufrufen und den Wert für das-Argument angeben.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. Das folgende Beispiel veranschaulicht dies für ein System, dessen aktuelle Kultur Englisch (USA) und dessen langes Muster von der Standardeinstellung h:mm: ss tt in hh: mm: SS geändert wurde.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 und Dynamic DataDateTimeFormatInfo and dynamic data

Die kulturspezifischen Daten zum Formatieren von Datums-und Uhrzeitwerten DateTimeFormatInfo , die von der-Klasse bereitgestellt werden, sind CultureInfo dynamisch, wie von der-Klasse bereitgestellte Kultur DatenThe 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. Sie sollten keine Annahmen über die Stabilität von Werten für DateTimeFormatInfo Objekte treffen, die bestimmten CultureInfo Objekten zugeordnet sind.You should not make any assumptions about the stability of values for DateTimeFormatInfo objects that are associated with particular CultureInfo objects. Nur die Daten, die von der invarianten Kultur und dem DateTimeFormatInfo zugeordneten-Objekt bereitgestellt werden, sind stabil.Only the data provided by the invariant culture and its associated DateTimeFormatInfo object is stable. Andere Daten können sich zwischen Anwendungs Sitzungen oder sogar während der Ausführung der Anwendung ändern.Other data can change between application sessions or even while your application is running. Es gibt vier wichtige Änderungs Quellen:There are four major sources of change:

  • System Updates.System updates. Kulturelle Einstellungen wie der bevorzugte Kalender oder die üblichen Datums-und Uhrzeit Formate ändern sich im Laufe der Zeit.Cultural preferences such as the preferred calendar or customary date and time formats change over time. In diesem Fall enthält Windows Update Änderungen am DateTimeFormatInfo Eigenschafts Wert für eine bestimmte Kultur.When this happens, Windows Update includes changes to the DateTimeFormatInfo property value for a particular culture.

  • Ersetzungs Kulturen.Replacement cultures. Die CultureAndRegionInfoBuilder -Klasse kann verwendet werden, um die Daten einer vorhandenen Kultur zu ersetzen.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Kaskadierende Änderungen an Eigenschafts Werten.Cascading changes to property values. Eine Reihe von kulturbezogenen Eigenschaften kann zur Laufzeit geändert werden, was wiederum bewirkt DateTimeFormatInfo , dass sich die Daten ändern.A number of culture-related properties can change at run time, which, in turn, causes DateTimeFormatInfo data to change. Beispielsweise kann die aktuelle Kultur entweder Programm gesteuert oder durch eine Benutzeraktion geändert werden.For example, the current culture can be changed either programmatically or through user action. In diesem Fall ändert sich DateTimeFormatInfo das von der CurrentInfo -Eigenschaft zurückgegebene-Objekt in ein-Objekt, das der aktuellen Kultur zugeordnet ist.When this happens, the DateTimeFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture. Ebenso kann der Kalender einer Kultur geändert werden, was zu Änderungen an zahlreichen DateTimeFormatInfo Eigenschafts Werten führen kann.Similarly, a culture's calendar can change, which can result in changes to numerous DateTimeFormatInfo property values.

  • Benutzereinstellungen.User preferences. Benutzer Ihrer Anwendung können mithilfe der Regions-und Sprachoptionen in der Systemsteuerung einige der Werte überschreiben, die mit der aktuellen System Kultur verknüpft sind.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. Beispielsweise können Benutzer das Datum in einem anderen Format anzeigen.For example, users might choose to display the date in a different format. Wenn die CultureInfo.UseUserOverride -Eigenschaft auf truefestgelegt ist DateTimeFormatInfo , werden die Eigenschaften des-Objekts auch aus den Benutzereinstellungen abgerufen.If the CultureInfo.UseUserOverride property is set to true, the properties of the DateTimeFormatInfo object is also retrieved from the user settings. Wenn die Benutzereinstellungen mit der Kultur, die dem CultureInfo Objekt zugeordnet ist, nicht kompatibel sind (wenn der ausgewählte Kalender z. b. keiner der Kalender ist, der durch die OptionalCalendars -Eigenschaft angegeben ist), werden die Ergebnisse der Methoden und die Werte der Eigenschaften sind nicht definiert.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.

Um die Möglichkeit inkonsistenter Daten zu minimieren, werden alle vom Benutzer DateTimeFormatInfo über schreibbaren Eigenschaften eines-Objekts initialisiert, wenn das Objekt erstellt wird.To minimize the possibility of inconsistent data, all user-overridable properties of a DateTimeFormatInfo object are initialized when the object is created. Es besteht immer noch die Möglichkeit, Inkonsistenzen zu sein, da weder die Objekt Erstellung noch der Benutzer Überschreibungs Prozess atomarisch ist und sich die relevanten Werte während der Objekt Erstellung ändernThere 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. Diese Situation sollte jedoch sehr selten auftreten.However, this situation should be extremely rare.

Sie können steuern, ob Benutzer Überschreibungen in DateTimeFormatInfo Objekten reflektiert werden, die dieselbe Kultur wie die System Kultur darstellen.You can control whether user overrides are reflected in DateTimeFormatInfo objects that represent the same culture as the system culture. In der folgenden Tabelle sind die Methoden aufgeführt, DateTimeFormatInfo mit denen ein-Objekt abgerufen werden kann, und es wird angegeben, ob das resultierende Objekt Benutzer Überschreibungen widerspiegelt.The following table lists the ways in which a DateTimeFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Quelle des CultureInfo-Objekts und des DateTimeFormatInfo-ObjektsSource of CultureInfo and DateTimeFormatInfo object Spiegelt Benutzer Überschreibungen widerReflects user overrides
CultureInfo.CurrentCulture.DateTimeFormat -EigenschaftCultureInfo.CurrentCulture.DateTimeFormat property JaYes
DateTimeFormatInfo.CurrentInfo -EigenschaftDateTimeFormatInfo.CurrentInfo property JaYes
CultureInfo.CreateSpecificCulture-MethodeCultureInfo.CreateSpecificCulture method JaYes
CultureInfo.GetCultureInfo-MethodeCultureInfo.GetCultureInfo method NeinNo
CultureInfo.CultureInfo(String)-KonstruktorCultureInfo.CultureInfo(String) constructor JaYes
CultureInfo.CultureInfo(String, Boolean)-KonstruktorCultureInfo.CultureInfo(String, Boolean) constructor Hängt vom Wert des useUserOverride Parameters ab.Depends on value of useUserOverride parameter

Sofern es keinen überzeugenden Grund dafür gibt, sollten Sie Benutzer Überschreibungen beachten, wenn Sie das DateTimeFormatInfo -Objekt in Client Anwendungen zum Formatieren und Analysieren von Benutzereingaben oder zum Anzeigen von Daten verwenden.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. Für Server Anwendungen oder unbeaufsichtigte Anwendungen sollten Sie dies nicht tun.For server applications or unattended applications, you should not. Wenn Sie das DateTimeFormatInfo Objekt jedoch entweder explizit oder implizit verwenden, um Datums-und Uhrzeitdaten im Zeichen folgen Format beizubehalten, sollten Sie entweder DateTimeFormatInfo ein-Objekt verwenden, das die Formatierungs Konventionen der invarianten Kultur widerspiegelt, oder Sie müssen einen Benutzerdefinierte Format Zeichenfolge für Datum und Uhrzeit, die Sie unabhängig von der Kultur verwenden.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.

Formatieren von Datum und ZeitFormatting dates and times

Ein DateTimeFormatInfo -Objekt wird implizit oder explizit in allen Datums-und Uhrzeit Formatierungs Vorgängen verwendet.A DateTimeFormatInfo object is used implicitly or explicitly in all date and time formatting operations. Hierzu gehören auch Aufrufe der folgenden Methoden:These include calls to the following methods:

Bei allen Formatierungs Vorgängen für Datum und Uhrzeit IFormatProvider wird eine-Implementierung verwendet.All date and time formatting operations make use of an IFormatProvider implementation. Die IFormatProvider -Schnittstelle enthält eine einzige IFormatProvider.GetFormat(Type)Methode,.The IFormatProvider interface includes a single method, IFormatProvider.GetFormat(Type). Dieser Rückruf Methode wird ein Type -Objekt übermittelt, das den zum Bereitstellen von Formatierungsinformationen erforderlichen Typ darstellt.This callback method is passed a Type object that represents the type needed to provide formatting information. Die-Methode gibt entweder eine Instanz dieses Typs oder null zurück, wenn keine Instanz des Typs bereitgestellt werden kann.The method returns either an instance of that type or null if it cannot provide an instance of the type. Die .NET Framework enthält zwei IFormatProvider Implementierungen zum Formatieren von Datums-und Uhrzeitwerten:The .NET Framework includes two IFormatProvider implementations for formatting dates and times:

Wenn eine- CultureInfo CultureInfo.CurrentCulture Implementierung nicht explizit für eine Formatierungs Methode bereitgestellt wird, wird das von der-Eigenschaft zurückgegebene-Objekt verwendet, das die aktuelle Thread Kultur darstellt. IFormatProviderIf an IFormatProvider implementation is not provided to a formatting method explicitly, the CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Im folgenden Beispiel wird die Beziehung zwischen der IFormatProvider -Schnittstelle DateTimeFormatInfo und der-Klasse in Formatierungs Vorgängen veranschaulicht.The following example illustrates the relationship between the IFormatProvider interface and the DateTimeFormatInfo class in formatting operations. Es definiert eine Benutzer IFormatProvider definierte- GetFormat Implementierung, deren-Methode den Typ des vom Formatierungs Vorgang angeforderten Objekts anzeigt.It defines a custom IFormatProvider implementation whose GetFormat method displays the type of the object requested by the formatting operation. Wenn ein DateTimeFormatInfo -Objekt angefordert wird, stellt die-Methode DateTimeFormatInfo das-Objekt für die aktuelle Thread Kultur bereit.If it is requesting a DateTimeFormatInfo object, the method provides the DateTimeFormatInfo object for the current thread culture. Wie die Ausgabe des Beispiels zeigt, fordert die Decimal.ToString(IFormatProvider) -Methode ein DateTimeFormatInfo NumberFormatInfo -Objekt auf, um Formatierungsinformationen String.Format(IFormatProvider, String, Object[]) bereitzustellen, DateTimeFormatInfo während die-Methode und ICustomFormatter -Objekte sowie ein Ausführungs.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

Format Zeichenfolgen und DateTimeFormatInfo-EigenschaftenFormat strings and DateTimeFormatInfo properties

Das DateTimeFormatInfo -Objekt enthält drei Arten von Eigenschaften, die bei Formatierungs Vorgängen mit Datums-und Uhrzeitwerten verwendet werden:The DateTimeFormatInfo object includes three kinds of properties that are used in formatting operations with date and time values:

Die standardmäßigen Format Zeichenfolgen für Datum und Uhrzeit, wie z. b. "d", "d", "f" und "f", sind DateTimeFormatInfo Aliase, die bestimmten Format Muster Eigenschaften entsprechen.The standard date and time format strings, such as "d", "D", "f", and "F", are aliases that correspond to particular DateTimeFormatInfo format pattern properties. Die meisten benutzerdefinierten Format Zeichenfolgen für Datum und Uhrzeit beziehen sich auf Zeichen folgen oder Teil Zeichenfolgen, die ein Formatierungs Vorgang in den Ergebnisdaten Strom einfügt.Most of the custom date and time format strings are related to strings or substrings that a formatting operation inserts into the result stream. In der folgenden Tabelle werden die standardmäßigen und benutzerdefinierten Format Bearbeiter für Datum und DateTimeFormatInfo Uhrzeit sowie die zugehörigen Eigenschaften aufgelistet.The following table lists the standard and custom date and time format specifiers and their associated DateTimeFormatInfo properties. Ausführliche Informationen zur Verwendung dieser Format Bearbeiter finden Sie unter Standard Format Zeichenfolgen für Datum und Uhrzeit und benutzerdefinierte Format Zeichenfolgen für Datum und Uhrzeit.For details about how to use these format specifiers, see Standard Date and Time Format Strings and Custom Date and Time Format Strings. Beachten Sie, dass jede Standardformat Zeichenfolge einer DateTimeFormatInfo Eigenschaft entspricht, deren Wert eine benutzerdefinierte Format Zeichenfolge für Datum und Uhrzeit ist.Note that each standard format string corresponds to a DateTimeFormatInfo property whose value is a custom date and time format string. Die einzelnen Spezifizierer in dieser benutzerdefinierten Format Zeichenfolge entsprechen DateTimeFormatInfo wiederum anderen Eigenschaften.The individual specifiers in this custom format string in turn correspond to other DateTimeFormatInfo properties. In der Tabelle werden nur DateTimeFormatInfo die Eigenschaften aufgelistet, für die die Standardformat Zeichenfolgen Aliase sind, und es werden keine Eigenschaften aufgelistet, auf die benutzerdefinierte Format Zeichenfolgen, die diesen Alias Eigenschaften zugewiesen sind, zugreifen können.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. Außerdem werden in der Tabelle nur benutzerdefinierte Format Bearbeiter aufgelistet, die DateTimeFormatInfo Eigenschaften entsprechen.In addition, the table lists only custom format specifiers that correspond to DateTimeFormatInfo properties.

FormatbezeichnerFormat specifier Zugeordnete EigenschaftenAssociated properties
"d" (kurzes Datum; Standardformat Zeichenfolge)"d" (short date; standard format string) ShortDatePattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.ShortDatePattern, to define the overall format of the result string.
"D" (langes Datum; Standardformat Zeichenfolge)"D" (long date; standard format string) LongDatePattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.LongDatePattern, to define the overall format of the result string.
"f" (vollständiges Datum/kurze Zeit; Standardformat Zeichenfolge)"f" (full date / short time; standard format string) LongDatePattern, um das Format der Datums Komponente der Ergebnis Zeichenfolge zu definieren.LongDatePattern, to define the format of the date component of the result string.

ShortTimePattern, um das Format der Zeitkomponente der Ergebnis Zeichenfolge zu definieren.ShortTimePattern, to define the format of the time component of the result string.
"F" (Full Date/Long Time; Standardformat Zeichenfolge)"F" (full date / long time; standard format string) LongDatePattern, um das Format der Datums Komponente der Ergebnis Zeichenfolge zu definieren.LongDatePattern, to define the format of the date component of the result string.

LongTimePattern, um das Format der Zeitkomponente der Ergebnis Zeichenfolge zu definieren.LongTimePattern, to define the format of the time component of the result string.
"g" (allgemeines Datum/kurze Zeit; Standardformat Zeichenfolge)"g" (general date / short time; standard format string) ShortDatePattern, um das Format der Datums Komponente der Ergebnis Zeichenfolge zu definieren.ShortDatePattern, to define the format of the date component of the result string.

ShortTimePattern, um das Format der Zeitkomponente der Ergebnis Zeichenfolge zu definieren.ShortTimePattern, to define the format of the time component of the result string.
"G" (allgemeines Datum/lange Zeit; Standardformat Zeichenfolge)"G" (general date / long time; standard format string) ShortDatePattern, um das Format der Datums Komponente der Ergebnis Zeichenfolge zu definieren.ShortDatePattern, to define the format of the date component of the result string.

LongTimePattern, um das Format der Zeitkomponente der Ergebnis Zeichenfolge zu definieren.LongTimePattern, to define the format of the time component of the result string.
"M", "m" (Monat/Tag; Standardformat Zeichenfolge)"M", "m" (month/day; standard format string) MonthDayPattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.MonthDayPattern, to define the overall format of the result string.
"O", "o" (Roundtrip-Datum/-Uhrzeit; Standardformat Zeichenfolge)"O", "o" (round-trip date/time; standard format string) KeineNone.
"R", "r" (RFC1123; Standardformat Zeichenfolge)"R", "r" (RFC1123; standard format string) RFC1123Pattern, um eine Ergebnis Zeichenfolge zu definieren, die dem RFC 1123-Standard entspricht.RFC1123Pattern, to define a result string that conforms to the RFC 1123 standard. Die Eigenschaft ist schreibgeschützt.The property is read-only.
"s" (Sortier bares Datum/Uhrzeit, Standardformat Zeichenfolge)"s" (sortable date/time; standard format string) SortableDateTimePattern, um eine Ergebnis Zeichenfolge zu definieren, die dem ISO 8601-Standard entspricht.SortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard. Die Eigenschaft ist schreibgeschützt.The property is read-only.
"t" (Kurzzeit; Standardformat Zeichenfolge)"t" (short time; standard format string) ShortTimePattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.ShortTimePattern, to define the overall format of the result string.
"T" (lange Zeit; Standardformat Zeichenfolge)"T" (long time; standard format string) LongTimePattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.LongTimePattern, to define the overall format of the result string.
"u" (universelle sortierbare Datums-/uhrzeitanzeit; Standardformat Zeichenfolge)"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, um eine Ergebnis Zeichenfolge zu definieren, die dem ISO 8601-Standard für die koordinierte Weltzeit entspricht.UniversalSortableDateTimePattern, to define a result string that conforms to the ISO 8601 standard for coordinated universal time. Die Eigenschaft ist schreibgeschützt.The property is read-only.
"U" (universelles vollständiges Datum/Uhrzeit; Standardformat Zeichenfolge)"U" (universal full date/time; standard format string) FullDateTimePattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.FullDateTimePattern, to define the overall format of the result string.
"Y", "y" (Year Month; Standardformat Zeichenfolge)"Y", "y" (year month; standard format string) YearMonthPattern, um das Gesamt Format der Ergebnis Zeichenfolge zu definieren.YearMonthPattern, to define the overall format of the result string.
"ddd" (benutzerdefinierter Format Bezeichner)"ddd" (custom format specifier) AbbreviatedDayNames, um den abgekürzten Namen des Wochentags in die Ergebnis Zeichenfolge einzuschließen.AbbreviatedDayNames, to include the abbreviated name of the day of the week in the result string.
"g", "gg" (benutzerdefinierter Format Bezeichner)"g", "gg" (custom format specifier) Ruft die GetEraName -Methode auf, um den ERA-Namen in die Ergebnis Zeichenfolge einzufügen.Calls the GetEraName method to insert the era name in the result string.
"MMM" (benutzerdefinierter Format Bezeichner)"MMM" (custom format specifier) AbbreviatedMonthNames, um den abgekürzten Monatsnamen in die Ergebnis Zeichenfolge einzuschließen.AbbreviatedMonthNames, to include the abbreviated month name in the result string.
"MMMM" (benutzerdefinierter Format Bezeichner)"MMMM" (custom format specifier) MonthNamesoder MonthGenitiveNames, um den vollständigen Monatsnamen in die Ergebnis Zeichenfolge einzuschließen.MonthNames or MonthGenitiveNames, to include the full month name in the result string.
"t" (benutzerdefinierter Format Bezeichner)"t" (custom format specifier) AMDesignatoroder PMDesignator, um das erste Zeichen des am/pm-Kenn Zeichner in die Ergebnis Zeichenfolge einzuschließen.AMDesignator or PMDesignator, to include the first character of the AM/PM designator in the result string.
"TT" (benutzerdefinierter Format Bezeichner)"tt" (custom format specifier) AMDesignatoroder PMDesignator, um den vollständigen am/pm-Kenn Zeichner in die Ergebnis Zeichenfolge einzuschließen.AMDesignator or PMDesignator, to include the full AM/PM designator in the result string.
":" (benutzerdefinierter Format Bezeichner)":" (custom format specifier) TimeSeparator, um das Zeit Trennzeichen in die Ergebnis Zeichenfolge einzuschließen.TimeSeparator, to include the time separator in the result string.
"/" (benutzerdefinierter Format Bezeichner)"/" (custom format specifier) DateSeparator, um das Datums Trennzeichen in die Ergebnis Zeichenfolge einzuschließen.DateSeparator, to include the date separator in the result string.

Ändern von DateTimeFormatInfo-EigenschaftenModifying DateTimeFormatInfo properties

Sie können die Ergebnis Zeichenfolge ändern, die von Format Zeichenfolgen für Datum und Uhrzeit erzeugt wurde, DateTimeFormatInfo indem Sie die zugehörigen Eigenschaften eines beschreibbaren Objekts ändern.You can change the result string produced by date and time format strings by modifying the associated properties of a writable DateTimeFormatInfo object. Verwenden Sie die IsReadOnly - DateTimeFormatInfo Eigenschaft, um zu bestimmen, ob ein-Objekt beschreibbar ist.To determine if a DateTimeFormatInfo object is writable, use the IsReadOnly property. So passen Sie DateTimeFormatInfo ein-Objekt auf folgende Weise an:To customize a DateTimeFormatInfo object in this way:

  1. Erstellen Sie eine Lese-/Schreibkopie eines DateTimeFormatInfo -Objekts, dessen Formatierungs Konventionen Sie ändern möchten.Create a read/write copy of a DateTimeFormatInfo object whose formatting conventions you want to modify. (Weitere Informationen finden Sie im Abschnitt Instanziieren eines DateTimeFormatInfo-Objekts .)(See the Instantiating a DateTimeFormatInfo object section.)

  2. Ändern Sie die-Eigenschaft oder die-Eigenschaften, die zum Entwickeln der gewünschten Ergebnis Zeichenfolge verwendet werden.Modify the property or properties that are used to produce the desired result string. (Informationen darüber, wie Formatierungs Methoden DateTimeFormatInfo Eigenschaften zum Definieren von Ergebnis Zeichenfolgen verwenden, finden Sie im vorherigen Abschnitt Formatieren von Zeichen folgen und DateTimeFormatInfo-Eigenschaften.)(For information about how formatting methods use DateTimeFormatInfo properties to define result strings, see the previous section, Format strings and DateTimeFormatInfo properties.)

  3. Verwenden Sie das DateTimeFormatInfo benutzerdefinierte Objekt, das IFormatProvider Sie als Argument in Aufrufen von Formatierungs Methoden erstellt haben.Use the custom DateTimeFormatInfo object you created as the IFormatProvider argument in calls to formatting methods.

Es gibt zwei weitere Möglichkeiten, das Format einer Ergebnis Zeichenfolge zu ändern:There are two other ways to change the format of a result string:

  • Mithilfe der CultureAndRegionInfoBuilder -Klasse können Sie entweder eine benutzerdefinierte Kultur (eine Kultur mit einem eindeutigen Namen, die vorhandene Kulturen ergänzt) oder eine Ersatz Kultur (die anstelle einer bestimmten Kultur verwendet wird) definieren.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). Sie können diese Kulturprogramm gesteuert speichern und darauf zugreifen, wie jedes CultureInfo beliebige Objekt, das von der .NET Framework unterstützt wird.You can save and access this culture programmatically as you would any CultureInfo object supported by the .NET Framework.

  • Wenn die Ergebnis Zeichenfolge nicht Kultur abhängig ist und nicht einem vordefinierten Format folgt, können Sie eine benutzerdefinierte Format Zeichenfolge für Datum und Uhrzeit verwenden.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. Wenn Sie z. b. Datums-und Uhrzeit Daten im Format yyyymmddhhmmss serialisieren, können Sie die Ergebnis Zeichenfolge generieren, indem Sie die benutzerdefinierte DateTime.ToString(String) Format Zeichenfolge an die-Methode übergeben, und Sie DateTime können die Ergebnis Zeichenfolge zurück in einen Wert konvertieren, indem Sie den Befehl DateTime.ParseExact -Methode.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.

Ändern des kurzen Datums MustersChanging the short date pattern

Im folgenden Beispiel wird das Format einer Ergebnis Zeichenfolge geändert, die von der Standardformat Zeichenfolge "d" (kurzes Datum) erzeugt wird.The following example changes the format of a result string produced by the "d" (short date) standard format string. Dadurch wird die zugehörige ShortDatePattern Eigenschaft für die Kultur "en-US" oder "Englisch" (USA) von der Standardeinstellung "M/d/yyyy" in "yyyy"-"mm"-"dd" geändert, und die Standardformat Zeichenfolge "d" wird verwendet, um das Datum vor und nach der ShortDatePattern Eigenschaft anzuzeigen. tes.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

Ändern des Datums TrennzeichensChanging the date separator character

Im folgenden Beispiel wird das Datums Trennzeichen in einem DateTimeFormatInfo -Objekt geändert, das die Formatierungs Konventionen der fr-FR-Kultur darstellt.The following example changes the date separator character in a DateTimeFormatInfo object that represents the formatting conventions of the fr-FR culture. Im Beispiel wird die Standardformat Zeichenfolge "g" verwendet, um das Datum sowohl vor DateSeparator als auch nach der Änderung der Eigenschaft anzuzeigen.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

Ändern von Tages Namen Abkürzungen und dem langen Datums MusterChanging day name abbreviations and the long date pattern

In einigen Fällen ist das lange Datums Muster, in dem in der Regel der vollständige Tag-und Monats Name zusammen mit der Anzahl der Tage des Monats und des Jahres angezeigt wird, möglicherweise zu lang.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. Im folgenden Beispiel wird das Long-Datums Muster für die Kultur "en-US" verkürzt, um eine aus einem Zeichen bestehende oder zwei Zeichen bestehende namens Abkürzung, gefolgt von der Tagesnummer, der Monatsnamen Abkürzung und dem Jahr zurückzugeben.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. Dies erfolgt durch Zuweisen kürzerer Tages Namen Abkürzungen zum AbbreviatedDayNames Array und durch Ändern der benutzerdefinierten Format Zeichenfolge, die der LongDatePattern Eigenschaft zugewiesen ist.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. Dies betrifft die Ergebnis Zeichenfolgen, die von den Standardformat Zeichenfolgen "D" und "f" zurückgegeben werden.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

Normalerweise wirkt sich die Änderung LongDatePattern an der-Eigenschaft FullDateTimePattern auch auf die-Eigenschaft aus, die wiederum die von der Standardformat Zeichenfolge "F" zurückgegebene Ergebnis Zeichenfolge definiert.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. Um das ursprüngliche vollständige Datums-und Uhrzeit Muster beizubehalten, wird im Beispiel die ursprüngliche benutzerdefinierte Format Zeichenfolge, die LongDatePattern der FullDateTimePattern Eigenschaft zugewiesen ist, nach der Änderung der-Eigenschaft neu zugewiesen.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.

Wechsel von einer 12-Stunden-Uhr zu einem 24-Stunden-FormatChanging from a 12-hour clock to a 24-hour clock

Für viele Kulturen im .NET Framework wird die Uhrzeit mit einem 12-Stunden-Format und einem am/pm-Kenn Zeichner ausgedrückt.For many cultures in the .NET Framework, the time is expressed by using a 12-hour clock and an AM/PM designator. Im folgenden Beispiel wird eine ReplaceWith24HourClock -Methode definiert, die jedes Zeitformat ersetzt, das ein 12-Stunden-Format mit einem Format verwendet, das einen 24-Stunden-Takt verwendet.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

Im Beispiel wird ein regulärer Ausdruck verwendet, um die Format Zeichenfolge zu ändern.The example uses a regular expression to modify the format string. Das Muster @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) für reguläre Ausdrücke wird wie folgt definiert:The regular expression pattern @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) is defined as follows:

MusterPattern BeschreibungDescription
^ Beginnt die Suche am Anfang der Zeichenfolge.Begin the match at the beginning of the string.
(?<openAMPM>\s*t+\s*)? Entsprechung für NULL oder ein Vorkommen von NULL oder mehr Leerzeichen, gefolgt vom Buchstaben "t" einmal oder mehrmals, gefolgt von NULL oder mehr Leerzeichen.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. Diese Erfassungs Gruppe hat openAMPMden Namen.This capturing group is named openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Wenn die openAMPM Gruppe eine Entsprechung aufweist, wird der Buchstabe "h" einmal oder mehrmals abgeglichen, gefolgt von einem oder mehreren Zeichen, die weder "h" noch "t" sind.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". Die Entsprechung endet am Ende der Zeichenfolge.The match ends at the end of the string. Alle Zeichen, die nach "h" aufgezeichnet werden, sind in einer nonHoursErfassungs Gruppe mit dem Namen enthalten.All characters captured after "h" are included in a capturing group named nonHours.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Wenn die openAMPM Gruppe keine Entsprechung aufweist, wird der Buchstabe "h" einmal oder mehrmals abgeglichen, gefolgt von mindestens einem Zeichen, das weder "h" noch "t" gefolgt von NULL oder mehr Leerzeichen ist.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. Zum Schluss finden Sie eine Entsprechung für ein oder mehrere Vorkommen des Buchstabens "t".Finally, match one or more occurrences of the letter "t". Alle Zeichen, die nach "h" und vor den Leerräume und "t" aufgezeichnet werden, sind in einer Erfassungs Gruppe mit dem Namen nonHoursenthalten.All characters captured after "h" and before the white-spaces and "t" are included in a capturing group named nonHours.

Die nonHours Erfassungs Gruppe enthält die Minute und möglicherweise die zweite Komponente einer benutzerdefinierten Format Zeichenfolge für Datum und Uhrzeit sowie alle Zeit Trennzeichen.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. Das Ersetzungs HH${nonHours} Muster fügt diesen Elementen die Teil Zeichenfolge "hh" voran.The replacement pattern HH${nonHours} prepends the substring "HH" to these elements.

Anzeigen und Ändern des Zeitraums in einem DatumDisplaying and changing the era in a date

Im folgenden Beispiel wird der benutzerdefinierte Format LongDatePattern Bezeichner "g" der-Eigenschaft eines-Objekts hinzugefügt, das die Formatierungs Konventionen der Kultur "en-US" darstellt.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. Diese Addition wirkt sich auf die folgenden drei Standardformat Zeichenfolgen aus:This addition affects the following three standard format strings:

  • Die Standardformat Zeichenfolge "D" (Long Date), die direkt der LongDatePattern -Eigenschaft zugeordnet wird.The "D" (long date) standard format string, which maps directly to the LongDatePattern property.

  • Die Standardformat Zeichenfolge "f" (Full Date/Short Time), die eine Ergebnis Zeichenfolge erzeugt, die die Teil Zeichenfolgen ShortTimePattern verkettet, die von den LongDatePattern Eigenschaften und erstellt werden.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.

  • Die Standardformat Zeichenfolge "F" (Full Date/Long Time), die direkt der FullDateTimePattern -Eigenschaft zugeordnet wird.The "F" (full date / long time) standard format string, which maps directly to the FullDateTimePattern property. Da wir diesen Eigenschafts Wert nicht explizit festgelegt haben, wird er dynamisch generiert, indem die LongDatePattern - LongTimePattern Eigenschaft und die-Eigenschaft verkettet werden.Because we have not explicitly set this property value, it is generated dynamically by concatenating the LongDatePattern and LongTimePattern properties.

Das Beispiel zeigt auch, wie Sie den ERA-Namen für eine Kultur ändern können, deren Kalender einen einzelnen Zeitraum hat.The example also shows how to change the era name for a culture whose calendar has a single era. In diesem Fall verwendet die Kultur "en-US" den gregorianischen Kalender, der durch ein GregorianCalendar -Objekt dargestellt wird.In this case, the en-US culture uses the Gregorian calendar, which is represented by a GregorianCalendar object. Die GregorianCalendar Klasse unterstützt einen einzelnen Zeitraum, der nach dem Namen n.The GregorianCalendar class supports a single era, which it names A.D. (Anno Domini).(Anno Domini). Im Beispiel wird der Name des Zeitraums in "v" geändertThe example changes the era name to C.E. (Allgemeiner Zeitraum) durch Ersetzen des benutzerdefinierten Format Bezeichnern "g" in der Format Zeichenfolge FullDateTimePattern , die der-Eigenschaft mit einer Literalzeichenfolge zugewiesen ist.(Common Era) by replacing the "g" custom format specifier in the format string assigned to the FullDateTimePattern property with a literal string. Die Verwendung einer Literalzeichenfolge ist erforderlich, da der Name des Zeitraums normalerweise GetEraName von der Methode aus privaten Daten in den Kultur Tabellen zurückgegeben wird, die entweder vom .NET Framework oder vom Windows-Betriebssystem bereitgestellt werden.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

Verarbeiten von Zeichenfolgen für Datum und UhrzeitParsing date and time strings

Bei der-Verarbeitung wird die Zeichen folgen Darstellung eines Datums und einer Uhrzeit DateTime in DateTimeOffset einen-Wert oder einen-Wert konvertiert.Parsing involves converting the string representation of a date and time to a DateTime or DateTimeOffset value. Beide Typen enthalten die Methoden, Parse TryParse, ParseExactund TryParseExact , um die Verarbeitung von Vorgängen zu unterstützen.Both of these types include the Parse, TryParse, ParseExact, and TryParseExact methods to support parsing operations. Die Parse - TryParse Methode und die-Methode konvertieren eine Zeichenfolge, die über eine ParseExact Vielzahl TryParseExact von Formaten verfügen kann, wohingegen und erfordern, dass die Zeichenfolge ein definiertes Format oder Format hatThe 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. Wenn der-Vorgang fehlschlägt, Parse ParseExact löst eine Ausnahme aus, während TryParse und TryParseExact zurück falsegeben.If the parsing operation fails, Parse and ParseExact throw an exception, whereas TryParse and TryParseExact return false.

Die Analysemethoden verwenden implizit oder explizit einen DateTimeStyles -Enumerationswert, um zu bestimmen, welche Stilelemente (z. b. führenden, nachfolgenden oder inneren Leerraum) in der zu testenden Zeichenfolge vorhanden sein können, und wie die analysierte Zeichenfolge interpretiert werden soll, oder fehlende Aspekte.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. Wenn Sie DateTimeStyles keinen Wert angeben, wenn Sie die- Parse oder TryParse die-Methode aufgerufen haben DateTimeStyles.AllowWhiteSpaces, ist der Standardwert. Dies ist ein DateTimeStyles.AllowLeadingWhitezusammengesetzter Stil DateTimeStyles.AllowInnerWhite , der die Flags, DateTimeStyles.AllowTrailingWhiteund enthält.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. Für die ParseExact - TryParseExact Methode und die-Methode DateTimeStyles.Noneist der Standardwert. die Eingabe Zeichenfolge muss exakt einer bestimmten benutzerdefinierten Format Zeichenfolge für Datum und Uhrzeit entsprechen.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.

Die Analysemethoden verwenden auch implizit oder explizit ein DateTimeFormatInfo -Objekt, das die spezifischen Symbole und Muster definiert, die in der zu testenden Zeichenfolge vorkommen können.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. Wenn Sie kein- DateTimeFormatInfo Objekt bereitstellen, wird standardmäßig das DateTimeFormatInfo -Objekt für die aktuelle Thread Kultur verwendet.If you don't provide a DateTimeFormatInfo object, the DateTimeFormatInfo object for the current thread culture is used by default. Weitere Informationen zum Auswerten von Datums-und Uhrzeit DateTime.ParseZeichenfolgen finden Sie in den einzelnen Methoden zum Auswerten, wie z. b., DateTime.TryParse, DateTimeOffset.ParseExactund 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.

Im folgenden Beispiel wird die Kultur abhängige Darstellung von Datums-und Uhrzeit Zeichenfolgen veranschaulicht.The following example illustrates the culture-sensitive nature of parsing date and time strings. Es wird versucht, zwei Datums Zeichenfolgen mithilfe der Konventionen der Kultur en-US, en-GB, fr-FR und fi-fi zu analysieren.It tries to parse two date strings by using the conventions of the en-US, en-GB, fr-FR, and fi-FI cultures. Das Datum, das in der Kultur "en-US" als 8/18/2014 interpretiert FormatException wird, löst eine-Ausnahme in den anderen drei Kulturen aus, da 18 als Monatsnummer interpretiert wird.The date that is interpreted as 8/18/2014 in the en-US culture throws a FormatException exception in the other three cultures because 18 is interpreted as the month number. 1/2/2015 wird als Zweiter Tag des ersten Monats in der Kultur "en-US" analysiert, aber als erster Tag des zweiten Monats in den verbleibenden Kulturen.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

Datums-und Uhrzeit Zeichenfolgen werden in der Regel aus zwei Gründen analysiert:Date and time strings are typically parsed for two reasons:

  • , Wenn Benutzereingaben in einen Datums-und Uhrzeitwert konvertiert werden sollen.To convert user input into a date and time value.

  • Um einen Roundtrip für einen Datums-und Uhrzeitwert durchzusetzen. Das heißt, dass ein Datums-und Uhrzeitwert deserialisiert werden soll, der zuvor als Zeichenfolge serialisiert wurde.To round-trip a date and time value; that is, to deserialize a date and time value that was previously serialized as a string.

In den folgenden Abschnitten werden diese beiden Vorgänge ausführlicher erläutert.The following sections discuss these two operations in greater detail.

Benutzer Zeichenfolgen werden verarbeitet.Parsing user strings

Wenn Sie die Eingabe von Zeichen folgen für Datum und Uhrzeit durch den Benutzer analysieren, sollten Sie immer ein DateTimeFormatInfo -Objekt instanziieren, das die Kultur Einstellungen des Benutzers widerspiegelt, einschließlich aller Anpassungen, die der Benutzer möglicherweise vorgenommen hat.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. Andernfalls weist das Datums-und Uhrzeit Objekt möglicherweise falsche Werte auf.Otherwise, the date and time object may have incorrect values. Informationen dazu, wie ein DateTimeFormatInfo -Objekt instanziiert wird, das Benutzer Kultur Anpassungen widerspiegelt, finden Sie im Abschnitt DateTimeFormatInfo und Dynamic Data .For information about how to instantiate a DateTimeFormatInfo object that reflects user cultural customizations, see the DateTimeFormatInfo and dynamic data section.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem-Verarbeitungsvorgang, der Benutzer Kultur Einstellungen widerspiegelt, und einem, der nicht.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. In diesem Fall ist die Standardsystem Kultur "en-US", aber der Benutzer hat die Systemsteuerung, die Region und die Sprache verwendet, um das kurze Datums Muster vom Standardwert "M/d/yyyy" in "yy/mm/dd" zu ändern.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". Wenn der Benutzer eine Zeichenfolge eingibt, die Benutzereinstellungen widerspiegelt, und die Zeichenfolge DateTimeFormatInfo durch ein-Objekt analysiert wird, das auch Benutzereinstellungen (außer Kraft setzungen) widerspiegelt, gibt der Analyse Vorgang ein korrektes Ergebnis zurück.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. Wenn die Zeichenfolge jedoch von einem DateTimeFormatInfo -Objekt analysiert wird, das die standardmäßigen en-US-Kultur Einstellungen widerspiegelt, löst die Analysemethode eine FormatException -Ausnahme aus, da Sie 14 als die Anzahl der Monate und nicht als die letzten zwei Ziffern des Jahres interpretiert.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

Serialisieren und Deserialisieren von Datums-und Uhrzeit DatenSerializing and deserializing date and time data

Für die Serialisierung von Datums-und Uhrzeitdaten wird ein Roundtrip erwartet. Das heißt, alle serialisierten und deserialisierten Werte sollten identisch sein.Serialized date and time data are expected to round-trip; that is, all serialized and deserialized values should be identical. Wenn ein Datums-und Uhrzeitwert einen bestimmten Zeitpunkt darstellt, sollte der deserialisierte Wert unabhängig von der Kultur oder Zeitzone des Systems, auf dem es wieder hergestellt wurde, denselben Zeitpunkt darstellen.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. Zum erfolgreichen Roundtrip von Datums-und Uhrzeitdaten müssen Sie die Konventionen der invarianten Kultur verwenden, die von der InvariantInfo -Eigenschaft zurückgegeben wird, um die Daten zu generieren und zu analysieren.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. Die Formatierungs-und die-Diagnose Vorgänge sollten niemals die Konventionen der Standard Kultur widerspiegeln.The formatting and parsing operations should never reflect the conventions of the default culture. Wenn Sie die standardmäßigen kulturellen Einstellungen verwenden, ist die Portabilität der Daten streng eingeschränkt. Sie kann nur in einem Thread deserialisiert werden, dessen kulturspezifische Einstellungen mit denen des Threads identisch sind, in dem Sie serialisiert wurde.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 einigen Fällen bedeutet dies, dass die Daten nicht einmal erfolgreich serialisiert und auf demselben System deserialisiert werden können.In some cases, this means that the data cannot even be successfully serialized and deserialized on the same system.

Wenn die Zeitkomponente eines Datums-und Uhrzeitwerts signifikant ist, sollte Sie auch in UTC konvertiert und mit der Standardformat Zeichenfolge"o" oder "r" serialisiert werden.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. Die Zeit Daten können dann wieder hergestellt werden, indem eine Analyse-Methode aufgerufen und ihr die entsprechende Format Zeichenfolge zusammen mit der invarianten Kultur als provider Argument übergeben wird.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.

Im folgenden Beispiel wird der Prozess zum Roundtrip eines Datums-und Uhrzeitwerts veranschaulicht.The following example illustrates the process of round-tripping a date and time value. Es serialisiert ein Datum und eine Uhrzeit in einem System, das den US-amerikanischen Pacific Time und deren aktuelle Kultur 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)

Es deserialisiert die Daten auf einem System in der Zeitzone "Brüssel", "Kopenhagen", "Madrid" und "Paris" und deren aktuelle Kultur "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. Das wiederhergestellte Datum beträgt neun Stunden nach dem ursprünglichen Datum, das die Zeit Zonen Anpassung von 8 Stunden hinter UTC auf eine Stunde vor UTC widerspiegelt.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. Sowohl das ursprüngliche Datum als auch das wiederhergestellte Datum stellen denselben Zeitpunkt dar.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

Konstruktoren

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

Initialisiert eine neue, schreibbare Instanz der DateTimeFormatInfo-Klasse, die kulturunabhängig (invariant) ist.Initializes a new writable instance of the DateTimeFormatInfo class that is culture-independent (invariant).

Eigenschaften

AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames AbbreviatedDayNames

Ruft ein eindimensionales Array vom Typ String ab, das die kulturabhängigen abgekürzten Namen der Wochentage enthält, oder legt dieses fest.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

Ruft ein Zeichenfolgenarray der abgekürzten Monatsnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt dieses fest.Gets or sets a string array of abbreviated month names associated with the current DateTimeFormatInfo object.

AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames AbbreviatedMonthNames

Ruft ein eindimensionales Zeichenfolgenarray ab, das die kulturabhängigen abgekürzten Namen der Monate enthält, oder legt dieses fest.Gets or sets a one-dimensional string array that contains the culture-specific abbreviated names of the months.

AMDesignator AMDesignator AMDesignator AMDesignator

Ruft den Zeichenfolgenkennzeichner für Zeitangaben vor 12 Uhr mittags ("ante meridiem", a.m.) ab oder legt diesen fest.Gets or sets the string designator for hours that are "ante meridiem" (before noon).

Calendar Calendar Calendar Calendar

Ruft den für die aktuelle Kultur zu verwendenden Kalender ab oder legen diesen fest.Gets or sets the calendar to use for the current culture.

CalendarWeekRule CalendarWeekRule CalendarWeekRule CalendarWeekRule

Ruft einen Wert ab, der die Regel zum Bestimmen der ersten Kalenderwoche eines Jahres angibt, oder legt diesen fest.Gets or sets a value that specifies which rule is used to determine the first calendar week of the year.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Ruft ein schreibgeschütztes DateTimeFormatInfo-Objekt ab, das Werte basierend auf der aktuellen Kultur formatiert.Gets a read-only DateTimeFormatInfo object that formats values based on the current culture.

DateSeparator DateSeparator DateSeparator DateSeparator

Ruft die Zeichenfolge ab, die die Datumskomponenten trennt, d. h. Jahr, Monat und Tag, oder legt diese fest.Gets or sets the string that separates the components of a date, that is, the year, month, and day.

DayNames DayNames DayNames DayNames

Ruft ein eindimensionales Zeichenfolgenarray ab, das die kulturabhängigen vollständigen Namen der Wochentage enthält, oder legt dieses fest.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

Ruft den ersten Tag der Woche ab oder legt diesen fest.Gets or sets the first day of the week.

FullDateTimePattern FullDateTimePattern FullDateTimePattern FullDateTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen langen Datums- und Uhrzeitwert ab oder legt dieses fest.Gets or sets the custom format string for a long date and long time value.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Ruft das schreibgeschützte DateTimeFormatInfo-Standardobjekt ab, das kulturunabhängig (invariant) ist.Gets the default read-only DateTimeFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ruft einen Wert ab, der angibt, ob das DateTimeFormatInfo-Objekt schreibgeschützt ist.Gets a value indicating whether the DateTimeFormatInfo object is read-only.

LongDatePattern LongDatePattern LongDatePattern LongDatePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen langen Datumswert ab oder legt diese fest.Gets or sets the custom format string for a long date value.

LongTimePattern LongTimePattern LongTimePattern LongTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen langen Uhrzeitwert ab oder legt diese fest.Gets or sets the custom format string for a long time value.

MonthDayPattern MonthDayPattern MonthDayPattern MonthDayPattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen Monats- und Tageswert ab oder legt diese fest.Gets or sets the custom format string for a month and day value.

MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames MonthGenitiveNames

Ruft ein Zeichenfolgenarray der Monatsnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt dieses fest.Gets or sets a string array of month names associated with the current DateTimeFormatInfo object.

MonthNames MonthNames MonthNames MonthNames

Ruft ein eindimensionales Array vom Typ String ab, das die kulturabhängigen vollständigen Namen der Monate enthält, oder legt dieses fest.Gets or sets a one-dimensional array of type String containing the culture-specific full names of the months.

NativeCalendarName NativeCalendarName NativeCalendarName NativeCalendarName

Ruft den systemeigenen Namen des Kalenders ab, der dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.Gets the native name of the calendar associated with the current DateTimeFormatInfo object.

PMDesignator PMDesignator PMDesignator PMDesignator

Ruft den Zeichenfolgenkennzeichner für Zeitangaben nach 12 Uhr mittags ("post meridiem", p.m.) ab oder legt diesen fest.Gets or sets the string designator for hours that are "post meridiem" (after noon).

RFC1123Pattern RFC1123Pattern RFC1123Pattern RFC1123Pattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen Uhrzeitwert ab, der auf der Spezifikation 1123 Request for Comments (Internet Engineering Task Force- IETF RFC ()) basiert.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

Ruft die benutzerdefinierte Formatzeichenfolge für einen kurzen Datumswert ab oder legt diese fest.Gets or sets the custom format string for a short date value.

ShortestDayNames ShortestDayNames ShortestDayNames ShortestDayNames

Ruft ein Zeichenfolgenarray der am stärksten abgekürzten, eindeutigen Tagesnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt diese fest.Gets or sets a string array of the shortest unique abbreviated day names associated with the current DateTimeFormatInfo object.

ShortTimePattern ShortTimePattern ShortTimePattern ShortTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen kurzen Uhrzeitwert ab oder legt diese fest.Gets or sets the custom format string for a short time value.

SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern SortableDateTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen sortierbaren Datums-und Zeitwert ab.Gets the custom format string for a sortable date and time value.

TimeSeparator TimeSeparator TimeSeparator TimeSeparator

Ruft die Zeichenfolge ab, die die Bestandteile der Uhrzeit trennt, d. h. Stunde, Minuten und Sekunden, oder legt diese fest.Gets or sets the string that separates the components of time, that is, the hour, minutes, and seconds.

UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern UniversalSortableDateTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für eine universelle sortierbare Datums- und Zeitzeichenfolge gemäß ISO 8601 ab.Gets the custom format string for a universal, sortable date and time string, as defined by ISO 8601.

YearMonthPattern YearMonthPattern YearMonthPattern YearMonthPattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen Jahres- und Monatswert ab oder legt diese fest.Gets or sets the custom format string for a year and month value.

Methoden

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

Erstellt eine flache Kopie von DateTimeFormatInfo.Creates a shallow copy of the DateTimeFormatInfo.

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

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

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

Gibt den kulturabhängigen abgekürzten Namen des angegebenen Wochentags entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.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)

Gibt die Zeichenfolge zurück, die den abgekürzten Namen des angegebenen Zeitraums enthält, sofern eine Abkürzung vorhanden ist.Returns the string containing the abbreviated name of the specified era, if an abbreviation exists.

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

Gibt den kulturabhängigen abgekürzten Namen des angegebenen Monats entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.Returns the culture-specific abbreviated name of the specified month based on the culture associated with the current DateTimeFormatInfo object.

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

Gibt alle Standardmuster zurück, in denen Datums- und Zeitwerte formatiert werden können.Returns all the standard patterns in which date and time values can be formatted.

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

Gibt alle Muster zurück, in denen Datums- und Zeitwerte mit der angegebenen Standardformatzeichenfolge formatiert werden können.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)

Gibt den kulturabhängigen vollständigen Namen des angegebenen Wochentags entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.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)

Gibt die Ganzzahl zurück, die den angegebenen Zeitraum darstellt.Returns the integer representing the specified era.

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

Gibt die Zeichenfolge mit dem Namen des angegebenen Zeitraums zurück.Returns the string containing the name of the specified era.

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

Gibt ein Objekt vom angegebenen Typ zurück, das einen Datum-und Zeit-Formatierungsdienst bereitstellt.Returns an object of the specified type that provides a date and time formatting service.

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

Fungiert als Standardhashfunktion.Serves as the default hash function.

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

Gibt das DateTimeFormatInfo-Objekt zurück, das dem angegebenen IFormatProvider zugeordnet ist.Returns the DateTimeFormatInfo object associated with the specified IFormatProvider.

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

Gibt den kulturabhängigen vollständigen Namen des angegebenen Monats entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.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)

Ruft den am stärksten abgekürzten Tagesnamen für einen angegebenen Wochentag ab, der dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.Obtains the shortest abbreviated day name for a specified day of the week associated with the current DateTimeFormatInfo object.

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

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

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

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

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

Gibt einen schreibgeschützten DateTimeFormatInfo-Wrapper zurück.Returns a read-only DateTimeFormatInfo wrapper.

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

Legt die benutzerdefinierten Formatzeichenfolgen für Datum und Uhrzeit fest, die einer angegebenen Standardformatzeichenfolge entsprechen.Sets the custom date and time format strings that correspond to a specified standard format string.

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

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

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

Gilt für:

Siehe auch