(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

DateTimeFormatInfo-Klasse

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

System.Object
  System.Globalization.DateTimeFormatInfo

Namespace:  System.Globalization
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class DateTimeFormatInfo : ICloneable, 
	IFormatProvider

Der DateTimeFormatInfo-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDateTimeFormatInfoInitialisiert eine neue, schreibbare Instanz der DateTimeFormatInfo-Klasse, die kulturunabhängig (invariant) ist.
Zum Seitenanfang

  NameBeschreibung
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAbbreviatedDayNamesRuft ein eindimensionales Array vom Typ String ab, das die kulturabhängigen abgekürzten Namen der Wochentage enthält, oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAbbreviatedMonthGenitiveNamesRuft ein Zeichenfolgenarray der abgekürzten Monatsnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAbbreviatedMonthNamesRuft ein eindimensionales Zeichenfolgenarray ab, das die kulturabhängigen abgekürzten Namen der Monate enthält, oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsAMDesignatorRuft den Zeichenfolgenkennzeichner für Zeitangaben vor 12 Uhr mittags ("ante meridiem", a.m.) ab oder legt diesen fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCalendarRuft den für die aktuelle Kultur zu verwendenden Kalender ab oder legen diesen fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCalendarWeekRuleRuft einen Wert ab, der die Regel zum Bestimmen der ersten Kalenderwoche eines Jahres angibt, oder legt diesen fest.
Öffentliche EigenschaftStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrentInfoRuft ein schreibgeschütztes DateTimeFormatInfo-Objekt ab, das Werte auf Grundlage der aktuellen Kultur formatiert.
Öffentliche EigenschaftUnterstützt von XNA FrameworkDateSeparatorRuft die Zeichenfolge ab, die die Datumskomponenten trennt, d. h. Jahr, Monat und Tag, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsDayNamesRuft ein eindimensionales Zeichenfolgenarray ab, das die kulturabhängigen vollständigen Namen der Wochentage enthält, oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFirstDayOfWeekRuft den ersten Tag der Woche ab oder legt diesen fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsFullDateTimePatternRuft die benutzerdefinierte Formatzeichenfolge für einen langen Datums- und Uhrzeitwert ab oder legt dieses fest.
Öffentliche EigenschaftStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInvariantInfoRuft das schreibgeschützte DateTimeFormatInfo-Standardobjekt ab, das kulturunabhängig (invariant) ist.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsReadOnlyRuft einen Wert ab, der angibt, ob das DateTimeFormatInfo-Objekt schreibgeschützt ist.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLongDatePatternRuft die benutzerdefinierte Formatzeichenfolge für einen langen Datumswert ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsLongTimePatternRuft die benutzerdefinierte Formatzeichenfolge für einen langen Uhrzeitwert ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMonthDayPatternRuft die benutzerdefinierte Formatzeichenfolge für einen Monats- und Tageswert ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMonthGenitiveNamesRuft ein Zeichenfolgenarray der Monatsnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsMonthNamesRuft ein eindimensionales Array vom Typ String ab, das die kulturabhängigen vollständigen Namen der Monate enthält, oder legt dieses fest.
Öffentliche EigenschaftNativeCalendarNameRuft den systemeigenen Namen des Kalenders ab, der dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPMDesignatorRuft den Zeichenfolgenkennzeichner für Zeitangaben nach 12 Uhr mittags ("post meridiem", p.m.) ab oder legt diesen fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsRFC1123PatternRuft die benutzerdefinierte Formatzeichenfolge für einen Uhrzeitwert ab, der auf der Spezifikation 1123 Request for Comments (Internet Engineering Task Force- IETF RFC ()) basiert.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsShortDatePatternRuft die benutzerdefinierte Formatzeichenfolge für einen kurzen Datumswert ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsShortestDayNamesRuft ein Zeichenfolgenarray der am stärksten abgekürzten, eindeutigen Tagesnamen ab, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet sind, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsShortTimePatternRuft die benutzerdefinierte Formatzeichenfolge für einen kurzen Uhrzeitwert ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsSortableDateTimePatternRuft die benutzerdefinierte Formatzeichenfolge für einen sortierbaren Datums-und Zeitwert ab.
Öffentliche EigenschaftUnterstützt von XNA FrameworkTimeSeparatorRuft die Zeichenfolge ab, die die Bestandteile der Uhrzeit trennt, d. h. Stunde, Minuten und Sekunden, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsUniversalSortableDateTimePatternRuft die benutzerdefinierte Formatzeichenfolge für eine universelle sortierbare Datums- und Zeitzeichenfolge ab.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsYearMonthPatternRuft die benutzerdefinierte Formatzeichenfolge für einen Jahres- und Monatswert ab oder legt diese fest.
Zum Seitenanfang

  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCloneErstellt eine flache Kopie von DateTimeFormatInfo.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsEquals(Object)Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist. (Von Object geerbt.)
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetAbbreviatedDayNameGibt den kulturabhängigen abgekürzten Namen des angegebenen Wochentags entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetAbbreviatedEraNameGibt die Zeichenfolge zurück, die den abgekürzten Namen des angegebenen Zeitraums enthält, sofern eine Abkürzung vorhanden ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetAbbreviatedMonthNameGibt den kulturabhängigen abgekürzten Namen des angegebenen Monats entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.
Öffentliche MethodeUnterstützt von XNA FrameworkGetAllDateTimePatterns()Gibt alle Standardmuster zurück, in denen Datums- und Zeitwerte formatiert werden können.
Öffentliche MethodeUnterstützt von XNA FrameworkGetAllDateTimePatterns(Char)Gibt alle Muster zurück, in denen Datums- und Zeitwerte mit der angegebenen Standardformatzeichenfolge formatiert werden können.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetDayNameGibt den kulturabhängigen vollständigen Namen des angegebenen Wochentags entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetEraGibt die Ganzzahl zurück, die den angegebenen Zeitraum darstellt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetEraNameGibt die Zeichenfolge mit dem Namen des angegebenen Zeitraums zurück.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetFormatGibt ein Objekt vom angegebenen Typ zurück, das einen Datum-und Zeit-Formatierungsdienst bereitstellt.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetHashCodeFungiert als die Standardhashfunktion. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetInstanceGibt das DateTimeFormatInfo-Objekt zurück, das dem angegebenen IFormatProvider zugeordnet ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetMonthNameGibt den kulturabhängigen vollständigen Namen des angegebenen Monats entsprechend der Kultur zurück, die dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.
Öffentliche MethodeGetShortestDayNameRuft den am stärksten abgekürzten Tagesnamen für einen angegebenen Wochentag ab, der dem aktuellen DateTimeFormatInfo-Objekt zugeordnet ist.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsGetTypeRuft den Type der aktuellen Instanz ab. (Von Object geerbt.)
Öffentliche MethodeStatischer MemberUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsReadOnlyGibt einen schreibgeschützten DateTimeFormatInfo-Wrapper zurück.
Öffentliche MethodeSetAllDateTimePatternsLegt die benutzerdefinierten Formatzeichenfolgen für Datum und Uhrzeit fest, die einer angegebenen Standardformatzeichenfolge entsprechen.
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsToStringGibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Von Object geerbt.)
Zum Seitenanfang

Die Eigenschaften der DateTimeFormatInfo-Klasse enthält kulturbezogene Informationen zum Formatieren oder Analysieren von Datums- und Uhrzeitwerten wie dem folgenden:

  • Die Muster verwendet, die Datumswerte zu formatieren.

  • Die Muster verwendet, um zu formatieren.

  • Die Namen der Wochentage.

  • Die Namen der Monate des Jahres.

  • Die Uhr- und Uhrkennzeichner verwendet in den Zeitwerten.

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

In diesem Abschnitt

Instanziieren eines DateTimeFormatInfo-Objekts

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

c6dw49cz.collapse_all(de-de,VS.110).gifInstanziieren 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 jede spezifische englischsprachigen Land/Region. Obwohl die Daten aus bestimmten Kulturen dynamisch sein können und ändern können, um neue kulturelle Konventionen oder Benutzereinstellungen zu entsprechen, werden die Daten der invarianten Kultur nicht. Sie können ein DateTimeFormatInfo-Objekt instanziieren, das die Formatierungskonventionen der invarianten Kultur folgendermaßen darstellt:

  • Durch Abrufen des Werts der InvariantInfo-Eigenschaft. Das zurückgegebene DateTimeFormatInfo-Objekt ist schreibgeschützt.

  • Durch Aufrufen des parameterlosen Konstruktors DateTimeFormatInfo. Das zurückgegebene Objekt DateTimeFormatInfo ist eine Lese-/Schreibeigenschaft.

  • Wenn Sie den Wert der DateTimeFormat-Eigenschaft von CultureInfo abrufen, Sie wenden ein, die durch die CultureInfo.InvariantCulture-Eigenschaft zurückgegeben wird. Das zurückgegebene DateTimeFormatInfo-Objekt ist schreibgeschützt.

Im folgenden Beispiel wird jede dieser Methoden, um ein DateTimeFormatInfo-Objekt zu instanziieren, das die invariante Kultur darstellt. Es gibt an, 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      


c6dw49cz.collapse_all(de-de,VS.110).gifInstanziieren eines DateTimeFormatInfo-Objekts für eine bestimmte Kultur

Einer bestimmten Kultur stellt eine Sprache dar, die in einer bestimmten Land/Regionen gesprochen wird. Beispielsweise ist eine bestimmte Kultur en-US, die der englischen Sprache darstellt, die sich in den USA gesprochen wird, und ENZertifizierungsstelle ist eine spezifische Kultur, die der englischen Sprache darstellt, die in Kanada gesprochen wird. Sie können ein DateTimeFormatInfo-Objekt instanziieren, das die Formatierungskonventionen einer bestimmten Kultur folgendermaßen darstellt:

Das folgende Beispiel veranschaulicht diesen Methoden, ein DateTimeFormatInfo-Objekt zu instanziieren und gibt an, ob das 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


c6dw49cz.collapse_all(de-de,VS.110).gifInstanziieren eines DateTimeFormatInfo-Objekts für eine neutrale Kultur

Eine neutrale Kultur stellt eine Kultur oder Sprache dar, die unabhängig Land/eine Region ist; In der Regel ist es das übergeordnete Element einer oder mehrerer spezifischen Kulturen. Von ist eine neutrale Kultur für die französische Sprachdatei und das übergeordnete Element der Kultur fr-FR. Sie können ein DateTimeFormatInfo-Objekt instanziieren, das die Formatierungskonventionen einer neutralen Kultur auf dieselbe Weise dargestellt, dass Sie ein DateTimeFormatInfo-Objekt erstellen, das die Formatierungskonventionen einer bestimmten Kultur darstellt. Darüber hinaus können Sie DateTimeFormatInfo-Objekt einer neutralen Kultur abrufen, indem Sie eine neutrale Kultur von CultureInfo.Parent-Eigenschaft einer bestimmten Kultur abrufen und das DateTimeFormatInfo-Objekt abrufen, das durch seine CultureInfo.DateTimeFormat-Eigenschaft zurückgegeben wird. Es sei denn, die übergeordnete Kultur die invariante Kultur darstellt, wird das zurückgegebene DateTimeFormatInfo-Objekt gelesen. Das folgende Beispiel verdeutlicht diese zum Instanziieren eines DateTimeFormatInfo-Objekts, 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      


HinweisHinweis

In den .NET Framework-Versionen 1.0, von .NET Framework 3.5 ist, ein DateTimeFormatInfo-Objekt abzurufen, das die Formatierungskonventionen der auslöst einer neutralen Kultur eine NotSupportedException Ausnahme aus.

Es fehlt eine neutrale Kultur kulturspezifische Formatierungsinformationen, da sie unabhängig von einer bestimmten Land/Region ist. Anstatt, das DateTimeFormatInfo-Objekt mit generischen Werte aufzufüllen zurück, gibt .NET Framework ein DateTimeFormatInfo-Objekt, das die Formatierungskonventionen einer bestimmten Kultur widerspiegelt, die ein untergeordnetes Element der neutralen Kultur ist. Beispielsweise gibt das DateTimeFormatInfo-Objekt für die neutrale en-Kultur der Formatierungskonventionen der Kultur, und das DateTimeFormatInfo-Objekt für von der Kultur widerspiegelt die Formatierungskonventionen der Kultur fr-FR.

Sie können beispielsweise folgenden Code verwenden, um zu bestimmen, das die Formatierungskonventionen der bestimmten Kultur eine neutrale Kultur darstellt. Das Beispiel verwendet Reflektion, um die DateTimeFormatInfo-Eigenschaften einer neutralen Kultur mit den Eigenschaften einer bestimmten untergeordneten Kultur zu vergleichen. Es werden zwei Kalender als äquivalent, wenn sie den gleichen Kalendertyp und, für gregorianische Kalender basieren, wenn ihre GregorianCalendar.CalendarType-Eigenschaften identische Werte verfügen.


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


c6dw49cz.collapse_all(de-de,VS.110).gifInstanziieren eines DateTimeFormatInfo-Objekts für die aktuelle Kultur

Sie können ein DateTimeFormatInfo-Objekt instanziieren, das die Formatierungskonventionen der aktuellen Kultur folgendermaßen darstellt:

  • Durch Abrufen des Werts der CurrentInfo-Eigenschaft. Das zurückgegebene DateTimeFormatInfo-Objekt ist schreibgeschützt.

  • Wenn Sie den Wert der DateTimeFormat-Eigenschaft von CultureInfo abrufen, Sie wenden ein, die durch die CultureInfo.CurrentCulture-Eigenschaft zurückgegeben wird. Das zurückgegebene DateTimeFormatInfo-Objekt ist schreibgeschützt.

  • Indem Sie die GetInstance-Methode mit CultureInfo aufrufen, befassen Sie ein, die die aktuelle Kultur darstellt. Das zurückgegebene DateTimeFormatInfo-Objekt ist schreibgeschützt.

Im folgenden Beispiel wird jede dieser Methoden, um ein DateTimeFormatInfo-Objekt zu instanziieren, das die Formatierungskonventionen der aktuellen Kultur darstellt. Es gibt an, 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


Sie können ein schreibbares DateTimeFormatInfo-Objekt erstellen, das die Konventionen der aktuellen Threadkultur in einer dieser Methoden veranschaulicht:

  • Indem Sie ein DateTimeFormatInfo-Objekt in jedem der drei vorherigen Methoden abrufen und die Methode Clone auf zurückgegebenen DateTimeFormatInfo aufrufen, Objekts. Dadurch wird eine Kopie des ursprünglichen Objekts DateTimeFormatInfo, außer dass die Eigenschaft IsReadOnly ist false.

  • Indem Sie die CultureInfo.CreateSpecificCulture-Methode aufrufen, um CultureInfo zu erstellen, wenden Sie, die die aktuelle Kultur darstellt, und mithilfe der Eigenschaft CultureInfo.DateTimeFormat, um das Objekt dann ein DateTimeFormatInfo abzurufen.

Im folgenden Beispiel wird jede Methode des Instanziierens Lese-/Schreibzugriff Objekts eines DateTimeFormatInfo und zeigt den Wert der IsReadOnly-Eigenschaft 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


In Windows kann der Benutzer einige der DateTimeFormatInfo-Eigenschaftswerte überschreiben, die in Formatierungs- und Analysevorgängen mithilfe Region und Sprache in der Systemsteuerung verwendet werden. Beispielsweise ein Benutzer auswählen, dessen Kultur Englisch (USA Macht ist, um lange Zeitwerte im 24-Stundenformat anzuzeigen (im Format HH:mm:ss) anstelle des Standard-12-Stunden-Formats (im Format h:mm:ss tt). Alle DateTimeFormatInfo-Objekte, die auf die abgerufen wurden Arten, zuvor erläuterten entsprechen diese benutzerdefinierte Überschreibungen. Wenn dieses unerwünscht ist, können Sie ein NumberFormatInfo-Objekt erstellen, das wieder (benutzerdefinierte Überschreibungen und ist ebenfalls nicht schreibgeschützten mit Lese-/Schreibzugriff), nicht mit dem CultureInfo.CultureInfo(String, Boolean)-Konstruktor aufrufen und einen Wert von false für das Argument useUserOverride angibt. Das folgende Beispiel veranschaulicht dies für ein System, dessen aktuelle Kultur Englisch (USA) und dem Muster für lange Zeit 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


DateTimeFormatInfo und dynamische Daten

Mit kulturspezifischen Daten für das Formatieren der Datums- und Uhrzeitwerte, die von der DateTimeFormatInfo-Klasse bereitgestellt werden, sind, wie die kulturellen Daten dynamisch, die von der CultureInfo-Klasse bereitgestellt werden. Sie sollten keine Annahmen über die Wertbeständigkeit für DateTimeFormatInfo-Objekte machen, die bestimmten CultureInfo-Objekten zugeordnet sind. Nur die Daten, die von der invarianten Kultur und von dem zugeordneten DateTimeFormatInfo-Objekt bereitgestellt werden, sind weiterhin. Weitere Daten können zwischen Anwendungssitzungen ändern und sogar, während die Anwendung ausgeführt wird. Es gibt vier Hauptquellen der Änderung:

  • Systemupdates. Kulturelle Einstellungen wie der bevorzugte Kalender oder übliche Datums- und Uhrzeitformate ändern im Zeitverlauf. Wenn dies geschieht, enthält Windows Update Änderungen am DateTimeFormatInfo-Eigenschaftswert für eine bestimmte Kultur.

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

  • Kaskadenänderungen an Eigenschaftswerten. Einige kulturbezogene Eigenschaften können zur Laufzeit, das wiederum DateTimeFormatInfo Daten geführt. Beispielsweise kann die aktuelle Kultur Benutzeraktion entweder programmgesteuert oder durch geändert werden. Wenn dies geschieht, ändert das DateTimeFormatInfo-Objekt, das durch die CurrentInfo-Eigenschaft zurückgegeben wird, auf ein Objekt, das der aktuellen Kultur zugeordnet ist. Entsprechend kann der Kalender einer Kultur ändern, der Änderungen an Eigenschaftswerten zahlreichen DateTimeFormatInfo führen kann.

  • Benutzereinstellungen. Benutzer der Anwendung könnten, um einige Werte überschreiben, die der aktuellen Systemkultur über die Regions- und Sprachoptionen in der Systemsteuerung zugeordnet werden. Beispielsweise könnten Benutzer, um das Datum in einem anderen Format anzuzeigen. Wenn die Eigenschaft CultureInfo.UseUserOverride auf true festgelegt wird, werden die Eigenschaften des Objekts DateTimeFormatInfo auch von den Benutzereinstellungen abgerufen. Wenn die Benutzereinstellungen mit der Kultur nicht kompatibel sind, die mit dem CultureInfo-Objekt zugeordnet ist (beispielsweise, wenn der Kalender ausgewählte keiner der Kalender ist, die von der OptionalCalendars-Eigenschaft bereitgestellt), um die Ergebnisse der Methoden und die Werte der Eigenschaften werden undefiniert.

Um die Gefahr von den Daten zu senken, werden alle vom Benutzer schreibbaren Eigenschaften eines DateTimeFormatInfo-Objekts initialisiert wenn das Objekt erstellt wird. Es gibt noch eine Möglichkeit der führt, da weder Objekterstellung noch der Benutzerüberschreibungsprozess unteilbar ist und die relevanten Werte während der Objekterstellung ändern können. Diese Situation sollte jedoch nur sehr selten eintreten.

Sie können steuern, ob benutzerdefinierte Überschreibungen in DateTimeFormatInfo-Objekte auswirken, die dieselbe Kultur wie die Systemkultur darstellen. In der folgenden Tabelle werden die Methoden, in denen ein DateTimeFormatInfo-Objekt abgerufen werden kann auf und gibt an, ob das Objekt benutzerdefinierte Überschreibungen wiedergegeben.

Quelle von CultureInfo-Objekt und DateTimeFormatInfo

Reflektiert benutzerdefinierte Überschreibungen

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

Hängt vom Wert von useUserOverride ab Parameter

Sofern, dass es ein zwingender Grund gibt; andernfalls zu erreichen, sollten Sie benutzerdefinierte Überschreibungen respektieren, wenn Sie das DateTimeFormatInfo-Objekt in Clientanwendungen, zu formatieren und Benutzereingaben zu analysieren oder Daten anzuzeigen verwenden. Für Serveranwendungen oder unbeaufsichtigte Anwendungen sollten Sie nicht. Wenn Sie jedoch das DateTimeFormatInfo-Objekt entweder explizit oder, Datums- und Uhrzeitdaten im Zeichenfolgenformat implizit beizubehalten verwenden, sollten Sie jede Verwendung ein DateTimeFormatInfo-Objekt, das die Formatierungskonventionen der invarianten Kultur widergespiegelt, oder Sie können eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit angeben, die Sie unabhängig von der Kultur verwenden.

Formatierungsdatumsangaben und -zeiten

Ein DateTimeFormatInfo-Objekt wird implizit oder explizit in alle Datums- und Zeitformatierungsvorgängen verwendet. Diese Einschließungsaufrufe zu den folgenden Methoden:

Alle Datums- und Zeitformatierungsvorgänge nutzen eine IFormatProvider Implementierung aus. Die IFormatProvider-Schnittstelle verfügt über eine einzige Methode, IFormatProvider.GetFormat(Type). Dieser Rückrufmethode wird ein Type-Objekt übergeben, das den Typ darstellt, der benötigt wird, um Formatierungsinformationen bereitzustellen. Die Methode gibt eine Instanz dieses Typs einem oder null zurück, wenn eine Instanz des Typs nicht bereitstellen kann. . .NET Framework enthält zwei Implementierungen IFormatProvider zum Formatieren von Datumsangaben und Zeitangaben ein:

  • Die CultureInfo-Klasse, die eine bestimmte Kultur darstellt (oder eine bestimmte Sprache in einer bestimmten Land/Region). In einem Datums- und Zeitformatierungsvorgang gibt die CultureInfo.GetFormat-Methode das DateTimeFormatInfo-Objekt zurück, das mit der CultureInfo.DateTimeFormat-Eigenschaft zugeordnet ist.

  • Die DateTimeFormatInfo-Klasse, die Informationen zu Formatierungskonventionen der der zugeordneten Kultur bereitstellt. Die DateTimeFormatInfo.GetFormat-Methode gibt eine Instanz von sich selbst zurück.

Wenn eine IFormatProvider Implementierung keiner Formatierungsmethode explizit bereitgestellt wird, der das CultureInfo-Objekt durch die CultureInfo.CurrentCulture-Eigenschaft zurück, die die aktuelle Threadkultur wird verwendet darstellt.

Im folgenden Beispiel wird die Beziehung zwischen der IFormatProvider-Schnittstelle und der DateTimeFormatInfo-Klasse bei Formatierungsvorgängen. Er definiert eine benutzerdefinierte Implementierung IFormatProvider, deren GetFormat-Methode den Typ des Objekts anzeigt, das durch den Formatierungsvorgang angefordert wird. Wenn es ein DateTimeFormatInfo-Objekt anfordert, erstellt die Methode das DateTimeFormatInfo-Objekt für die aktuelle Threadkultur bereit. Die Ausgabe im Beispiel zeigt, wird die Decimal.ToString(IFormatProvider)-Methode um ein DateTimeFormatInfo-Objekt, um Formatierungsinformationen bereitzustellen, während die String.Format(IFormatProvider, String, Object[])-Methode NumberFormatInfo und DateTimeFormatInfo sowie Objekte eine ICustomFormatter Implementierung erfordert.


using System;
using System.Globalization;

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

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


Formatzeichenfolgen- und DateTimeFormatInfo-Eigenschaften

Das DateTimeFormatInfo-Objekt umfasst drei Arten Eigenschaften, die bei Formatierungsvorgängen mit Datums- und Uhrzeitwerte verwendet werden:

Standard-Formatzeichenfolgen für Datum und Uhrzeit, z "d", "D", "f" und "F", sind Aliase, die bestimmten DateTimeFormatInfo Formatmustereigenschaften entsprechen. Die meisten benutzerdefinierte Formatbezeichner werden in Zeichenfolgen oder zu den Teilzeichenfolgen verknüpft, die einen Formatierungsvorgang in den Ergebnisstream einfügt. In der folgenden Tabelle sind die standardmäßigen und Gewohnheitsdatums- und Datum und Uhrzeit und die zugehörigen Eigenschaften DateTimeFormatInfo auf. Ausführliche Informationen, wie diese Formatbezeichner, finden Sie unter Standard-Formatzeichenfolgen für Datum und Uhrzeit und Benutzerdefinierte Formatzeichenfolgen für Datum und Uhrzeit. Beachten Sie, dass jede Standardformatzeichenfolge an eine DateTimeFormatInfo-Eigenschaft entspricht, deren Werte eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit ist. Die einzelnen Bezeichner in der benutzerdefinierten Formatzeichenfolge entsprechen wiederum zu anderen DateTimeFormatInfo-Eigenschaften. In der Tabelle werden nur die Eigenschaften DateTimeFormatInfo, für die die Standardformatzeichenfolgen Alias sind, und wird nicht Eigenschaften auf, die die auf benutzerdefinierten Nachverfolgungsspannen Formatzeichenfolgen sind, die diesen Alias- Eigenschaften zugewiesen werden. Darüber hinaus zeigt die Tabelle nur benutzerdefinierte Formatbezeichner auf, die DateTimeFormatInfo entsprechen Eigenschaften.

Formatbezeichner

Zugeordnete Eigenschaften

"d" (kurzes Datum; Standardformatzeichenfolge)

ShortDatePattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"D" (langes Datum; Standardformatzeichenfolge)

LongDatePattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"f" (vollständiges Datum und kurze Zeit; Standardformatzeichenfolge)

LongDatePattern , das Format der Datumskomponente der Ergebniszeichenfolge definiert.

ShortTimePattern , das Format der Zeitkomponente der Ergebniszeichenfolge definiert.

"F" (vollständiges Datum und lange Zeit; Standardformatzeichenfolge)

LongDatePattern , das Format der Datumskomponente der Ergebniszeichenfolge definiert.

LongTimePattern , das Format der Zeitkomponente der Ergebniszeichenfolge definiert.

"g" für allgemeines (kurze Datum/Zeit; Standardformatzeichenfolge)

ShortDatePattern , das Format der Datumskomponente der Ergebniszeichenfolge definiert.

ShortTimePattern , das Format der Zeitkomponente der Ergebniszeichenfolge definiert.

"G" (allgemeines Datum/lange Zeit; Standardformatzeichenfolge)

ShortDatePattern , das Format der Datumskomponente der Ergebniszeichenfolge definiert.

LongTimePattern , das Format der Zeitkomponente der Ergebniszeichenfolge definiert.

"M", "m" (Monat/Tag; Standardformatzeichenfolge)

MonthDayPattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"O", "o" (Rundreisedatum /uhrzeit; Standardformatzeichenfolge)

Keiner.

"R", "r" (RFC1123; Standardformatzeichenfolge)

RFC1123Pattern , eine Ergebniszeichenfolge definieren, die an der RFC-Spezifikation 1123 entspricht. Die Eigenschaft ist schreibgeschützt.

"s" (sortierbares Datum /Uhrzeit; Standardformatzeichenfolge)

SortableDateTimePattern , eine Ergebniszeichenfolge definieren, die an den standardmäßigen ISO 8601 entspricht. Die Eigenschaft ist schreibgeschützt.

"t" (kurze Zeit; Standardformatzeichenfolge)

ShortTimePattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"T" (lange Zeit; Standardformatzeichenfolge)

LongTimePattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"&" (universelles sortierbares Datum /Uhrzeit; Standardformatzeichenfolge)

UniversalSortableDateTimePattern , eine Ergebniszeichenfolge definieren, die an den standardmäßigen ISO 8601 für koordinierte Weltzeit entspricht. Die Eigenschaft ist schreibgeschützt.

"U" (universelles vollständiges Datum /Uhrzeit; Standardformatzeichenfolge)

FullDateTimePattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"Y", "y" (Jahrmonat; Standardformatzeichenfolge)

YearMonthPattern , das Gesamtformat der Ergebniszeichenfolge definiert.

"ddd" (benutzerdefinierter Formatbezeichner)

AbbreviatedDayNames , den abgekürzten Namen des Tags der Woche in der Ergebniszeichenfolge enthalten.

"g", "GZ" (benutzerdefinierter Formatbezeichner)

Ruft die GetEraName-Methode auf, um den Namen des Zeitraums in der Ergebniszeichenfolge einzufügen.

"MMM" (benutzerdefinierter Formatbezeichner)

AbbreviatedMonthNames , den abgekürzten Monatsnamen in der Ergebniszeichenfolge enthalten.

"MMMM" (benutzerdefinierter Formatbezeichner)

MonthNames oder MonthGenitiveNames, den vollständigen Monatsnamen in der Ergebniszeichenfolge enthalten.

"t" (benutzerdefinierter Formatbezeichner)

AMDesignator oder PMDesignator, das erste Zeichen des AM/PM-Kennzeichners in der Ergebniszeichenfolge enthalten.

"tt" (benutzerdefinierter Formatbezeichner)

AMDesignator oder PMDesignator, den vollständigen AM/PM-Kennzeichner in der Ergebniszeichenfolge enthalten.

":" (benutzerdefinierter Formatbezeichner)

TimeSeparator , Trennzeichen für Zeitangaben in der Ergebniszeichenfolge enthalten.

"/" (benutzerdefinierter Formatbezeichner)

DateSeparator , das Datumstrennzeichen in der Ergebniszeichenfolge enthalten.

Ändern von DateTimeFormatInfo-Eigenschaften

Sie können die Ergebniszeichenfolge ändern, die von Formatzeichenfolgen für Datum und Uhrzeit erzeugt wird, indem Sie die entsprechenden Eigenschaften eines überschreibbaren DateTimeFormatInfo-Objekten ändern. Sie können mithilfe der IsReadOnly-Eigenschaft ermitteln, ob ein DateTimeFormatInfo-Objekt schreibbar ist. Um ein mobiles DateTimeFormatInfo-Objekt auf diese Weise anpassen:

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

  2. Ändern Sie die Eigenschaft oder die Eigenschaften, die verwendet werden, um die Zeichenfolge der gewünschte Ergebnis zu erzeugen. (Weitere Informationen zum Formatieren, Methodenverwendungs- DateTimeFormatInfo-Eigenschaften, um Ergebniszeichenfolgeketten zu definieren, finden Sie im vorherigen Abschnitt, Formatzeichenfolgen- und DateTimeFormatInfo-Eigenschaften.)

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

Es gibt zwei andere Möglichkeiten, Stil eine Ergebniszeichenfolge zu ändern:

  • Sie können die CultureAndRegionInfoBuilder-Klasse verwenden, um entweder eine benutzerdefinierte Kultur (eine Kultur, die einen eindeutigen Namen verfügt und die vorhandenen Kulturen ergänzt) oder einer Ersatzkultur (eine, die anstelle einer bestimmten Kultur verwendet wird) zu definieren. Sie können auf diese Kultur programmgesteuert speichern und verwenden, während Sie ein beliebiges CultureInfo-Objekt fest, das von .NET Framework unterstützt wurde.

  • Wenn die Ergebniszeichenfolge nicht kulturabhängig ist und nicht nach einem vordefinierten Format folgt, können Sie eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit verwenden. Wenn Sie Datums- und Uhrzeitdaten im Format YYYYMMDDHHmmss serialisieren, können Sie die Ergebniszeichenfolge generieren, indem Sie die benutzerdefinierte Formatzeichenfolge für die DateTime.ToString(String)-Methode übergeben, und Sie können die Ergebniszeichenfolge zurück in einen DateTime-Wert konvertieren, indem Sie die DateTime.ParseExact-Methode aufrufen.

c6dw49cz.collapse_all(de-de,VS.110).gifÄndern des kurzen Datumsmuster

Das folgende Beispiel unterscheidet sich vom Format eine Ergebniszeichenfolge, die durch die Standardformatzeichenfolge "erzeugt d" (kurzes Datum). Er ändert die zugeordnete ShortDatePattern-Eigenschaft für en-US oder Kultur Englisch (USA) von den Standardwert "M/d/yyyy" in "yyyy"-"MM"-"dd" und Verwendung die Standardformatzeichenfolge "d", das sowohl Datum anzuzeigen, bevor und nachdem die ShortDatePattern-Eigenschaft geändert wird.


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


c6dw49cz.collapse_all(de-de,VS.110).gifÄndern des Datumstrennzeichens

Im folgenden Beispiel ändert das Datumstrennzeichen in einem DateTimeFormatInfo-Objekt, das die Formatierungskonventionen der Kultur fr-FR darstellt. Das Beispiel verwendet die Standardformatzeichenfolge "g ", um das Datum beide anzuzeigen, bevor und nachdem die DateSeparator-Eigenschaft geändert wird.


using System;
using System.Globalization;

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

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

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


c6dw49cz.collapse_all(de-de,VS.110).gifÄndern von Tagsnamenabkürzungen und von langen Datumsmuster

In einigen Fällen kann das lange Datumsmuster, das in der Regel den gesamten Tag und den Monatsnamen zusammen mit der Nummer des Tages des Monats und des Jahres anzeigt, zu lang. Im folgenden Beispiel arbeiten das lange Datumsmuster, sodass die Kultur einer ein Zeichen Großbuchstaben oder zwei Zeichen Großbuchstaben Tagsnamenabkürzung zurückgibt, die aus der Nummer folgen, der Monatsnamenabkürzung und das Jahr. Das geschieht, indem Tagsnamenabkürzungen kürzere zum AbbreviatedDayNames Array zugewiesen und mit der benutzerdefinierten Formatzeichenfolge ändert, die zur LongDatePattern-Eigenschaft zugewiesen wird. Dies betrifft die daraus resultierenden Zeichenfolgen, die mit 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 09, 2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tuesday, July 09, 2013 12:00 AM
//       
//       D: Tu 09-Jul-2013
//       F: Tuesday, July 09, 2013 12:00:00 AM
//       f: Tu 09-Jul-2013 12:00 AM


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

c6dw49cz.collapse_all(de-de,VS.110).gifÄndern von 12-Stunden-Format zu ein 24-Stunden-Format

Für viele Kulturen in .NET Framework, wird der Zeitpunkt angegeben, indem ein 12-Stunden-Format und einen AM/PM-Kennzeichner verwendet. Im folgenden Beispiel wird eine ReplaceWith24HourClock-Methode jederzeit Format, die ersetzt dabei, das ein mit einem Stil verwendet, das ein 24-Stunden-Format 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


Im Beispiel wird ein regulärer Ausdruck, um die Formatzeichenfolge zu ändern. Das Muster eines regulären Ausdrucks @"^(?<openAMPM>\s*t+\s*)? (?(openAMPM) h+(?<nonHours>[^ht]+)$ | \s*h+(?<nonHours>[^ht]+)\s*t+) wird definiert, wie folgt:

Muster

Beschreibung

^

Beginnt die Suche am Anfang der Zeichenfolge.

(?<openAMPM>\s*t+\s*)?

Übereinstimmung mit keinem oder einem Vorkommen von keinem oder mehr Leerzeichen, gefolgt vom Buchstaben "t" ein oder mehrmals, gefolgt von keinem oder mehr Leerzeichen. Diese Erfassungsgruppe ist openAMPM.

(?(openAMPM) h+(?<nonHours>[^ht]+)$

Wenn die openAMPM Gruppe eine Übereinstimmung, gleichen Sie den Buchstaben "h" ein oder mehrmals, gefolgt von einem oder mehreren Zeichen, die weder "h" noch "t" sind. Die Abgleichungsenden am Ende der Zeichenfolge. Alle Zeichen aufgezeichnet, nachdem "h" in einer Erfassungsgruppe enthalten sind, die nonHours genannt wird.

| \s*h+(?<nonHours>[^ht]+)\s*t+)

Wenn die openAMPM Gruppe keine Übereinstimmung, gleichen Sie den Buchstaben "h" ein oder mehrmals, gefolgt von einem oder mehreren Zeichen, die weder "h" noch "t" sind, gefolgt von keinem oder mehr Leerzeichen. Schließlich gleichen eines oder mehrere Vorkommen des Buchstabens "t". alle Zeichen, die auf "h" und den Leerzeichen und den "t" aufgezeichnet werden, werden in einer Erfassungsgruppe enthalten, die mit dem Namen nonHours.

Die nonHours Erfassungsgruppe enthält die Minute und möglicherweise die zweite Komponente eine benutzerdefinierte Formatzeichenfolge für Datum und Uhrzeit, zusammen mit jederzeit Trennzeichen. Das Ersetzungsmuster HH${nonHours} stellt die Teilzeichenfolge "HH" zu diesen Elementen erkennbar.

c6dw49cz.collapse_all(de-de,VS.110).gifDer Zeitraum in ein Datum anzeigen und Ändern

Im folgenden Beispiel wird dem benutzerdefinierten Formatbezeichner "g" der Eigenschaft LongDatePattern eines Objekts hinzu, das die Formatierungskonventionen der Kultur darstellt. Dadurch werden auf die folgenden drei Formatzeichenfolgen:

  • Die Standardformatzeichenfolgen "D" (langes Datum), die sich direkt auf die Eigenschaft LongDatePattern zuordnet.

  • Die Standardformatzeichenfolgen "f" (vollständiges Datum und kurze Zeit), die eine Ergebniszeichenfolge erzeugt, die die Teilzeichenfolgen verkettet, könnte durch die Eigenschaften LongDatePattern und ShortTimePattern.

  • Die Standardformatzeichenfolgen "Fs" (vollständiges Datum und lange Zeit), die sich direkt auf die Eigenschaft FullDateTimePattern zuordnet. Da nicht explizit diesen Eigenschaftswert festgelegt haben, wird er dynamisch generiert, indem die Eigenschaften LongDatePattern und LongTimePattern verkettet.

Im Beispiel wird auch gezeigt, wie den Namen des Zeitraums für eine Kultur ändert, deren Kalender einen einzigen Zeitraum hat. In diesem Fall wird die Kultur en-US gregorianischen Kalender, der durch ein GregorianCalendar-Objekt dargestellt wird. Die GregorianCalendar-Klasse unterstützt einen einzigen Zeitraum, den sie. A.D. benennt (Anno Domini). Im Beispiel wird den Namen des Zeitraums zu &. Z. (Allgemeiner Zeitraum) durch das Ersetzen von "g" benutzerdefinierten Formatbezeichners in der Formatzeichenfolge zugewiesen der FullDateTimePattern- Eigenschaft über eine Literalzeichenfolge. Die Verwendung von eine Literalzeichenfolge ist erforderlich, da der Zeitraumname in der Regel durch die GetEraName-Methode von privaten Daten in den Kulturtabellen zurückgegeben, das entweder von .NET Framework oder das Windows-Betriebssystem angegeben 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


Analysedatums- und uhrzeitzeichenfolgen

Analyse, scrollen die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts in einem DateTime oder DateTimeOffset-Wert zu konvertieren. Beide Typen gehören Parse, TryParse, ParseExact und TryParseExact, um Methoden Analysevorgänge zu unterstützen. Die Parse und TryParse-Methoden konvertieren eine Zeichenfolge, die eine Vielzahl von Formaten haben kann, während ParseExact und TryParseExact erfordern, dass die Zeichenfolge ein definiertes Format oder Formate aufweisen. Wenn die Analyseoperation fehlschlägt, Parse und ParseExact lösen eine Ausnahme, während TryParse und TryParseExactfalse zurückgeben.

Die Analysemethoden verwenden implizit oder explizit einen DateTimeStyles-Enumerationswert, um zu ermitteln, welche Formatelemente (z Zeilenabstands, Schleppen oder innere Leerzeichen) in der zu analysierende Zeichenfolge vorhanden sein können, und wie die analysierte Zeichenfolge oder alle fehlenden Elemente interpretiert. Wenn Sie keinen DateTimeStyles-Wert bereitstellen, wenn Sie die Methode Parse oder TryParse aufrufen, ist der Standardwert DateTimeStyles.AllowWhiteSpaces, der ein zusammengesetztes Stil handelt, der DateTimeStyles.AllowLeadingWhite, DateTimeStyles.AllowTrailingWhite und DateTimeStyles.AllowInnerWhite-Flags enthält. Für die ParseExact und TryParseExact für Methoden ist der Standardwert DateTimeStyles.None; muss die Eingabezeichenfolge an eine bestimmten benutzerdefinierten Formatzeichenfolge für Datum und Uhrzeit genau entsprechen.

Die Analysemethoden auch implizit oder explizit verwenden ein DateTimeFormatInfo-Objekt, das die einzelnen Symbole und Muster definiert, die in die zu analysierende Zeichenfolge erfolgen können. Wenn Sie kein DateTimeFormatInfo-Objekt bereitstellen, wird das DateTimeFormatInfo-Objekt für die aktuelle Threadkultur standardmäßig verwendet. Weitere Informationen über Analysedatums- und uhrzeitzeichenfolgen, finden Sie die einzelnen Analysemethoden, wie DateTime.Parse, DateTime.TryParse, DateTimeOffset.ParseExact und DateTimeOffset.TryParseExact.

Das folgende Beispiel veranschaulicht die kulturabhängige Weise von Analysedatums- und uhrzeitzeichenfolgen. Es wird versucht, zwei Datumszeichenfolgen analysieren, indem die Konventionen en-US, des en-GBs, des fr-FRs und der FIFI-Kulturen verwendet. Das Datum, das als 8/18/2014 in der Kultur en-US interpretiert wird, löst FormatException eine Ausnahme in die anderen drei Kulturen, weil 18 als die Monatszahl interpretiert wird. 1/2/2015 wird als der zweite Tag des ersten Monats in der Kultur en-US, sondern als der erste Tag des Monats zweiten in den verbleibenden Kulturen analysiert.


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


Datums- Uhrzeitzeichenfolgen werden normalerweise aus zwei Gründen analysiert:

  • So Benutzereingaben in einen Datums- und Uhrzeitwert konvertieren.

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

In den folgenden Abschnitten werden diese zwei Vorgänge ausführlich.

c6dw49cz.collapse_all(de-de,VS.110).gifAnalysebenutzerzeichenfolgen

Wenn Sie die Datums- Uhrzeitzeichenfolgen analysieren, die vom Benutzer eingegeben werden, sollte ein DateTimeFormatInfo-Objekt, das die Kultureinstellungen des Benutzers übernommen, darunter alle Anpassungen immer instanziieren, die der Benutzer eventuell vorgenommenen. Andernfalls haben möglicherweise das Datum und das Zeitobjekt falsche Werte. Informationen, wie Sie DateTimeFormatInfo-Objekt, die kulturelle Anpassungen des Benutzers entspricht, finden Sie im Abschnitt DateTimeFormatInfo und dynamische Daten instanziiert.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem Analysevorgang, der Benutzerkultureinstellungen widerspiegelt und einen, der nicht vorhanden ist. In diesem Fall ist die Standardsystemkultur en-US, der Benutzer verfügt Systemsteuerung, Region und Sprache verwendet, um dem kurzen Datumsmuster von den Standardwert "M/d/yyyy" zu "yy/MM/dd" zu ändern. Wenn der Benutzer eine Zeichenfolge, die Benutzer und die Zeichenfolge widergespiegelt, analysiert wird durch ein DateTimeFormatInfo-Objekt eingibt, das auch (Benutzereinstellungen Überschreibungen) wiedergibt, gibt der Analysevorgang ein richtiges Ergebnis zurück. Wenn die Zeichenfolge durch ein DateTimeFormatInfo-Objekt analysiert wird, das Standard-en-US-Kultureinstellungen widergespiegelt, löst der Analysemethode eine FormatException Ausnahme, da 14 als die Nummer des Monats interpretiert, nicht die letzten zwei Ziffern vom Jahr aus.


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


c6dw49cz.collapse_all(de-de,VS.110).gifDatums- und Uhrzeitdaten Serialisieren und Deserialisieren

Serialisierte Datums- und Uhrzeitdaten werden erwartet, dass ein Roundtrip zu übergeben; das heißt, sollten alle serialisierten und deserialisierten Werte identisch sein. Wenn der Datums- und Uhrzeitwert einen einzelnen Zeitpunkt darstellt, sollte der deserialisierte Wert den gleichen Zeitpunkt unabhängig von der verwendeten Kultur oder die Zeitzone des Systems darstellen, auf dem sie wiederhergestellt wurde. Um von Datums- und Uhrzeitdaten erfolgreich einen Roundtrip zu übergeben, müssen Sie die Konventionen der invarianten Kultur verwenden, die durch die InvariantInfo-Eigenschaft zurückgegeben wird, um die Daten zu generieren und zu analysieren. Die Formatierung und Analyseoperationen sollten die Konventionen der Standardkultur nie entsprechen. Wenn Sie Standardkultureinstellungen verwenden, wird die Portabilität der Daten ausschließlich beschränkt; Sie kann nur in einem Thread erfolgreich deserialisiert werden, dessen Kulturellbesondereeinstellungen denen des Threads identisch sind, auf dem er serialisiert wurde. In einigen Fällen bedeutet dies, dass die Daten auf dem gleichen System nicht einmal erfolgreich serialisiert und deserialisiert werden können.

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

Das folgende Beispiel veranschaulicht den Prozess des einen Roundtrip führens eines Datums- und Uhrzeitwerts. Es werden ein Datum und eine Uhrzeit in einem System, das auf US-pazifische Zeit achtet 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)


Es deserialisiert die Daten in einem System in der Brüssel-, Kopenhagen-, Madrid- und Paris-Zeitzone 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 nach UTC an eine Stunde vor UTC an. Beides ursprüngliche Datum und das wiederhergestellte Datum stellt 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


Die folgende Beispielsverwendungsreflektion, um die Eigenschaften des DateTimeFormatInfo-Objekts für die Kultur Englisch (USA) abzurufen. Sie zeigt den Wert dieser Eigenschaften, die benutzerdefinierte Formatzeichenfolgen enthalten an und verwendet diese Zeichenfolgen, für 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


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft