DateTimeFormatInfo Klasse

Definition

Stellt kulturabhängige Informationen zum Format von Datum und Zeitangaben bereit.

public ref class DateTimeFormatInfo sealed : IFormatProvider
public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider
public ref class DateTimeFormatInfo sealed : ICloneable, IFormatProvider, System::Runtime::Serialization::ISerializable
public sealed class DateTimeFormatInfo : IFormatProvider
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider, System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
type DateTimeFormatInfo = class
    interface IFormatProvider
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
[<System.Serializable>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type DateTimeFormatInfo = class
    interface ICloneable
    interface IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider
Public NotInheritable Class DateTimeFormatInfo
Implements ICloneable, IFormatProvider, ISerializable
Vererbung
DateTimeFormatInfo
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird Reflektion verwendet, um die Eigenschaften des DateTimeFormatInfo -Objekts für die englische Kultur (USA) abzurufen. Es zeigt den Wert dieser Eigenschaften an, die benutzerdefinierte Formatzeichenfolgen enthalten, und verwendet diese Zeichenfolgen, um formatierte Datumsangaben anzuzeigen.

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 der -Klasse enthalten kulturspezifische Informationen zur Formatierung oder Analyse von DateTimeFormatInfo Datums- und Uhrzeitwerten, z. B.:

  • Die Muster, die zum Formatieren von Datumswerten verwendet werden.

  • Die Muster, die zum Formatieren von Zeitwerten verwendet werden.

  • Die Namen der Wochentage.

  • Die Namen der Monate des Jahres.

  • The A.M. und Nachmittag -Designatoren, die in Zeitwerten verwendet werden.

  • Der Kalender, in dem Datumsangaben ausgedrückt werden.

Inhalt dieses Abschnitts:

Instanziieren eines DateTimeFormatInfo-Objekts

Ein DateTimeFormatInfo -Objekt kann die Formatierungskonventionen der invarianten Kultur, einer bestimmten Kultur, einer neutralen Kultur oder der aktuellen Kultur darstellen. In diesem Abschnitt wird erläutert, wie die einzelnen Objekttypen instanziiert DateTimeFormatInfo werden.

Instanziieren eines DateTimeFormatInfo-Objekts für die invariante Kultur

Die invariante Kultur stellt eine Kultur dar, die kulturunabhängig ist. Sie basiert auf der englischen Sprache, aber nicht auf einem bestimmten englischsprachigen Land/einer bestimmten Region. Obwohl die Daten bestimmter Kulturen dynamisch sein können und sich ändern können, um neue kulturelle Konventionen oder Benutzereinstellungen zu berücksichtigen, ändern sich die Daten der invarianten Kultur nicht. Sie können ein -Objekt instanziieren, das die Formatierungskonventionen der invarianten Kultur auf folgende DateTimeFormatInfo Weise darstellt:

Im folgenden Beispiel wird jede dieser Methoden verwendet, um ein -Objekt zu instanziieren, DateTimeFormatInfo das die invariante Kultur darstellt. Anschließend wird angegeben, ob das Objekt schreibgeschützt ist.

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 Kultur

Eine bestimmte Kultur stellt eine Sprache dar, die in einem bestimmten Land/einer bestimmten Region gesprochen wird. Beispielsweise ist en-US eine spezifische Kultur, die die im USA gesprochene englische Sprache darstellt, und en-CA ist eine bestimmte Kultur, die die in Kanada gesprochene englische Sprache darstellt. Sie können ein -Objekt instanziieren, DateTimeFormatInfo das die Formatierungskonventionen einer bestimmten Kultur darstellt, auf folgende Weise:

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

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 Kultur

Eine neutrale Kultur stellt eine Kultur oder Sprache dar, die von einem Land/einer Region unabhängig ist. es ist in der Regel das übergeordnete Element einer oder mehrere spezifische Kulturen. Fr ist z. B. eine neutrale Kultur für die französische Sprache und das übergeordnete Element der fr-FR-Kultur. Sie können ein -Objekt instanziieren, das die Formatierungskonventionen einer neutralen Kultur auf die gleiche Weise darstellt wie ein -Objekt, das die Formatierungskonventionen einer bestimmten DateTimeFormatInfo DateTimeFormatInfo Kultur darstellt. Darüber hinaus können Sie das -Objekt einer neutralen Kultur abrufen, indem Sie eine neutrale Kultur aus der -Eigenschaft einer bestimmten Kultur abrufen und das von der -Eigenschaft DateTimeFormatInfo CultureInfo.Parent DateTimeFormatInfo zurückgegebene Objekt CultureInfo.DateTimeFormat abrufen. Sofern die übergeordnete Kultur nicht die invariante Kultur darstellt, ist das DateTimeFormatInfo zurückgegebene Objekt Lese-/Schreibzugriff. Im folgenden Beispiel werden diese Methoden zum Instanziieren eines -Objekts DateTimeFormatInfo veranschaulicht, das eine neutrale Kultur darstellt.

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 löst der Versuch, ein -Objekt abzurufen, das die Formatierungskonventionen einer neutralen Kultur widerspiegelt, DateTimeFormatInfo eine Ausnahme NotSupportedException aus.

Eine neutrale Kultur enthält jedoch keine kulturspezifischen Formatierungsinformationen, da sie unabhängig von einem bestimmten Land/einer bestimmten Region ist. Anstatt das -Objekt mit generischen Werten zu aufpopulieren, gibt die .NET Framework ein -Objekt zurück, das die Formatierungskonventionen einer bestimmten Kultur widerspiegelt, die ein untergeordnetes Objekt der DateTimeFormatInfo DateTimeFormatInfo neutralen Kultur ist. Beispielsweise spiegelt das -Objekt für die neutrale en-Kultur die Formatierungskonventionen der Kultur en-US wider, und das -Objekt für die kultur fr spiegelt die Formatierungskonventionen der DateTimeFormatInfo DateTimeFormatInfo fr-FR-Kultur wider.

Sie können Code wie den folgenden verwenden, um zu bestimmen, welche Formatierungskonventionen eine neutrale Kultur für eine bestimmte Kultur darstellt. Im Beispiel wird reflektion verwendet, um die Eigenschaften einer neutralen Kultur mit den DateTimeFormatInfo Eigenschaften einer bestimmten untergeordneten Kultur zu vergleichen. Zwei Kalender werden als gleichwertig betrachtet, wenn sie denselben Kalendertyp aufweisen, und bei gregorianischen Kalendern, wenn ihre Eigenschaften GregorianCalendar.CalendarType identische Werte aufweisen.

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 Kultur

Sie können ein -Objekt instanziieren, das die Formatierungskonventionen der aktuellen Kultur DateTimeFormatInfo darstellt, auf folgende Weise:

Im folgenden Beispiel wird jede dieser Methoden verwendet, um ein -Objekt zu instanziieren, das die DateTimeFormatInfo Formatierungskonventionen der aktuellen Kultur darstellt. Anschließend wird angegeben, ob das Objekt schreibgeschützt ist.

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 Objekt erstellen, das die Konventionen der aktuellen Threadkultur DateTimeFormatInfo auf eine der folgenden Arten darstellt:

Das folgende Beispiel veranschaulicht die einzelnen Arten der Instanziierung eines Lese-/Schreibobjekts und zeigt DateTimeFormatInfo den Wert seiner -Eigenschaft IsReadOnly an.

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 der Eigenschaftswerte überschreiben, die in Formatierungs- und Analysevorgängen über die Anwendung Region und Sprache DateTimeFormatInfo in Systemsteuerung. Beispielsweise kann ein Benutzer, dessen Kultur Englisch (USA) ist, lange Zeitwerte mit einer 24-Stunden-Uhr (im Format HH:mm:ss) anstelle der standardmäßigen 12-Stunden-Uhr (im Format h:mm:ss tt) anzeigen. Die DateTimeFormatInfo -Objekte, die auf die zuvor erläuterte Weise abgerufen wurden, spiegeln diese Benutzerüberschreibungen wider. Wenn dies unerwünscht ist, können Sie ein -Objekt erstellen, das keine Benutzerüberschreibungen widergerufen hat (und auch lese-/schreibgef noch nicht schreibgeschützt ist), indem Sie den Konstruktor aufrufen und einen Wert von für das Argument NumberFormatInfo CultureInfo.CultureInfo(String, Boolean) false useUserOverride angeben. Das folgende Beispiel veranschaulicht dies für ein System, dessen aktuelle Kultur Englisch (USA) ist und dessen langes Zeitmuster vom Standardwert h:mm:ss tt in HH:mm:ss geändert wurde.

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 dynamische Daten

Die kulturspezifischen Daten zum Formatieren von Datums- und Uhrzeitwerten, die von der -Klasse bereitgestellt werden, sind dynamisch, genau wie kulturspezifische Daten, die DateTimeFormatInfo von der -Klasse bereitgestellt CultureInfo werden. Sie sollten keine Annahmen über die Stabilität von Werten für Objekte DateTimeFormatInfo treffen, die bestimmten Objekten zugeordnet CultureInfo sind. Nur die Daten, die von der invarianten Kultur und dem zugehörigen DateTimeFormatInfo Objekt bereitgestellt werden, sind stabil. Andere Daten können sich zwischen Anwendungssitzungen oder sogar während der Ausführung Ihrer Anwendung ändern. Es gibt vier Hauptquellen für Änderungen:

  • Systemupdates. Kulturelle Vorlieben wie der bevorzugte Kalender oder die üblichen Datums- und Uhrzeitformate ändern sich im Laufe der Zeit. In diesem Fall Windows Update Änderungen am Eigenschaftswert DateTimeFormatInfo für eine bestimmte Kultur ein.

  • Ersetzungskulturen. Die CultureAndRegionInfoBuilder -Klasse kann verwendet werden, um die Daten einer vorhandenen Kultur zu ersetzen.

  • Kaskadierenden Änderungen an Eigenschaftswerten. Eine Reihe von kulturbezogenen Eigenschaften kann sich zur Laufzeit ändern, wodurch wiederum Daten DateTimeFormatInfo geändert werden. Beispielsweise kann die aktuelle Kultur entweder programmgesteuert oder über eine Benutzeraktion geändert werden. In diesem Fall ändert sich DateTimeFormatInfo das von der CurrentInfo -Eigenschaft zurückgegebene Objekt in ein -Objekt, das der aktuellen Kultur zugeordnet ist. Auf ähnliche Weise kann sich der Kalender einer Kultur ändern, was zu Änderungen an zahlreichen DateTimeFormatInfo Eigenschaftswerten führen kann.

  • Benutzereinstellungen. Benutzer Ihrer Anwendung können einige der Werte, die der aktuellen Systemkultur zugeordnet sind, über die Regionalen- und Sprachoptionen in Systemsteuerung. Beispielsweise können Benutzer das Datum in einem anderen Format anzeigen. Wenn die -Eigenschaft auf festgelegt ist, werden die Eigenschaften des -Objekts auch CultureInfo.UseUserOverride true aus den DateTimeFormatInfo Benutzereinstellungen abgerufen. Wenn die Benutzereinstellungen nicht mit der kultur kompatibel sind, die dem -Objekt zugeordnet ist (z. B. wenn der ausgewählte Kalender nicht zu den kalendern gehört, die durch die -Eigenschaft angegeben werden), sind die Ergebnisse der Methoden und die Werte der Eigenschaften nicht CultureInfo OptionalCalendars definiert.

Um die Möglichkeit inkonsistenter Daten zu minimieren, werden alle vom Benutzer überschreibbaren Eigenschaften eines -Objekts DateTimeFormatInfo initialisiert, wenn das Objekt erstellt wird. Es besteht weiterhin die Möglichkeit von Inkonsistenz, da weder die Objekterstellung noch der Benutzerüberschreibungsprozess atomar ist und sich die relevanten Werte während der Objekterstellung ändern können. Diese Situation sollte jedoch äußerst selten sein.

Sie können steuern, ob Benutzerüberschreibungen in Objekten widergespiegelt DateTimeFormatInfo werden, die dieselbe Kultur wie die Systemkultur darstellen. In der folgenden Tabelle sind die Methoden aufgeführt, mit denen ein -Objekt abgerufen werden kann, und gibt an, ob das resultierende DateTimeFormatInfo Objekt Benutzerüberschreibungen widerspiegelt.

Quelle des CultureInfo- und DateTimeFormatInfo-Objekts Spiegelt Außerkraftsetzungen von Benutzer wider
CultureInfo.CurrentCulture.DateTimeFormat -Eigenschaft Ja
DateTimeFormatInfo.CurrentInfo -Eigenschaft Ja
CultureInfo.CreateSpecificCulture-Methode Ja
CultureInfo.GetCultureInfo-Methode Nein
CultureInfo.CultureInfo(String)-Konstruktor Ja
CultureInfo.CultureInfo(String, Boolean)-Konstruktor Abhängig vom Wert des useUserOverride Parameters

Sofern es keinen zwingenden Grund gibt, etwas anderes zu tun, sollten Sie Die Außerkraftsetzungen von Benutzer achten, wenn Sie das -Objekt in Clientanwendungen zum Formatieren und Analysieren von Benutzereingaben oder zum Anzeigen DateTimeFormatInfo von Daten verwenden. Bei Serveranwendungen oder unbeaufsichtigten Anwendungen ist dies nicht zu verwenden. Wenn Sie das -Objekt jedoch explizit oder implizit verwenden, um Datums- und Uhrzeitdaten in Zeichenfolgenform zu speichern, sollten Sie entweder ein -Objekt verwenden, das die Formatierungskonventionen der invarianten Kultur widerspiegelt, oder Sie sollten eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit angeben, die Sie unabhängig von der Kultur DateTimeFormatInfo DateTimeFormatInfo verwenden.

Formatieren von Datums- und Zeitangaben

Ein DateTimeFormatInfo -Objekt wird implizit oder explizit in allen Datums- und Uhrzeitformatierungsvorgängen verwendet. Dazu gehören Aufrufe der folgenden Methoden:

Alle Datums- und Uhrzeitformatierungsvorgänge verwenden eine IFormatProvider -Implementierung. Die IFormatProvider -Schnittstelle enthält eine einzelne Methode, IFormatProvider.GetFormat(Type) . Dieser Rückrufmethode wird ein -Objekt übergeben, das den Typ darstellt, der zum Type Bereitstellen von Formatierungsinformationen erforderlich ist. Die Methode gibt entweder eine Instanz dieses Typs oder null zurück, wenn sie keine Instanz des Typs bereitstellen kann. Das .NET Framework enthält zwei IFormatProvider Implementierungen zum Formatieren von Datums- und Zeitangaben:

Wenn eine Implementierung nicht explizit für eine Formatierungsmethode bereitgestellt wird, wird das von der -Eigenschaft zurückgegebene -Objekt verwendet, das die aktuelle IFormatProvider CultureInfo CultureInfo.CurrentCulture Threadkultur darstellt.

Das folgende Beispiel veranschaulicht die Beziehung zwischen der IFormatProvider -Schnittstelle und der DateTimeFormatInfo -Klasse in Formatierungsvorgängen. Sie definiert eine benutzerdefinierte IFormatProvider Implementierung, GetFormat deren -Methode den Typ des objekts anzeigt, das vom Formatierungsvorgang angefordert wird. Wenn sie ein -Objekt an DateTimeFormatInfo fordert, stellt die -Methode das DateTimeFormatInfo -Objekt für die aktuelle Threadkultur zur Verfügung. Wie die Ausgabe des Beispiels zeigt, fordert die -Methode ein -Objekt an, um Formatierungsinformationen zur Verfügung zu stellen, während die -Methode und -Objekte sowie eine Decimal.ToString(IFormatProvider) DateTimeFormatInfo String.Format(IFormatProvider, String, Object[]) NumberFormatInfo DateTimeFormatInfo -Implementierung ICustomFormatter an fordert.

using System;
using System.Globalization;

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

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

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

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

Formatzeichenfolgen und DateTimeFormatInfo-Eigenschaften

Das DateTimeFormatInfo -Objekt enthält drei Arten von Eigenschaften, die bei Formatierungsvorgängen mit Datums- und Uhrzeitwerten verwendet werden:

Die Standardformatzeichenfolgenfür Datum und Uhrzeit, z. B. "d", "D", "f" und "F", sind Aliase, die bestimmten Formatmustereigenschaften DateTimeFormatInfo entsprechen. Die meisten benutzerdefinierten Formatzeichenfolgen für Datum und Uhrzeit sind mit Zeichenfolgen oder Teilzeichenfolgen verknüpft, die von einem Formatierungsvorgang in den Ergebnisstream eingefügt werden. In der folgenden Tabelle sind die standardmäßigen und benutzerdefinierten Formatbezeichner für Datum und Uhrzeit und die zugehörigen Eigenschaften DateTimeFormatInfo aufgeführt. Weitere Informationen zur Verwendung dieser Formatbezeichner finden Sie unter Standardformatzeichenfolgen für Datum und Uhrzeit und Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit. Beachten Sie, dass jede Standardformatzeichenfolge einer Eigenschaft entspricht, DateTimeFormatInfo deren Wert eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit ist. Die einzelnen Spezifizierer in dieser benutzerdefinierten Formatzeichenfolge entsprechen wiederum anderen DateTimeFormatInfo Eigenschaften. Die Tabelle listet nur die Eigenschaften auf, für die die Standardformatzeichenfolgen Aliase sind, und listet keine Eigenschaften auf, auf die von benutzerdefinierten Formatzeichenfolgen zugegriffen werden kann, die diesen Aliaseigenschaften DateTimeFormatInfo zugewiesen sind. Darüber hinaus werden in der Tabelle nur benutzerdefinierte Formatbezeichner aufgeführt, die Eigenschaften DateTimeFormatInfo entsprechen.

Formatbezeichner Zugeordnete Eigenschaften
"d" (kurzes Datum; Standardformatzeichenfolge) ShortDatePattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"D" (langes Datum; Standardformatzeichenfolge) LongDatePattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"f" (vollständiges Datum/kurze Zeit; Standardformatzeichenfolge) LongDatePattern, um das Format der Datumskomponente der Ergebniszeichenfolge zu definieren.

ShortTimePattern, um das Format der Zeitkomponente der Ergebniszeichenfolge zu definieren.
"F" (vollständiges Datum/lange Zeit; Standardformatzeichenfolge) LongDatePattern, um das Format der Datumskomponente der Ergebniszeichenfolge zu definieren.

LongTimePattern, um das Format der Zeitkomponente der Ergebniszeichenfolge zu definieren.
"g" (allgemeines Datum/kurze Zeit; Standardformatzeichenfolge) ShortDatePattern, um das Format der Datumskomponente der Ergebniszeichenfolge zu definieren.

ShortTimePattern, um das Format der Zeitkomponente der Ergebniszeichenfolge zu definieren.
"G" (allgemeines Datum/lange Zeit; Standardformatzeichenfolge) ShortDatePattern, um das Format der Datumskomponente der Ergebniszeichenfolge zu definieren.

LongTimePattern, um das Format der Zeitkomponente der Ergebniszeichenfolge zu definieren.
"M", "m" (Monat/Tag; Standardformatzeichenfolge) MonthDayPattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"O", "o" (Roundtripdatum/-uhrzeit; Standardformatzeichenfolge) Keine.
"R", "r" (RFC1123; Standardformatzeichenfolge) RFC1123Pattern, um eine Ergebniszeichenfolge zu definieren, die dem RFC 1123-Standard entspricht. Die Eigenschaft ist schreibgeschützt.
"s" (sortierbares Datum/Uhrzeit; Standardformatzeichenfolge) SortableDateTimePattern, um eine Ergebniszeichenfolge zu definieren, die dem ISO 8601-Standard entspricht. Die Eigenschaft ist schreibgeschützt.
"t" (kurze Zeit; Standardformatzeichenfolge) ShortTimePattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"T" (lange Zeit; Standardformatzeichenfolge) LongTimePattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"u" (universal sortable date/time; standard format string) UniversalSortableDateTimePattern, um eine Ergebniszeichenfolge zu definieren, die dem ISO 8601-Standard für koordinierte Weltzeit entspricht. Die Eigenschaft ist schreibgeschützt.
"U" (universelles vollständiges Datum/Uhrzeit; Standardformatzeichenfolge) FullDateTimePattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"Y", "y" (Jahresmonat; Standardformatzeichenfolge) YearMonthPattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"ddd" (benutzerdefinierter Formatbezeichner) AbbreviatedDayNames, um den abgekürzten Namen des Wochentags in die Ergebniszeichenfolge ein.
"g", "gg" (benutzerdefinierter Formatbezeichner) Ruft die GetEraName -Methode auf, um den Namen des Zeitalters in die Ergebniszeichenfolge einfügungen.
"MMM" (benutzerdefinierter Formatbezeichner) AbbreviatedMonthNames, um den abgekürzten Monatsnamen in die Ergebniszeichenfolge ein include.
"MMMM" (benutzerdefinierter Formatbezeichner) MonthNames oder MonthGenitiveNames , um den vollständigen Monatsnamen in die Ergebniszeichenfolge ein include.
"t" (benutzerdefinierter Formatbezeichner) AMDesignator oder PMDesignator , um das erste Zeichen des AM/PM-Designators in die Ergebniszeichenfolge ein schließen zu können.
"tt" (benutzerdefinierter Formatbezeichner) AMDesignator oder PMDesignator , um den vollständigen AM/PM-Designator in die Ergebniszeichenfolge ein-
":" (benutzerdefinierter Formatbezeichner) TimeSeparator, um das Zeittrennzeichen in die Ergebniszeichenfolge ein schließen zu können.
"/" (benutzerdefinierter Formatbezeichner) DateSeparator, um das Datumstrennzeichen in die Ergebniszeichenfolge ein schließen zu können.

Ändern von DateTimeFormatInfo-Eigenschaften

Sie können die Von Datums- und Uhrzeitformatzeichenfolgen erzeugte Ergebniszeichenfolge ändern, indem Sie die zugeordneten Eigenschaften eines beschreibbaren Objekts DateTimeFormatInfo ändern. Verwenden Sie die -Eigenschaft, um zu bestimmen, ob ein DateTimeFormatInfo -Objekt beschreibbar IsReadOnly ist. So passen Sie DateTimeFormatInfo ein -Objekt auf diese Weise an:

  1. Erstellen Sie eine Lese-/Schreibkopie eines DateTimeFormatInfo Objekts, dessen Formatierungskonventionen Sie ändern möchten. (Weitere Informationen finden Sie im Abschnitt Instanziieren eines DateTimeFormatInfo-Objekts.)

  2. Ändern Sie die Eigenschaft oder die Eigenschaften, die verwendet werden, um die gewünschte Ergebniszeichenfolge zu erzeugen. (Informationen dazu, wie Formatierungsmethoden Eigenschaften verwenden, um Ergebniszeichenfolgen zu definieren, finden Sie im vorherigen Abschnitt DateTimeFormatInfo Formatzeichenfolgen und DateTimeFormatInfo-Eigenschaften.)

  3. Verwenden Sie das DateTimeFormatInfo benutzerdefinierte Objekt, das Sie in Aufrufen IFormatProvider von Formatierungsmethoden als Argument erstellt haben.

Es gibt zwei weitere Möglichkeiten, das Format einer Ergebniszeichenfolge zu ändern:

  • Sie können die -Klasse verwenden, um entweder eine benutzerdefinierte Kultur (eine Kultur, die einen eindeutigen Namen hat und vorhandene Kulturen ergänzt) oder eine Ersatzkultur (eine Kultur, die anstelle einer bestimmten Kultur verwendet wird) zu CultureAndRegionInfoBuilder definieren. Sie können diese Kultur programmgesteuert speichern und darauf zugreifen, wie Sie jedes objekt, das CultureInfo von der -.NET Framework.

  • Wenn die Ergebniszeichenfolge nicht kulturempfindlich ist und nicht einem vordefinierten Format folgt, können Sie eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit verwenden. Wenn Sie beispielsweise Datums- und Uhrzeitdaten im Format YYYYMMDDHHmmss serialisieren, können Sie die Ergebniszeichenfolge generieren, indem Sie die benutzerdefinierte Formatzeichenfolge an die -Methode übergeben. Sie können die Ergebniszeichenfolge durch Aufrufen der -Methode wieder in einen Wert DateTime.ToString(String) DateTime DateTime.ParseExact konvertieren.

Ändern des kurzen Datumsmusters

Im folgenden Beispiel wird das Format einer Ergebniszeichenfolge geändert, die von der Standardformatzeichenfolge "d" (kurzes Datum) erzeugt wird. Sie ändert die zugeordnete Eigenschaft für die Kultur "en-US" oder "English (USA)" von ihrem Standardwert ShortDatePattern "M/d/yyyy" in "yyyy'-"MM"-"dd" und verwendet die Standardformatzeichenfolge "d", um das Datum sowohl vor als auch nach der Änderung der Eigenschaft ShortDatePattern anzuzeigen.

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 Datumstrennzeichens

Im folgenden Beispiel wird das Datumstrennzeichen in einem -Objekt geändert, das DateTimeFormatInfo die Formatierungskonventionen der kultur fr-FR darstellt. Im Beispiel wird die Standardformatzeichenfolge "g" verwendet, um das Datum sowohl vor als auch nach der Änderung DateSeparator der Eigenschaft anzuzeigen.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime dateValue = new DateTime(2013, 08, 28);
      CultureInfo frFR = CultureInfo.CreateSpecificCulture("fr-FR");
      DateTimeFormatInfo dtfi = frFR.DateTimeFormat;

      Console.WriteLine("Before modifying DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));

      // Modify the date separator.
      dtfi.DateSeparator = "-";
      Console.WriteLine("After modifying the DateSeparator property: {0}",
                        dateValue.ToString("g", frFR));
   }
}
// The example displays the following output:
//       Before modifying DateSeparator property: 28/08/2013 00:00
//       After modifying the DateSeparator property: 28-08-2013 00:00
Imports System.Globalization

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

Ändern der Abkürzungen für Tagnamen und des Musters für lange Datumsnamen

In einigen Fällen ist das Muster für langes Datum, das in der Regel den Namen des ganzen Tages und Monats zusammen mit der Anzahl des Tages des Monats und des Jahres anzeigt, möglicherweise zu lang. Im folgenden Beispiel wird das lange Datumsmuster für die Kultur "en-US" verkürzt, um eine Abkürzung für einen Tag mit einem zeichenbasierten oder zwei Zeichen zurück zu geben, gefolgt von der Tagnummer, der Abkürzung für den Monatsnamen und dem Jahr. Hierzu werden dem Array kürzere Abkürzungen für Tagnamen zugewiesen, und die der -Eigenschaft zugewiesene benutzerdefinierte AbbreviatedDayNames Formatzeichenfolge wird LongDatePattern geändert. Dies wirkt sich auf die Ergebniszeichenfolgen aus, die von den Standardformatzeichenfolgen "D" und "f" zurückgegeben werden.

using System;
using System.Globalization;

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

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

      Console.WriteLine();

      // We don't want to change the FullDateTimePattern, so we need to save it.
      String originalFullDateTimePattern = dtfi.FullDateTimePattern;

      // Modify day name abbreviations and long date pattern.
      dtfi.AbbreviatedDayNames = new String[] { "Su", "M", "Tu", "W", "Th", "F", "Sa" };
      dtfi.LongDatePattern = "ddd dd-MMM-yyyy";
      dtfi.FullDateTimePattern = originalFullDateTimePattern;
      foreach (var fmt in formats)
         Console.WriteLine("{0}: {1}", fmt, value.ToString(fmt, dtfi));
   }
}
// The example displays the following output:
//       D: Tuesday, July 9, 2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tuesday, July 9, 2013 12:00 AM
//
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 9, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM
Imports System.Globalization

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

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

Normalerweise wirkt sich die Änderung an der -Eigenschaft auch auf die -Eigenschaft aus, die wiederum die Ergebniszeichenfolge definiert, die von der LongDatePattern FullDateTimePattern Standardformatzeichenfolge "F" zurückgegeben wird. Um das ursprüngliche vollständige Datums- und Uhrzeitmuster zu erhalten, weist das Beispiel die ursprüngliche benutzerdefinierte Formatzeichenfolge, die der -Eigenschaft zugewiesen ist, nach der Änderung FullDateTimePattern LongDatePattern der -Eigenschaft neu zu.

Wechsel von einer 12-Stunden-Uhr zu einer 24-Stunden-Uhr

Für viele Kulturen in der .NET Framework wird die Uhrzeit mit einer 12-Stunden-Uhr und einem AM/PM-Designator ausgedrückt. Im folgenden Beispiel wird eine -Methode definiert, die jedes Zeitformat ersetzt, das eine 12-Stunden-Uhr verwendet, durch ein Format, das eine ReplaceWith24HourClock 24-Stunden-Uhr verwendet.

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 Formatzeichenfolge zu ändern. Das Muster für reguläre @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) Ausdrücke ist wie folgt definiert:

Muster Beschreibung
^ Beginnt die Suche am Anfang der Zeichenfolge.
(?<openAMPM>\s*t+\s*)? Übereinstimmung mit null oder einem Vorkommen von null oder mehr Leerzeichen, gefolgt vom Buchstaben "t" ein oder mehrere Male, gefolgt von null oder mehr Leerzeichen. Diese Erfassungsgruppe heißt openAMPM .
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Wenn die Gruppe eine Übereinstimmung hat, müssen Sie den Buchstaben "h" ein oder mehrere Male ab suchen, gefolgt von einem oder mehr Zeichen, die weder openAMPM "h" noch "t" sind. Die Übereinstimmung endet am Ende der Zeichenfolge. Alle zeichen, die nach "h" erfasst werden, sind in einer Erfassungsgruppe mit dem Namen nonHours enthalten.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Wenn die Gruppe keine Übereinstimmung hat, müssen Sie den Buchstaben "h" ein oder mehrere Male ab suchen, gefolgt von mindestens einem Zeichen, das weder "h" noch "t" ist, gefolgt von null oder mehr openAMPM Leerzeichen. Übereinstimmung mit einem oder mehr Vorkommen des Buchstabens "t". Alle Zeichen, die nach "h" und vor den Leerzeichen und "t" erfasst werden, sind in einer Erfassungsgruppe namens nonHours enthalten.

Die Erfassungsgruppe enthält die Minute und ggf. die zweite Komponente einer benutzerdefinierten Formatzeichenfolge für Datum und Uhrzeit sowie nonHours alle Zeittrennzeichen. Das Ersetzungsmuster wird diesen Elementen die Teilzeichenfolge HH${nonHours} "HH" vorausbeenden.

Anzeigen und Ändern des Zeitalters in einem Datum

Im folgenden Beispiel wird der benutzerdefinierte Formatbezeichner "g" zur -Eigenschaft eines -Objekts addiert, das die Formatierungskonventionen der LongDatePattern Kultur "en-US" darstellt. Diese Addition wirkt sich auf die folgenden drei Standardformatzeichenfolgen aus:

  • Die Standardformatzeichenfolge "D" (langes Datum), die direkt der -Eigenschaft LongDatePattern entspricht.

  • Die Standardformatzeichenfolge "f" (vollständiges Datum/kurze Zeit), die eine Ergebniszeichenfolge erzeugt, die die von den Eigenschaften und erzeugten Teilzeichenfolgen LongDatePattern ShortTimePattern verkettet.

  • Die Standardformatzeichenfolge "F" (vollständiges Datum/lange Zeit), die direkt der -Eigenschaft FullDateTimePattern entspricht. Da wir diesen Eigenschaftswert nicht explizit festgelegt haben, wird er dynamisch durch Verkettung der Eigenschaften und LongDatePattern LongTimePattern generiert.

Das Beispiel zeigt auch, wie sie den Namen des Zeitalters für eine Kultur ändern, deren Kalender über einen einzelnen 1.000.000-Jahr-Kalender verfügt. In diesem Fall verwendet die Kultur en-US den gregorianischen Kalender, der durch ein -Objekt dargestellt GregorianCalendar wird. Die GregorianCalendar -Klasse unterstützt eine einzelne Zeitrechnung, die als A.D. bezeichnet wird. (Anno Domini). Im Beispiel wird der Name des Zeitalters in C.E. geändert. (Common Era) durch Ersetzen des benutzerdefinierten Formatbezeichners "g" in der Formatzeichenfolge, die der -Eigenschaft zugewiesen FullDateTimePattern ist, durch eine Literalzeichenfolge. Die Verwendung einer literalen Zeichenfolge ist erforderlich, da der Name des Zeitalters in der Regel von der -Methode aus privaten Daten in den Kulturtabellen zurückgegeben wird, die entweder vom .NET Framework- oder vom Windows bereitgestellt GetEraName werden.

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 Uhrzeit

Bei der Analyse wird die Zeichenfolgendarstellung eines Datums und einer Uhrzeit in einen - oder DateTime -Wert DateTimeOffset konvertiert. Beide Typen enthalten die Methoden Parse , , und zur Unterstützung von TryParse ParseExact TryParseExact Analysevorgängen. Die Methoden und konvertieren eine Zeichenfolge, die eine Vielzahl von Formaten haben kann, wohingegen und erfordern, dass die Zeichenfolge Parse TryParse ein ParseExact TryParseExact definiertes Format oder formatiert. Wenn der Analysevorgang fehlschlägt und Parse ParseExact eine Ausnahme auslöst, während und TryParse TryParseExact false zurückgeben.

Die Analysemethoden verwenden implizit oder explizit einen -Enumerationswert, um zu bestimmen, welche Stilelemente (z. B. führende, nach trailende oder innere Leerzeichen) in der zu analysierenden Zeichenfolge vorhanden sein können und wie die analysierte Zeichenfolge oder fehlende Elemente interpretiert DateTimeStyles werden. Wenn Sie beim Aufrufen der - oder -Methode keinen Wert bereitstellen, ist der Standardwert . Dies ist ein zusammengesetzter Stil, der die DateTimeStyles Parse TryParse DateTimeStyles.AllowWhiteSpaces DateTimeStyles.AllowLeadingWhite DateTimeStyles.AllowTrailingWhite Flags , und DateTimeStyles.AllowInnerWhite enthält. Für die Methoden und ist der Standardwert . Die Eingabezeichenfolge muss genau einer bestimmten benutzerdefinierten Formatzeichenfolge für Datum ParseExact TryParseExact und Uhrzeit DateTimeStyles.None entsprechen.

Die Analysemethoden verwenden auch implizit oder explizit ein -Objekt, das die spezifischen Symbole und Muster definiert, die in der zu analysierenden DateTimeFormatInfo Zeichenfolge auftreten können. Wenn Sie kein -Objekt bereitstellen, wird standardmäßig das -Objekt für die aktuelle DateTimeFormatInfo DateTimeFormatInfo Threadkultur verwendet. Weitere Informationen zum Analyse von Datums- und Uhrzeitzeichenfolgen finden Sie in den einzelnen Analysemethoden wie DateTime.Parse , DateTime.TryParse , und DateTimeOffset.ParseExact DateTimeOffset.TryParseExact .

Das folgende Beispiel veranschaulicht die kultursensible Natur der Analyse von Datums- und Uhrzeitzeichenfolgen. Es wird versucht, zwei Datumszeichenfolgen anhand der Konventionen der Kulturen en-US, en-GB, fr-FR und fi-FI zu analysieren. Das Datum, das in der Kultur "en-US" als 18.8.2014 interpretiert wird, löst in den anderen drei Kulturen eine Ausnahme aus, da 18 als Monatszahl interpretiert FormatException wird. 2.1.2015 wird als zweiter Tag des ersten Monats in der Kultur "en-US" analysiert, in den übrigen Kulturen jedoch als erster Tag des zweiten Monats.

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 Uhrzeitzeichenfolgen werden in der Regel aus zwei Gründen analysiert:

  • Um Benutzereingaben in einen Datums- und Uhrzeitwert zu konvertieren.

  • Zum Roundtrip eines Datums- und Uhrzeitwerts; das heißt, um einen Datums- und Uhrzeitwert zu deserialisieren, der zuvor als Zeichenfolge serialisiert wurde.

In den folgenden Abschnitten werden diese beiden Vorgänge ausführlicher erläutert.

Analyse von Benutzerzeichenfolgen

Wenn Sie vom Benutzer eingegebene Datums- und Uhrzeitzeichenfolgen analysieren, sollten Sie immer ein -Objekt instanziieren, das die Kultureinstellungen des Benutzers widerspiegelt, einschließlich aller Anpassungen, die der Benutzer DateTimeFormatInfo möglicherweise vorgenommen hat. Andernfalls weisen das Datums- und Uhrzeitobjekt möglicherweise falsche Werte auf. Informationen zum Instanziieren eines -Objekts, das kulturelle Anpassungen von DateTimeFormatInfo Benutzern widerspiegelt, finden Sie im Abschnitt DateTimeFormatInfo und dynamische Daten.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem Analysevorgang, der die kulturellen Einstellungen von Benutzern widerspiegelt, und einem Vorgang, der dies nicht tut. In diesem Fall lautet die Standardsystemkultur en-US, aber der Benutzer hat Systemsteuerung, Region und Sprache verwendet, um das kurze Datumsmuster von seinem Standardwert "M/d/yyyy" in "yy/MM/dd" zu ändern. Wenn der Benutzer eine Zeichenfolge eingibt, die Benutzereinstellungen widerspiegelt, und die Zeichenfolge von einem -Objekt analysiert DateTimeFormatInfo wird, das auch Benutzereinstellungen (Außerkraftsetzungen) wiedergibt, gibt der Analysevorgang ein korrektes Ergebnis zurück. Wenn die Zeichenfolge jedoch von einem -Objekt analysiert wird, DateTimeFormatInfo das die en-US-Standardkultureinstellungen wiedergibt, löst die Analysemethode eine Ausnahme aus, FormatException da sie 14 als Anzahl des Monats interpretiert, nicht als die letzten beiden Ziffern des Jahres.

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 Uhrzeitdaten

Für serialisierte Datums- und Uhrzeitdaten wird ein Roundtrip erwartet. Das heißt, alle serialisierten und deserialisierten Werte sollten identisch sein. Wenn ein Datums- und Uhrzeitwert einen einzelnen Zeitpunkt darstellt, sollte der deserialisierte Wert unabhängig von der Kultur oder Zeitzone des Systems, in dem er wiederhergestellt wurde, den gleichen Zeitpunkt darstellen. Zum erfolgreichen Roundtrip von Datums- und Uhrzeitdaten müssen Sie die Konventionen der invarianten Kultur verwenden, die von der -Eigenschaft zurückgegeben InvariantInfo wird, um die Daten zu generieren und zu analysieren. Die Formatierungs- und Analysevorgänge sollten nie die Konventionen der Standardkultur widerspiegeln. Wenn Sie kulturelle Standardeinstellungen verwenden, ist die Portabilität der Daten streng beschränkt. Sie kann nur in einem Thread deserialisiert werden, dessen kulturspezifische Einstellungen mit denen des Threads identisch sind, für den sie serialisiert wurde. In einigen Fällen bedeutet dies, dass die Daten nicht einmal erfolgreich im selben System serialisiert und deserialisiert werden können.

Wenn die Zeitkomponente eines Datums- und Uhrzeitwerts signifikant ist, sollte sie auch in UTC konvertiert und mithilfe der Standardformatzeichenfolge"o" oder "r" serialisiert werden. Die Zeitdaten können dann wiederhergestellt werden, indem eine Analysemethode aufgerufen und die entsprechende Formatzeichenfolge zusammen mit der invarianten Kultur als Argument übergeben provider wird.

Das folgende Beispiel veranschaulicht den Prozess des Roundtrips eines Datums- und Uhrzeitwerts. Es serialisiert ein Datum und eine Uhrzeit auf einem System, das die US-Pacific-Zeit beachtet und deren aktuelle Kultur en-US ist.

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)

Sie deserialisiert die Daten in einem System in der Zeitzone "Paris", "Paris", und deren aktuelle Kultur "fr-FR" lautet. Das wiederhergestellte Datum liegt neun Stunden nach dem ursprünglichen Datum, das die Zeitzonenanpassung von acht Stunden hinter UTC in eine Stunde vor UTC widerspiegelt. Sowohl das ursprüngliche Datum als auch das wiederhergestellte Datum stellen denselben Zeitpunkt dar.

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()

Initialisiert eine neue, schreibbare Instanz der DateTimeFormatInfo-Klasse, die kulturunabhängig (invariant) ist.

Eigenschaften

AbbreviatedDayNames

Ruft ein eindimensionales Array vom Typ String ab, das die kulturabhängigen abgekürzten Namen der Wochentage enthält, oder legt dieses fest.

AbbreviatedMonthGenitiveNames

Ruft ein Zeichenfolgenarray der abgekürzten Monatsnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt dieses fest.

AbbreviatedMonthNames

Ruft ein eindimensionales Zeichenfolgenarray ab, das die kulturabhängigen abgekürzten Namen der Monate enthält, oder legt dieses fest.

AMDesignator

Ruft den Zeichenfolgenkennzeichner für Zeitangaben vor 12 Uhr mittags („ante meridiem“, a.m.) ab oder legt diesen fest.

Calendar

Ruft den für die aktuelle Kultur zu verwendenden Kalender ab oder legen diesen fest.

CalendarWeekRule

Ruft einen Wert ab, der die Regel zum Bestimmen der ersten Kalenderwoche eines Jahres angibt, oder legt diesen fest.

CurrentInfo

Ruft ein schreibgeschütztes DateTimeFormatInfo-Objekt ab, das Werte basierend auf der aktuellen Kultur formatiert.

DateSeparator

Ruft die Zeichenfolge ab, die die Datumskomponenten trennt, d. h. Jahr, Monat und Tag, oder legt diese fest.

DayNames

Ruft ein eindimensionales Zeichenfolgenarray ab, das die kulturabhängigen vollständigen Namen der Wochentage enthält, oder legt dieses fest.

FirstDayOfWeek

Ruft den ersten Tag der Woche ab oder legt diesen fest.

FullDateTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen langen Datums- und Uhrzeitwert ab oder legt dieses fest.

InvariantInfo

Ruft das schreibgeschützte DateTimeFormatInfo-Standardobjekt ab, das kulturunabhängig (invariant) ist.

IsReadOnly

Ruft einen Wert ab, der angibt, ob das DateTimeFormatInfo schreibgeschützt ist.

LongDatePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen langen Datumswert ab oder legt diese fest.

LongTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen langen Uhrzeitwert ab oder legt diese fest.

MonthDayPattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen Monats- und Tageswert ab oder legt diese fest.

MonthGenitiveNames

Ruft ein Zeichenfolgenarray der Monatsnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt dieses fest.

MonthNames

Ruft ein eindimensionales Array vom Typ String ab, das die kulturabhängigen vollständigen Namen der Monate enthält, oder legt dieses fest.

NativeCalendarName

Ruft den systemeigenen Namen des Kalenders ab, der dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.

PMDesignator

Ruft den Zeichenfolgenkennzeichner für Zeitangaben nach 12 Uhr mittags ("post meridiem", p.m.) ab oder legt diesen fest.

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.

ShortDatePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen kurzen Datumswert ab oder legt diese fest.

ShortestDayNames

Ruft ein Zeichenfolgenarray der am stärksten abgekürzten, eindeutigen Tagesnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt diese fest.

ShortTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen kurzen Uhrzeitwert ab oder legt diese fest.

SortableDateTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen sortierbaren Datums-und Zeitwert ab.

TimeSeparator

Ruft die Zeichenfolge ab, die die Bestandteile der Uhrzeit trennt, d. h. Stunde, Minuten und Sekunden, oder legt diese fest.

UniversalSortableDateTimePattern

Ruft die benutzerdefinierte Formatzeichenfolge für eine universelle sortierbare Datums- und Zeitzeichenfolge gemäß ISO 8601 ab.

YearMonthPattern

Ruft die benutzerdefinierte Formatzeichenfolge für einen Jahres- und Monatswert ab oder legt diese fest.

Methoden

Clone()

Erstellt eine flache Kopie von DateTimeFormatInfo.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetAbbreviatedDayName(DayOfWeek)

Gibt den kulturabhängigen abgekürzten Namen des angegebenen Wochentags entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.

GetAbbreviatedEraName(Int32)

Gibt die Zeichenfolge zurück, die den abgekürzten Namen des angegebenen Zeitraums enthält, sofern eine Abkürzung vorhanden ist.

GetAbbreviatedMonthName(Int32)

Gibt den kulturabhängigen abgekürzten Namen des angegebenen Monats entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.

GetAllDateTimePatterns()

Gibt alle Standardmuster zurück, in denen Datums- und Zeitwerte formatiert werden können.

GetAllDateTimePatterns(Char)

Gibt alle Muster zurück, in denen Datums- und Zeitwerte mit der angegebenen Standardformatzeichenfolge formatiert werden können.

GetDayName(DayOfWeek)

Gibt den kulturabhängigen vollständigen Namen des angegebenen Wochentags entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.

GetEra(String)

Gibt die Ganzzahl zurück, die den angegebenen Zeitraum darstellt.

GetEraName(Int32)

Gibt die Zeichenfolge mit dem Namen des angegebenen Zeitraums zurück.

GetFormat(Type)

Gibt ein Objekt vom angegebenen Typ zurück, das einen Datum-und Zeit-Formatierungsdienst bereitstellt.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetInstance(IFormatProvider)

Gibt das DateTimeFormatInfo-Objekt zurück, das dem angegebenen IFormatProvider zugeordnet ist.

GetMonthName(Int32)

Gibt den kulturabhängigen vollständigen Namen des angegebenen Monats entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.

GetShortestDayName(DayOfWeek)

Ruft den am stärksten abgekürzten Tagesnamen für einen angegebenen Wochentag ab, der dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ReadOnly(DateTimeFormatInfo)

Gibt einen schreibgeschützten DateTimeFormatInfo-Wrapper zurück.

SetAllDateTimePatterns(String[], Char)

Legt die benutzerdefinierten Formatzeichenfolgen für Datum und Uhrzeit fest, die einer angegebenen Standardformatzeichenfolge entsprechen.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt SerializationInfo mit den Daten auf, die zur Serialisierung des Zielobjekts benötigt werden.

Gilt für

Siehe auch