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 die Spiegelung verwendet, um die Eigenschaften des Objekts für die DateTimeFormatInfo englische Kultur (USA) abzurufen. Es zeigt den Wert dieser Eigenschaften an, die benutzerdefinierte Formatzeichenfolgen enthalten und diese Zeichenfolgen zum Anzeigen formatierter Datumsangaben verwendet.

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 DateTimeFormatInfo Klasse enthalten kulturspezifische Informationen zum Formatieren oder Analysieren von Datums- und Uhrzeitwerten wie den folgenden:

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

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

  • Die Namen der Tage der Woche.

  • Die Namen der Monate des Jahres.

  • Die 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 jeder Objekttyp DateTimeFormatInfo instanziiert wird.

Instanziieren eines DateTimeFormatInfo-Objekts für die invariante Kultur

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

Im folgenden Beispiel werden jede dieser Methoden verwendet, um ein DateTimeFormatInfo Objekt zu instanziieren, 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 bestimmte Kultur, die die englische Sprache darstellt, die in der USA gesprochen wird, und en-CA ist eine bestimmte Kultur, die die Englischsprache darstellt, die in Kanada gesprochen wird. Sie können ein DateTimeFormatInfo Objekt instanziieren, das die Formatierungskonventionen einer bestimmten Kultur auf folgende Weise darstellt:

Im folgenden Beispiel wird jede dieser Möglichkeiten veranschaulicht, ein DateTimeFormatInfo Objekt instanziieren zu können und angibt, ob das resultierende Objekt 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 unabhängig von einem Land/einer Region ist; es ist in der Regel das übergeordnete Element einer oder mehrerer spezifischer Kulturen. Beispielsweise ist Fr eine neutrale Kultur für die französische Sprache und das Übergeordnete der fr-FR-Kultur. Sie können ein DateTimeFormatInfo Objekt instanziieren, das die Formatierungskonventionen einer neutralen Kultur auf dieselbe Weise darstellt, wie Sie ein DateTimeFormatInfo Objekt erstellen, das die Formatierungskonventionen einer bestimmten Kultur darstellt. Darüber hinaus können Sie das Objekt einer neutralen DateTimeFormatInfo Kultur abrufen, indem Sie eine neutrale Kultur aus der Eigenschaft einer bestimmten Kultur CultureInfo.Parent abrufen und das DateTimeFormatInfo von der CultureInfo.DateTimeFormat Eigenschaft zurückgegebene Objekt abrufen. Es sei denn, die übergeordnete Kultur stellt die invariante Kultur dar, das zurückgegebene DateTimeFormatInfo Objekt ist lese-/schreibzugriff. Im folgenden Beispiel werden diese Methoden zum Instanziieren eines DateTimeFormatInfo Objekts 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 versucht, ein DateTimeFormatInfo Objekt abzurufen, das die Formatierungskonventionen einer neutralen Kultur widerspiegelt, löst eine NotSupportedException Ausnahme aus.

Eine neutrale Kultur fehlt jedoch kulturspezifische Formatierungsinformationen, da sie unabhängig von einem bestimmten Land/einer bestimmten Region ist. Anstatt das DateTimeFormatInfo Objekt mit generischen Werten aufzufüllen, gibt das .NET Framework ein DateTimeFormatInfo Objekt zurück, das die Formatierungskonventionen einer bestimmten Kultur widerspiegelt, die ein untergeordnetes Element der neutralen Kultur ist. Das Objekt für die neutrale Kultur spiegelt beispielsweise die Formatierungskonventionen der en-US-Kultur wider, und das DateTimeFormatInfo DateTimeFormatInfo Objekt für die fr-Kultur spiegelt die Formatierungskonventionen der fr-FR-Kultur wider.

Sie können Code wie das folgende verwenden, um zu bestimmen, welche Formatierungskonventionen einer bestimmten Kultur eine neutrale Kultur darstellt. Im Beispiel wird die Spiegelung verwendet, um die DateTimeFormatInfo Eigenschaften einer neutralen Kultur mit den Eigenschaften einer bestimmten untergeordneten Kultur zu vergleichen. Es betrachtet zwei Kalender als gleichwertig, wenn es sich um denselben Kalendertyp handelt und für Gregorianische Kalender, wenn ihre GregorianCalendar.CalendarType Eigenschaften identische Werte haben.

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 DateTimeFormatInfo Objekt instanziieren, das die Formatierungskonventionen der aktuellen Kultur auf folgende Weise darstellt:

Im folgenden Beispiel werden jede dieser Methoden verwendet, um ein DateTimeFormatInfo Objekt zu instanziieren, das die 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 schreibbares DateTimeFormatInfo Objekt erstellen, das die Konventionen der aktuellen Kultur auf eine der folgenden Arten darstellt:

Im folgenden Beispiel wird jede Art von Instanziierung eines Lese-/Schreibobjekts DateTimeFormatInfo veranschaulicht und der Wert seiner IsReadOnly Eigenschaft angezeigt.

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 Eigenschaftenwerte außer Kraft setzen, die DateTimeFormatInfo in Formatierungs- und Analysevorgängen über die Region- und Sprachanwendung in Systemsteuerung verwendet werden. Ein Benutzer, dessen Kultur englisch (USA) ist, kann beispielsweise auswählen, dass lange Zeitwerte mithilfe einer 24-Stunden-Uhr (im Format HH:mm:ss) anstelle der Standard-12-Stunden-Uhr (im Format h:mm:ss tt) angezeigt werden. Die objekte, die DateTimeFormatInfo in den zuvor beschriebenen Methoden abgerufen wurden, spiegeln diese Benutzerüberschreibungen wider. Wenn dies unerwünscht ist, können Sie ein NumberFormatInfo Objekt erstellen, das keine Benutzerüberschreibungen (und nicht schreibgeschützt) enthält, indem Sie den CultureInfo.CultureInfo(String, Boolean) Konstruktor aufrufen und einen Wert false für das useUserOverride Argument angeben. Im folgenden Beispiel wird dies für ein System veranschaulicht, dessen aktuelle Kultur Englisch (USA) ist und dessen lange Zeitmuster von der Standardeinstellung von 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, genauso wie Kulturdaten, die von der DateTimeFormatInfo CultureInfo Klasse bereitgestellt werden. Sie sollten keine Annahmen über die Stabilität von Werten für DateTimeFormatInfo Objekte vornehmen, die bestimmten CultureInfo Objekten zugeordnet sind. Nur die von der invarianten Kultur bereitgestellten Daten und das zugehörige DateTimeFormatInfo Objekt 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 Einstellungen wie z. B. den bevorzugten Kalender oder die üblichen Datums- und Uhrzeitformate ändern sich im Laufe der Zeit. Wenn dies geschieht, enthält Windows Update Änderungen an dem DateTimeFormatInfo Eigenschaftswert für eine bestimmte Kultur.

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

  • Kaskadieren von Änderungen an Eigenschaftenwerten. Eine Reihe von kulturbezogenen Eigenschaften kann sich zur Laufzeit ändern, was wiederum DateTimeFormatInfo dazu führt, dass Daten geändert werden. Beispielsweise kann die aktuelle Kultur programmgesteuert oder über Benutzeraktionen geändert werden. Wenn dies geschieht, ändert sich das DateTimeFormatInfo von der CurrentInfo Eigenschaft zurückgegebene Objekt in einem Objekt, das der aktuellen Kultur zugeordnet ist. Ebenso kann sich der Kalender eines Kulturkalenders ändern, was zu Änderungen an zahlreichen DateTimeFormatInfo Eigenschaftenwerten führen kann.

  • Benutzereinstellungen. Benutzer Ihrer Anwendung können einige der Werte außer Kraft setzen, die der aktuellen Systemkultur zugeordnet sind, durch die regionalen und Sprachoptionen in Systemsteuerung. Beispielsweise können Benutzer das Datum in einem anderen Format anzeigen. Wenn die CultureInfo.UseUserOverride Eigenschaft auf truefestgelegt ist, wird die Eigenschaften des DateTimeFormatInfo Objekts auch aus den Benutzereinstellungen abgerufen. Wenn die Benutzereinstellungen nicht mit der Kultur kompatibel sind, die dem Objekt zugeordnet CultureInfo ist (z. B. wenn der ausgewählte Kalender nicht einer der kalender ist, die von der OptionalCalendars Eigenschaft angegeben sind), werden die Ergebnisse der Methoden und die Werte der Eigenschaften nicht definiert.

Um die Möglichkeit inkonsistenter Daten zu minimieren, werden alle benutzerüberschreibbaren Eigenschaften eines DateTimeFormatInfo Objekts initialisiert, wenn das Objekt erstellt wird. Es gibt immer noch eine Möglichkeit der Unkonsistität, da weder die Objekterstellung noch der Benutzerüberschreibungsprozess atomistisch ist und die relevanten Werte während der Objekterstellung geändert werden können. Diese Situation sollte jedoch extrem selten sein.

Sie können steuern, ob Benutzerüberschreibungen in DateTimeFormatInfo Objekten angezeigt werden, die dieselbe Kultur wie die Systemkultur darstellen. In der folgenden Tabelle sind die Methoden aufgeführt, auf denen ein DateTimeFormatInfo Objekt abgerufen werden kann und angibt, ob das resultierende Objekt benutzerüberschrieben ist.

Quelle des CultureInfo- und DateTimeFormatInfo-Objekts Zeigt Benutzerüberschreibungen an
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

Es sei denn, es gibt einen zwingenden Grund, andernfalls Benutzerüberschreibungen zu berücksichtigen, wenn Sie das DateTimeFormatInfo Objekt in Clientanwendungen verwenden, um Benutzereingaben zu formatieren und zu analysieren oder Daten anzuzeigen. Für Serveranwendungen oder unbeaufsichtigte Anwendungen sollten Sie nicht. Wenn Sie das DateTimeFormatInfo Objekt jedoch entweder explizit oder implizit zum Beibehalten von Datums- und Uhrzeitdaten in Zeichenfolgenformular verwenden, sollten Sie entweder ein Objekt verwenden, das die Formatierungskonventionen der invarianten Kultur widerspiegelt, oder Sie sollten eine DateTimeFormatInfo benutzerdefinierte Datums- und Uhrzeitformatzeichenfolge angeben, die Sie unabhängig von der Kultur verwenden.

Formatieren von Datums- und Uhrzeitangaben

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

Alle Datums- und Uhrzeitformatierungsvorgänge verwenden eine IFormatProvider Implementierung. Die IFormatProvider Schnittstelle enthält eine einzelne Methode, IFormatProvider.GetFormat(Type). Diese Rückrufmethode wird ein Type Objekt übergeben, das den Typ darstellt, der zum Bereitstellen von Formatierungsinformationen benötigt wird. Die Methode gibt entweder eine Instanz dieses Typs zurück oder null wenn sie keine Instanz des Typs bereitstellen kann. Die .NET Framework enthält zwei IFormatProvider Implementierungen für die Formatierung von Datums- und Uhrzeitangaben:

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

Im folgenden Beispiel wird die Beziehung zwischen der IFormatProvider Schnittstelle und der DateTimeFormatInfo Klasse in Formatierungsvorgängen veranschaulicht. Es definiert eine benutzerdefinierte IFormatProvider Implementierung, deren GetFormat Methode den Vom Formatierungsvorgang angeforderten Objekttyp anzeigt. Wenn ein DateTimeFormatInfo Objekt angefordert wird, stellt die Methode das Objekt für die DateTimeFormatInfo aktuelle Kultur bereit. Wie die Ausgabe aus dem Beispiel zeigt, fordert die Decimal.ToString(IFormatProvider) Methode ein DateTimeFormatInfo Objekt an, Formatierungsinformationen bereitzustellen, während die String.Format(IFormatProvider, String, Object[]) Methodenanforderungen NumberFormatInfo und DateTimeFormatInfo -objekte sowie eine ICustomFormatter Implementierung erforderlich sind.

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

Formatieren von Zeichenfolgen und DateTimeFormatInfo-Eigenschaften

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

Die Standarddatums- und Uhrzeitformatzeichenfolgen, z. B. "d", "d", "f", und "F", sind Aliase, die bestimmten DateTimeFormatInfo Formatmustereigenschaften entsprechen. Die meisten der benutzerdefinierten Datums- und Uhrzeitformatzeichenfolgen beziehen sich auf Zeichenfolgen oder Unterzeichenfolgen, die ein Formatierungsvorgang in den Ergebnisstrom einfügt. In der folgenden Tabelle sind die standard- und benutzerdefinierten Datums- und Uhrzeitformatspezifizierer und die zugehörigen DateTimeFormatInfo Eigenschaften aufgeführt. Ausführliche Informationen zum Verwenden dieser Formatspezifikationen finden Sie unter Standarddatums- und Uhrzeitformatzeichenfolgen und benutzerdefinierte Datums- und Uhrzeitformatzeichenfolgen. Beachten Sie, dass jede Standardformatzeichenfolge einer DateTimeFormatInfo Eigenschaft entspricht, deren Wert eine benutzerdefinierte Datums- und Uhrzeitformatzeichenfolge ist. Die einzelnen Bezeichner in dieser benutzerdefinierten Formatzeichenfolge entsprechen wiederum anderen DateTimeFormatInfo Eigenschaften. In der Tabelle sind nur die Eigenschaften aufgeführt, für die die Standardformatzeichenfolgen Aliase sind und keine Eigenschaften auflisten, auf die möglicherweise durch benutzerdefinierte Formatzeichenfolgen zugegriffen werden kann, die DateTimeFormatInfo diesen aliasen Eigenschaften zugewiesen sind. Darüber hinaus listet die Tabelle nur benutzerdefinierte Formatbezeichner auf, die Eigenschaften entsprechen DateTimeFormatInfo .

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" (Round-Trip-Datum/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" (universelle sortierbare Datum/Uhrzeit; Standardformatzeichenfolge) UniversalSortableDateTimePattern, um eine Ergebniszeichenfolge zu definieren, die dem ISO 8601-Standard für koordinierte universelle Zeit entspricht. Die Eigenschaft ist schreibgeschützt.
"U" (universelle vollständige Datum/Uhrzeit; Standardformatzeichenfolge) FullDateTimePattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"Y", "y" (Jahrmonat; Standardformatzeichenfolge) YearMonthPattern, um das Gesamtformat der Ergebniszeichenfolge zu definieren.
"ddd" (benutzerdefinierter Formatbezeichner) AbbreviatedDayNames, um den abgekürzten Namen des Wochentags in die Ergebniszeichenfolge einzuschließen.
"g", "gg" (benutzerdefinierter Formatbezeichner) Ruft die GetEraName Methode auf, um den Namen der Ära in die Ergebniszeichenfolge einzufügen.
"MMM" (benutzerdefinierter Formatbezeichner) AbbreviatedMonthNames, um den abgekürzten Monatsnamen in die Ergebniszeichenfolge einzuschließen.
"MMMM" (benutzerdefinierter Formatbezeichner) MonthNames oder MonthGenitiveNames, um den vollständigen Monatsnamen in die Ergebniszeichenfolge einzuschließen.
"t" (benutzerdefinierter Formatbezeichner) AMDesignator oder PMDesignator, um das erste Zeichen des AM/PM-Designators in die Ergebniszeichenfolge einzuschließen.
"tt" (benutzerdefinierter Formatbezeichner) AMDesignator oder PMDesignator, um den vollständigen AM/PM-Designator in die Ergebniszeichenfolge einzuschließen.
":" (benutzerdefinierter Formatbezeichner) TimeSeparator, um das Zeittrennzeichen in die Ergebniszeichenfolge einzuschließen.
"/" (benutzerdefinierter Formatbezeichner) DateSeparator, um das Datumstrennzeichen in die Ergebniszeichenfolge einzuschließen.

Ändern von DateTimeFormatInfo-Eigenschaften

Sie können die Ergebniszeichenfolge ändern, die nach Datums- und Uhrzeitformatzeichenfolgen erstellt wird, indem Sie die zugeordneten Eigenschaften eines schreibbaren DateTimeFormatInfo Objekts ändern. Verwenden Sie die IsReadOnly Eigenschaft, um festzustellen, ob ein DateTimeFormatInfo Objekt schreibbar ist. So passen Sie ein DateTimeFormatInfo Objekt auf diese Weise an:

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

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

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

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

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

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

Ändern des kurzen Datumsmusters

Im folgenden Beispiel wird das Format einer Ergebniszeichenfolge geändert, die von der Standardformatzeichenfolge "d" (short date) erstellt wird. Sie ändert die zugeordnete ShortDatePattern Eigenschaft für die en-US- oder Englisch -Kultur (USA) von der Standardformatzeichenfolge "M/d/d/y" in "yy'-"MM"-"-"dd" und verwendet die Standardformatzeichenfolge "d", um das Datum sowohl vor als auch nach der Änderung der ShortDatePattern Eigenschaft 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 DateTimeFormatInfo Objekt geändert, das die Formatierungskonventionen der fr-FR-Kultur darstellt. Im Beispiel wird die Standardformatzeichenfolge "g" verwendet, um das Datum sowohl vor als auch nach der Änderung der DateSeparator 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 des Tages und des langen Datumsmusters

In einigen Fällen kann das lange Datumsmuster, das in der Regel den vollständigen Tag- und Monatsnamen zusammen mit der Anzahl des Monats und des Jahres anzeigt, zu lang sein. Im folgenden Beispiel wird das lange Datumsmuster für die en-US-Kultur gekürzt, um eine Abkürzung für einen oder zwei Zeichennamen gefolgt von der Tagesnummer, der Monatsnamenskürzel und dem Jahr zurückzugeben. Dies geschieht durch Zuweisen von Abkürzungen für kürzere Tagnamen zum Array und durch Ändern der benutzerdefinierten Formatzeichenfolge, die AbbreviatedDayNames der LongDatePattern Eigenschaft zugewiesen ist. 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

Ordinarily wirkt sich die Änderung der LongDatePattern Eigenschaft auch auf die FullDateTimePattern Eigenschaft aus, wodurch wiederum die ergebniszeichenfolge definiert wird, die von der Standardformatzeichenfolge "F" zurückgegeben wird. Um das ursprüngliche vollständige Datums- und Uhrzeitmuster beizubehalten, weist das Beispiel die ursprüngliche benutzerdefinierte Formatzeichenfolge neu zu, die der FullDateTimePattern Eigenschaft zugewiesen ist, nachdem die LongDatePattern Eigenschaft geändert wurde.

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

Für viele Kulturen im .NET Framework wird die Zeit mit einer 12-Stunden-Uhr und einem AM/PM-Designator ausgedrückt. Im folgenden Beispiel wird eine ReplaceWith24HourClock Methode definiert, die jedes Zeitformat ersetzt, das eine 12-Stunden-Uhr mit einem Format verwendet, das eine 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 Ausdrücke @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) wird wie folgt definiert:

Muster Beschreibung
^ Beginnt die Suche am Anfang der Zeichenfolge.
(?<openAMPM>\s*t+\s*)? Entspricht null oder einem Vorkommen von Null oder mehr Leerzeichen, gefolgt vom Buchstaben "t" mindestens ein Mal, gefolgt von null oder mehr Leerzeichen. Diese Aufnahmegruppe wird benannt openAMPM.
(?(openAMPM) h+(?<nonHours>[^ht]+)$ Wenn die openAMPM Gruppe eine Übereinstimmung aufweist, stimmen Sie mit dem Buchstaben "h" ein oder mehrere Male überein, gefolgt von einem oder mehreren Zeichen, die weder "h" noch "t" sind. Die Übereinstimmung endet am Ende der Zeichenfolge. Alle Zeichen, die nach "h" erfasst wurden, sind in einer Aufnahmegruppe mit dem Namen " nonHoursh" enthalten.
&#124; \s*h+(?<nonHours>[^ht]+)\s*t+) Wenn die openAMPM Gruppe keine Übereinstimmung aufweist, stimmen Sie mit dem Buchstaben "h" ein oder mehrere Male überein, gefolgt von einem oder mehreren Zeichen, die weder "h" noch "t" sind, gefolgt von null oder mehr Leerzeichen. Stimmen Sie schließlich mit einem oder mehreren Vorkommen des Buchstabens "t" überein. Alle Zeichen, die nach "h" und vor den Leerzeichen und "t" erfasst wurden, sind in einer Aufnahmegruppe mit dem Namen " nonHourst" enthalten.

Die nonHours Aufnahmegruppe enthält die Minute und möglicherweise die zweite Komponente einer benutzerdefinierten Datums- und Uhrzeitformatzeichenfolge sowie alle Zeittrennzeichen. Das Ersetzungsmuster HH${nonHours} stellt die Teilzeichenfolge "HH" für diese Elemente vor.

Anzeigen und Ändern der Ära in einem Datum

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

  • Die Standardformatzeichenfolge "D" (long date), die der Eigenschaft direkt LongDatePattern zugeordnet ist.

  • Die Standardformatzeichenfolge "f" (full date / short time), die eine Ergebniszeichenfolge erzeugt, die die von den und ShortTimePattern den LongDatePattern Eigenschaften erzeugten Teilzeichenfolgen verkettet.

  • Die Standardformatzeichenfolge "F" (volldatum/ lange Zeit), die der FullDateTimePattern Eigenschaft direkt zugeordnet ist. Da wir diesen Eigenschaftswert nicht explizit festgelegt haben, wird er dynamisch generiert, indem die LongDatePattern Und-Eigenschaften LongTimePattern verkettet werden.

Das Beispiel zeigt auch, wie Sie den Namen der Ära für eine Kultur ändern, deren Kalender eine einzelne Ära aufweist. In diesem Fall verwendet die en-US-Kultur den gregorianischen Kalender, der durch ein GregorianCalendar Objekt dargestellt wird. Die GregorianCalendar Klasse unterstützt eine einzelne Ära, die A.D. nennt. (Anno Domini). Im Beispiel wird der Name der Ära in C.E geändert. (Common Era) durch Ersetzen des benutzerdefinierten Formatbezeichners "g" in der Formatzeichenfolge, die der FullDateTimePattern Eigenschaft mit einer Literalzeichenfolge zugewiesen ist. Die Verwendung einer Literalzeichenfolge ist erforderlich, da der Era-Name in der Regel von der GetEraName Methode aus privaten Daten in den Kulturtabellen zurückgegeben wird, die entweder von der .NET Framework oder dem Windows Betriebssystem bereitgestellt 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

Die Analyse umfasst das Konvertieren der Zeichenfolgendarstellung eines Datums und einer Uhrzeit in einen DateTime oder DateTimeOffset Wert. Beide Typen umfassen die ParseAnalysevorgänge , TryParse``ParseExact, und TryParseExact Methoden zur Unterstützung von Analysevorgängen. Die Parse und TryParse Methoden konvertieren eine Zeichenfolge, die eine Vielzahl von Formaten aufweisen kann, während ParseExact die TryParseExact Zeichenfolge über ein definiertes Format oder ein definiertes Format verfügen muss. Wenn der Analysevorgang fehlschlägt, und ParseExact es wird eine Ausnahme ausgelöst, Parse während TryParse und TryParseExact zurückgegeben falsewird.

Die Analysemethoden können implizit oder explizit einen DateTimeStyles Enumerationswert verwenden, um zu bestimmen, welche Stilelemente (z. B. führende, nachgestellte oder innere Leerzeichen) in der zu analysierenden Zeichenfolge vorhanden sind und wie die analysierte Zeichenfolge oder fehlende Elemente interpretiert werden. Wenn Sie keinen Wert angebenDateTimeStyles, wenn Sie die TryParse Parse Methode aufrufen, lautet DateTimeStyles.AllowWhiteSpacesder Standardwert eine zusammengesetzte Formatvorlage, die die DateTimeStyles.AllowLeadingWhiteDateTimeStyles.AllowTrailingWhiteKennzeichnungen enthält, und DateTimeStyles.AllowInnerWhite flags. Für die ParseExact TryParseExact Methoden lautet DateTimeStyles.Noneder Standardwert ; die Eingabezeichenfolge muss genau einer bestimmten benutzerdefinierten Datums- und Uhrzeitformatzeichenfolge entsprechen.

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

Im folgenden Beispiel wird die kulturempfindliche Art der Analyse von Datums- und Uhrzeitzeichenfolgen veranschaulicht. Es versucht, zwei Datumszeichenfolgen mithilfe der Konventionen der en-US, en-GB, fr-FR und fi-FI-Kulturen zu analysieren. Das Datum, das als 8.18.2014 in der en-US-Kultur interpretiert wird, löst eine FormatException Ausnahme in den anderen drei Kulturen aus, da 18 als Monatszahl interpretiert wird. 1/2/2015 wird als zweiter Tag des ersten Monats in der en-US-Kultur analysiert, aber als erster Tag des zweiten Monats in den verbleibenden Kulturen.

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:

  • So konvertieren Sie die Benutzereingabe in einen Datums- und Uhrzeitwert.

  • Um einen Datums- und Uhrzeitwert umzurunden; 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.

Analysieren von Benutzerzeichenfolgen

Wenn Sie Datums- und Uhrzeitzeichenfolgeneingaben des Benutzers analysieren, sollten Sie immer ein DateTimeFormatInfo Objekt instanziieren, das die kulturellen Einstellungen des Benutzers widerspiegelt, einschließlich aller Anpassungen, die der Benutzer möglicherweise vorgenommen hat. Andernfalls hat das Datums- und Uhrzeitobjekt möglicherweise falsche Werte. Informationen zum Instanziieren eines DateTimeFormatInfo Objekts, das benutzerkulturelle Anpassungen widerspiegelt, finden Sie im Abschnitt "DateTimeFormatInfo" und "dynamische Daten ".

Im folgenden Beispiel wird der Unterschied zwischen einem Analysevorgang veranschaulicht, der benutzerkulturelle Einstellungen und eine, die nicht entspricht. In diesem Fall ist die Standardsystemkultur en-US, aber der Benutzer hat Systemsteuerung, Region und Sprache verwendet, um das kurze Datumsmuster von "M/d/yyyyy" in "yy" in "yyy/MM/dd" zu ändern. Wenn der Benutzer eine Zeichenfolge eingibt, die Benutzereinstellungen widerspiegelt, und die Zeichenfolge wird von einem DateTimeFormatInfo Objekt analysiert, das auch Benutzereinstellungen (Außerkraftsetzungen) widerspiegelt, gibt der Analysevorgang ein korrektes Ergebnis zurück. Wenn die Zeichenfolge jedoch von einem DateTimeFormatInfo Objekt analysiert wird, das Standard-Kultureinstellungen in den USA widerspiegelt, löst die Analysemethode eine FormatException Ausnahme aus, da sie 14 als Anzahl des Monats interpretiert, nicht 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

Serialisierte Datums- und Uhrzeitdaten werden für Rundfahrt erwartet; das heißt, alle serialisierten und deserialisierten Werte sollten identisch sein. Wenn ein Datums- und Uhrzeitwert einen einzelnen Moment in der Zeit darstellt, sollte der deserialisierte Wert den gleichen Zeitpunkt darstellen, unabhängig von der Kultur oder Zeitzone des Systems, auf dem es wiederhergestellt wurde. Um Datums- und Uhrzeitdaten erfolgreich zu runden, 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. Die Formatierungs- und Analysevorgänge sollten niemals die Konventionen der Standardkultur widerspiegeln. Wenn Sie standardkulturelle Einstellungen verwenden, ist die Portierbarkeit der Daten streng begrenzt; es kann nur auf einem Thread erfolgreich deserialisiert werden, dessen kulturspezifische Einstellungen identisch mit denen des Threads sind, auf dem sie serialisiert wurde. In einigen Fällen bedeutet dies, dass die Daten nicht sogar erfolgreich serialisiert und auf demselben System deerialisiert werden können.

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

Im folgenden Beispiel wird der Prozess der Rundfahrt eines Datums- und Uhrzeitwerts veranschaulicht. Es serialisiert ein Datum und eine Uhrzeit auf einem System, das die US-Pazifikzeit beobachtet und dessen 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)

Es wird die Daten für ein System in Brüssel, Kopenhagen, Madrid und Paris zeitzonenisiert und dessen aktuelle Kultur fr-FR ist. Das wiederhergestellte Datum ist neun Stunden später als das ursprüngliche Datum, das die Zeitzonenanpassung von acht Stunden hinter UTC bis zu einer Stunde vor UTC widerspiegelt. Sowohl das ursprüngliche Datum als auch das wiederhergestellte Datum stellen den gleichen 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