Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

NumberFormatInfo-Klasse

 

Veröffentlicht: Oktober 2016

Stellt kulturspezifische Informationen für Formatierung und Analyse für numerische Werte bereitstellt.

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

System.Object
  System.Globalization.NumberFormatInfo

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

NameBeschreibung
System_CAPS_pubmethodNumberFormatInfo()

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

NameBeschreibung
System_CAPS_pubpropertyCurrencyDecimalDigits

Ruft die Anzahl der in Währungswerten zu verwendenden Dezimalstellen ab oder legt diese fest.

System_CAPS_pubpropertyCurrencyDecimalSeparator

Ruft die in Währungsangaben als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.

System_CAPS_pubpropertyCurrencyGroupSeparator

Ruft die Zeichenfolge ab, mit der bei Währungsangaben Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.

System_CAPS_pubpropertyCurrencyGroupSizes

Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in Währungsangaben ab oder legt diese fest.

System_CAPS_pubpropertyCurrencyNegativePattern

Ruft das Formatmuster für negative Währungsangaben ab oder legt dieses fest.

System_CAPS_pubpropertyCurrencyPositivePattern

Ruft das Formatmuster für positive Währungsangaben ab oder legt dieses fest.

System_CAPS_pubpropertyCurrencySymbol

Ruft die als Währungssymbol zu verwendende Zeichenfolge ab oder legt diese fest.

System_CAPS_pubpropertySystem_CAPS_staticCurrentInfo

Ruft eine schreibgeschützte NumberFormatInfo ab, die Werte auf Grundlage der aktuellen Kultur formatiert.

System_CAPS_pubpropertyDigitSubstitution

Ruft einen Wert ab oder legt einen Wert fest, der angibt, in welcher Form die grafische Benutzeroberfläche Ziffern anzeigt.

System_CAPS_pubpropertySystem_CAPS_staticInvariantInfo

Ruft ein schreibgeschütztes NumberFormatInfo-Objekt ab, das kulturunabhängig (invariant) ist.

System_CAPS_pubpropertyIsReadOnly

Ruft einen Wert ab, der angibt, ob dieses NumberFormatInfo-Objekt schreibgeschützt ist.

System_CAPS_pubpropertyNaNSymbol

Ruft die Zeichenfolge ab, die den IEEE-NaN-Wert (Not a Number) darstellt, oder legt diese fest.

System_CAPS_pubpropertyNativeDigits

Ruft ein Zeichenfolgenarray mit systemeigenen Ziffern ab, die den europäischen Ziffern 0 (null) bis 9 entsprechen, oder legt ein entsprechendes Zeichenfolgenarray fest.

System_CAPS_pubpropertyNegativeInfinitySymbol

Ruft die Zeichenfolge ab, die minus unendlich darstellt, oder legt diese fest.

System_CAPS_pubpropertyNegativeSign

Ruft die Zeichenfolge ab, die kennzeichnet, dass die zugeordnete Zahl negativ ist, oder legt diese fest.

System_CAPS_pubpropertyNumberDecimalDigits

Ruft die Anzahl der in numerischen Werten zu verwendenden Dezimalstellen ab oder legt diese fest.

System_CAPS_pubpropertyNumberDecimalSeparator

Ruft die in numerischen Werten als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.

System_CAPS_pubpropertyNumberGroupSeparator

Ruft die Zeichenfolge ab, mit der bei numerischen Werten Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.

System_CAPS_pubpropertyNumberGroupSizes

Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in numerischen Werten ab oder legt diese fest.

System_CAPS_pubpropertyNumberNegativePattern

Ruft das Formatmuster für negative numerische Werte ab oder legt dieses fest.

System_CAPS_pubpropertyPercentDecimalDigits

Ruft die Anzahl der in Prozentwerten zu verwendenden Dezimalstellen ab oder legt diese fest.

System_CAPS_pubpropertyPercentDecimalSeparator

Ruft die in Prozentwerten als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.

System_CAPS_pubpropertyPercentGroupSeparator

Ruft die Zeichenfolge ab, mit der in Prozentwerten Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.

System_CAPS_pubpropertyPercentGroupSizes

Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in Prozentwerten ab oder legt diese fest.

System_CAPS_pubpropertyPercentNegativePattern

Ruft das Formatmuster für negative Prozentangaben ab oder legt dieses fest.

System_CAPS_pubpropertyPercentPositivePattern

Ruft das Formatmuster für positive Prozentangaben ab oder legt dieses fest.

System_CAPS_pubpropertyPercentSymbol

Ruft die als Prozentsymbol zu verwendende Zeichenfolge ab oder legt diese fest.

System_CAPS_pubpropertyPerMilleSymbol

Ruft die als Promillesymbol zu verwendende Zeichenfolge ab oder legt diese fest.

System_CAPS_pubpropertyPositiveInfinitySymbol

Ruft die Zeichenfolge ab, die plus unendlich darstellt, oder legt diese fest.

System_CAPS_pubpropertyPositiveSign

Ruft die Zeichenfolge ab, die kennzeichnet, dass die zugeordnete Zahl positiv ist, oder legt diese fest.

NameBeschreibung
System_CAPS_pubmethodClone()

Erstellt eine flache Kopie des NumberFormatInfo-Objekts.

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_pubmethodGetFormat(Type)

Ruft ein Objekt vom angegebenen Typ ab, das einen Zahlenformatierungsdienst bereitstellt.

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticGetInstance(IFormatProvider)

Ruft die NumberFormatInfo ab, die dem angegebenen IFormatProvider zugeordnet ist.

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodSystem_CAPS_staticReadOnly(NumberFormatInfo)

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

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

Instanziieren Sie ein NumberFormatInfo Objekt, das die Formatierungskonventionen der aktuellen Kultur, die invariante Kultur, eine bestimmte Kultur oder eine neutrale Kultur darstellt.

Instanziieren Sie ein NumberFormatInfo -Objekt für die aktuelle Threadkultur in einer der folgenden Methoden. In jedem Fall die zurückgegebene NumberFormatInfo Objekt ist schreibgeschützt.

Im folgenden Beispiel wird diese drei Methoden zum Erstellen von NumberFormatInfo -Objekten, die Formatierungskonventionen der aktuellen Kultur darstellen. Auch der Wert von abgerufen, die IsReadOnly Eigenschaft, um zu veranschaulichen, dass jedes Objekt schreibgeschützt ist.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo current1 = CultureInfo.CurrentCulture.NumberFormat;
      Console.WriteLine(current1.IsReadOnly);

      NumberFormatInfo current2 = NumberFormatInfo.CurrentInfo;
      Console.WriteLine(current2.IsReadOnly);

      NumberFormatInfo current3 = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture);
      Console.WriteLine(current3.IsReadOnly);
   }
}
// The example displays the following output:
//       True
//       True
//       True

Sie können eine nicht schreibgeschützte erstellen NumberFormatInfo -Objekt, das die Konventionen der aktuellen Threadkultur, in einer der folgenden Methoden darstellt:

  • Durch das Abrufen einer NumberFormatInfo Objekt in den Methoden, die im vorherigen Codebeispiel dargestellt und das Aufrufen der Clone -Methode für das zurückgegebene NumberFormatInfo Objekt. Erstellt eine Kopie der ursprünglichen NumberFormatInfo -Objekt, mit Ausnahme der IsReadOnly -Eigenschaft ist false.

  • Durch Aufrufen der CultureInfo.CreateSpecificCulture Methode zum Erstellen einer CultureInfo -Objekt, das die aktuelle Kultur darstellt, und dann seine CultureInfo.NumberFormat -Eigenschaft zum Abrufen der NumberFormatInfo Objekt.

Das folgende Beispiel veranschaulicht diese zwei Methoden zum Instanziieren einer NumberFormatInfo -Objekt und zeigt den Wert der IsReadOnly Eigenschaft, um zu veranschaulichen, dass das Objekt nicht schreibgeschützt ist.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo current1 = NumberFormatInfo.CurrentInfo;
      current1 = (NumberFormatInfo) current1.Clone();
      Console.WriteLine(current1.IsReadOnly);

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      NumberFormatInfo current2 = culture2.NumberFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False

Beachten Sie, dass das Windows-Betriebssystem der Benutzer einige der überschreiben kann die NumberFormatInfo Eigenschaftswerte in numerische Formatierung und Analyse von Operationen durch die Region und Sprache Element in der Systemsteuerung. Ein Benutzer mit der Kultur Englisch (USA) ist z. B. können Währungsangaben als 1.1 USD anstelle des Standardwerts von $1.1 angezeigt. Die NumberFormatInfo erläutert Möglichkeiten abgerufene Objekte zuvor spiegeln diese Benutzer überschreibt. Wenn dies nicht erwünscht ist, erstellen Sie ein NumberFormatInfo -Objekt, das Benutzer überschreibt nicht wiedergibt (und außerdem Lese-/Schreibzugriff ist statt nur-Lese) durch Aufrufen der CultureInfo.CultureInfo(String, Boolean) -Konstruktor und den Wert false für die useUserOverride Argument. Das folgende Beispiel veranschaulicht ein System, dessen aktuelle Kultur Englisch (USA) ist und dessen Währungssymbol vom Standardwert $ in US-Dollar geändert wurde.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;

      culture = CultureInfo.CurrentCulture;
      nfi = culture.NumberFormat;
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}\n", culture.NumberFormat.CurrencySymbol);

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol);
   }
}
// The example displays the following output:
//       Culture Name:    en-US
//       User Overrides:  True
//       Currency Symbol: USD
//       
//       Culture Name:    en-US
//       User Overrides:  False
//       Currency Symbol: $

Wenn die CultureInfo.UseUserOverride Eigenschaft auf festgelegt ist true, die Eigenschaften CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, und CultureInfo.TextInfo auch aus den benutzereinstellungen abgerufen werden. Wenn die Einstellungen nicht kompatibel mit der Kultur zugeordnet sind die CultureInfo Objekt (z. B., wenn Sie der ausgewählte Kalender nicht aufgelisteten Kalender ist die OptionalCalendars Eigenschaft), die Ergebnisse der Methoden und die Werte der Eigenschaften sind nicht definiert.

Die invariante Kultur stellt eine Kultur, die kulturunabhängig ist. Es basiert auf der englischen Sprache, jedoch nicht auf alle englischsprachigen Land/die Region. Obwohl die Daten für bestimmte Kulturen dynamisch sein können und können neue kulturelle Konventionen oder Benutzervoreinstellungen entsprechend ändern, ändert sich die Daten der invarianten Kultur nicht. Ein NumberFormatInfo -Objekt, das die Formatierungskonventionen der invarianten Kultur darstellt, kann für Formatierungsvorgänge Zeichenfolgen sollten in der Ergebnismenge nicht unterscheiden von Kultur verwendet werden.

Instanziieren Sie ein NumberFormatInfo -Objekt, das die Formatierungskonventionen der invarianten Kultur, auf folgende Weise darstellt:

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

  • Durch das Abrufen des Werts der CultureInfo.NumberFormat Eigenschaft aus der CultureInfo -Objekt, das von zurückgegebene die CultureInfo.InvariantCulture Eigenschaft. Das zurückgegebene NumberFormatInfo Objekt ist schreibgeschützt.

  • Durch Aufrufen der parameterlosen NumberFormatInfo Klassenkonstruktor. Das zurückgegebene NumberFormatInfo Objekt wird Lese-/Schreibzugriff.

Im folgenden Beispiel wird jede dieser Methoden zum Instanziieren einer NumberFormatInfo -Objekt, das die invariante Kultur darstellt. Anschließend wird angegeben, ob das Objekt schreibgeschützt ist,

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nfi;

      nfi = System.Globalization.NumberFormatInfo.InvariantInfo;
      Console.WriteLine(nfi.IsReadOnly);               

      nfi = CultureInfo.InvariantCulture.NumberFormat;
      Console.WriteLine(nfi.IsReadOnly);               

      nfi = New NumberFormatInfo();
      Console.WriteLine(nfi.IsReadOnly);               
   }
}
// The example displays the following output:
//       True
//       True
//       False

Eine bestimmte Kultur darstellt, eine Sprache, die in einer bestimmten Ländern/Regionen gesprochen wird. Z. B. En-US ist eine bestimmte Kultur, die die englische Sprache, die in den Vereinigten Staaten darstellt; En-CA ist eine bestimmte Kultur, die die englische Sprache, die in Kanada darstellt. Instanziieren Sie ein NumberFormatInfo -Objekt, das die Formatierungskonventionen einer bestimmten Kultur, auf folgende Weise darstellt:

Im folgenden Beispiel wird diese vier Methoden zum Erstellen einer NumberFormatInfo -Objekt, das die Formatierungskonventionen der Kultur Indonesisch (Indonesien) entspricht. Außerdem wird angegeben, ob jedes Objekt schreibgeschützt ist.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo culture;
      NumberFormatInfo nfi;

      nfi = CultureInfo.GetCultureInfo("id-ID").NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);

      culture = new CultureInfo("id-ID");
      nfi = NumberFormatInfo.GetInstance(culture);
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);

      culture = CultureInfo.CreateSpecificCulture("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);

      culture = new CultureInfo("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
   }
}
// The example displays the following output:
//       Read-only: True
//       Read-only: False
//       Read-only: False
//       Read-only: False

Eine neutrale Kultur darstellt, eine Kultur oder Sprache, die unabhängig von Sprache/Land ist. Es ist normalerweise das übergeordnete Element des einen oder mehrere bestimmte Kulturen. Beispielsweise ist "fr" für die französische Sprache und das übergeordnete Element der fr-FR-Kultur eine neutrale Kultur. Sie erstellen ein NumberFormatInfo Objekt, das die Formatierungskonventionen einer neutralen Kultur auf die gleiche Weise darstellt, die Sie erstellen ein NumberFormatInfo Objekt, das die Formatierungskonventionen einer bestimmten Kultur darstellt.

System_CAPS_noteHinweis

In der .NET Framework 3.5 und früheren Versionen, die beim Abrufen einer NumberFormatInfo -Objekt, das die Formatierungskonventionen einer neutralen Kultur widerspiegelt löst eine NotSupportedException Ausnahme.

Allerdings ist es unabhängig von einem bestimmten Land/Region, verfügt nicht über eine neutrale Kultur kulturspezifische Formatierungsinformationen. Anstatt zum Auffüllen der NumberFormatInfo -Objekt mit den Werten der generischen, .NET Framework gibt ein NumberFormatInfo -Objekt, das die Formatierungskonventionen einer bestimmten Kultur, die widerspiegelt ist ein untergeordnetes Element der neutralen Kultur. Z. B. die NumberFormatInfo -Objekt für die En neutrale Kultur die Formatierungskonventionen der Kultur En-US widerspiegelt und NumberFormatInfo -Objekt für die Kultur fr die Formatierungskonventionen der Kultur fr-FR widerspiegelt.

Sie können Code wie den folgenden um Formatierungskonventionen der bestimmten Kultur zu ermitteln, jede neutrale Kultur darstellt.

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 NumberFormatInfo object.
      NumberFormatInfo nfi = CultureInfo.GetCultureInfo(name).NumberFormat;
      // 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 NumberFormatInfo properties
      PropertyInfo[] properties = typeof(NumberFormatInfo).GetProperties(BindingFlags.Instance | BindingFlags.Public);
      bool hasOneMatch = false;

      foreach (var ci in cultures) {
         bool match = true;     
         // Get the NumberFormatInfo for a specific culture.
         NumberFormatInfo specificNfi = ci.NumberFormat;
         // 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(nfi, null);
               IList sList = (IList) prop.GetValue(specificNfi, null);
               if (nList.Count != sList.Count) {
                  match = false;
                  break;
               } 

               for (int ctr = 0; ctr < nList.Count; ctr++) {
                  if (! nList[ctr].Equals(sList[ctr])) {
                     match = false;
                     break;
                  }     
               }
            }   
            else if (! prop.GetValue(specificNfi).Equals(prop.GetValue(nfi))) {
               match = false;
               break;   
            }        
         }
         if (match) {
            Console.WriteLine("NumberFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name);
            hasOneMatch = true;
         }                                       
      }
      if (! hasOneMatch)
         Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name);            

      Console.WriteLine();
   }
}

Die kulturspezifische Daten zur Formatierung von numerischer Werten der NumberFormatInfo -Klasse ist dynamisch, wie die kulturellen Daten die CultureInfo Klasse. Sie sollten keine Annahmen über die Stabilität der Werte für NumberFormatInfo verknüpften Objekte mit bestimmten CultureInfo Objekte. Nur die Daten der invarianten Kultur und die zugehörigen NumberFormatInfo Objekt stabil ist. Andere Daten können zwischen anwendungssitzungen oder sogar innerhalb einer einzelnen Sitzung den folgenden Gründen ändern:

  • System-Updates. Kulturelle Einstellungen wie z. B. das Währungssymbol oder Währungsformate werden mit der Zeit ändern. In diesem Fall enthält Windows Update Änderungen an der NumberFormatInfo Eigenschaftswert für eine bestimmte Kultur.

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

  • Kaskadierende Änderungen von Eigenschaftswerten. Eine Reihe von Eigenschaften kulturbezogene kann zur Laufzeit, die wiederum ändern NumberFormatInfo Daten ändern. Beispielsweise kann für die aktuelle Kultur entweder programmgesteuert oder durch eine Benutzeraktion geändert werden. In diesem Fall die NumberFormatInfo von zurückgegebenen Objekts die CurrentInfo Eigenschaft ändert sich in ein Objekt der aktuellen Kultur zugeordnet.

  • Voreinstellungen des Benutzers. Benutzer der Anwendung möglicherweise einige der Werte, die die aktuelle Systemkultur die Region und Sprache Optionen in der Systemsteuerung zugeordneten überschrieben. Benutzer können z. B. ein anderes Währungssymbol oder eine andere Dezimaltrennzeichen. Wenn die CultureInfo.UseUserOverride Eigenschaft auf festgelegt ist true (der Standardwert), die Eigenschaften der NumberFormatInfo Objekt auch aus den benutzereinstellungen abgerufen werden.

Ab .NET Framework 2.0, alle Benutzer überschreibbaren Eigenschaften einer NumberFormatInfo Objekt werden initialisiert, wenn das Objekt erstellt wurde. Besteht immer noch von Inkonsistenz, da keine Erstellung-Objekt noch Benutzerprozess Außerkraftsetzung ist unteilbar, und die relevanten Werte während der Erstellung des Objekts ändern können. Allerdings sollten diese Inkonsistenzen tritt nur sehr selten sein.

Sie können steuern, ob Benutzer überschreibt dargestellt werden NumberFormatInfo Objekte, die dieselbe Kultur aufweist wie die aktuelle Threadkultur darstellen. Die folgende Tabelle enthält, auf welche Weise ein NumberFormatInfo Objekt abgerufen werden kann, und gibt an, ob das resultierende Objekt Benutzer überschreibt widerspiegeln.

CultureInfo und NumberFormatInfo-Objekt

Gibt Benutzer Außerkraftsetzungen

CultureInfo.CurrentCulture.NumberFormat-Eigenschaft

Ja

NumberFormatInfo.CurrentInfo-Eigenschaft

Ja

CultureInfo.CreateSpecificCulture-Methode

Ja

CultureInfo.GetCultureInfo-Methode

Nein

CultureInfo(String)-Konstruktor

Ja

CultureInfo.CultureInfo(String, Boolean)-Konstruktor

Hängt vom Wert der useUserOverride Parameter

Sofern kein zwingender Grund nicht vorhanden ist, Sie sollten Sie berücksichtigen, überschreibt der Benutzer bei Verwendung der NumberFormatInfo Objekt in Clientanwendungen, formatieren und Analysieren von Benutzereingaben oder numerische Daten angezeigt. Für serveranwendungen oder unbeaufsichtigte sollten Sie Benutzer überschreibt nicht berücksichtigt. Allerdings bei Verwendung der NumberFormatInfo Objekt entweder explizit oder implizit um numerische Daten in Form einer Zeichenfolge beizubehalten, sollten Sie entweder ein NumberFormatInfo -Objekt, das die Formatierungskonventionen der invarianten Kultur, oder Sie gibt eine benutzerdefinierte numerische Formatzeichenfolge, mit denen Sie unabhängig von der Kultur angeben sollten.

Ein NumberFormatInfo Objekt wird in allen numerischen Formatierungsvorgängen implizit oder explizit verwendet. Dazu gehören die folgenden Methoden aufrufen:

Stellen Sie alle numerische Formatierungsvorgängen verwendet ein IFormatProvider Implementierung. Die IFormatProvider Schnittstelle enthält nur die Methode GetFormat(Type). Dies ist eine Rückrufmethode, die übergeben wird, wird ein Type -Objekt, das den Typ erforderlich, um Formatierungsinformationen bereitzustellen darstellt. Die Methode ist verantwortlich für die Rückgabe entweder einer Instanz dieses Typs oder null, wenn sie eine Instanz des Typs bereitstellen kann. .NET Framework bietet zwei IFormatProvider Implementierungen zum Formatieren von Zahlen:

  • Die CultureInfo -Klasse, die eine bestimmte Kultur oder eine bestimmte Sprache in einem bestimmten Land/Region darstellt. In eine numerische Formatierung-Operation die CultureInfo.GetFormat -Methode gibt die NumberFormatInfo zugeordnete Objekt seine CultureInfo.NumberFormat Eigenschaft.

  • Die NumberFormatInfo -Klasse, die Informationen über die Formatierungskonventionen der zugeordnete Kultur bereitstellt. Die NumberFormatInfo.GetFormat -Methode gibt eine Instanz von sich selbst zurück.

Wenn ein IFormatProvider Implementierung wird nicht explizit an eine Formatierungsmethode bereitgestellt einer CultureInfo zurückgegebenes Objekt die CultureInfo.CurrentCulture -Eigenschaft, die aktuelle Threadkultur darstellt, wird verwendet.

Das folgende Beispiel veranschaulicht die Beziehung zwischen der IFormatProvider Schnittstelle und die NumberFormatInfo bei Formatierungsvorgängen durch Definieren einer benutzerdefinierten Klasse IFormatProvider Implementierung. Die GetFormat Methode zeigt den Typnamen des Objekts, durch den Formatierungsvorgang angefordert. Wenn die Schnittstelle angefordert wird ein NumberFormatInfo Objekt, diese Methode bietet die NumberFormatInfo -Objekt für die aktuelle Threadkultur. Wie die Ausgabe des Beispiels zeigt die Decimal.ToString(IFormatProvider) Anforderungsmethoden ein NumberFormatInfo Objekt, das Formatierungsinformationen hingegen stellen die String.Format(IFormatProvider, String, Object[]) Anforderungsmethoden NumberFormatInfo und DateTimeFormatInfo Objekte als auch einen ICustomFormatter Implementierung.

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()
   {
      Decimal amount = 1203.541m;
      string value = amount.ToString("C2", new CurrentCultureFormatProvider());
      Console.WriteLine(value);
      Console.WriteLine();
      string composite = String.Format(new CurrentCultureFormatProvider(), 
                                       "Date: {0}   Amount: {1}   Description: {2}",
                                       DateTime.Now, 1264.03m, "Service Charge");
      Console.WriteLine(composite);
      Console.WriteLine();
   }
}
// The example displays output like the following:
//    Requesting an object of type NumberFormatInfo
//    $1,203.54
//    
//    Requesting an object of type ICustomFormatter
//    Requesting an object of type DateTimeFormatInfo
//    Requesting an object of type NumberFormatInfo
//    Date: 11/15/2012 2:00:01 PM   Amount: 1264.03   Description: Service Charge

Wenn ein IFormatProvider Implementierung in eine numerische Formatierung-Methodenaufruf, ruft die Methode nicht explizit angegeben ist die CultureInfo.CurrentCulture.GetFormat -Methode, die gibt die NumberFormatInfo Objekt, das die aktuelle Threadkultur entspricht.

Jede Formatierungsvorgang verwendet entweder eine standardmäßige oder benutzerdefinierte numerische Formatzeichenfolge erzeugt eine Ergebniszeichenfolge aus einer Reihe an. In einigen Fällen ist die Verwendung einer Formatzeichenfolge erzeugt eine Ergebniszeichenfolge explizit, wie im folgenden Beispiel. Dieser Code Ruft die Decimal.ToString(IFormatProvider) -Methode zum Konvertieren einer Decimal Wert mit einer Reihe von verschiedenen zeichenfolgendarstellungen, die unter Verwendung der Formatierungskonventionen der Kultur En-US.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] formatStrings = { "C2", "E1", "F", "G3", "N", 
                                 "#,##0.000", "0,000,000,000.0##" };
      CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
      Decimal[] values = { 1345.6538m, 1921651.16m };

      foreach (var value in values) {
         foreach (var formatString in formatStrings) {
            string resultString = value.ToString(formatString, culture);
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString);
         }
         Console.WriteLine();      
      }   
   }
}
// The example displays the following output:
//       C2                 -->  $1,345.65
//       E1                 -->  1.3E+003
//       F                  -->  1345.65
//       G3                 -->  1.35E+03
//       N                  -->  1,345.65
//       #,##0.000          -->  1,345.654
//       0,000,000,000.0##  -->  0,000,001,345.654
//       
//       C2                 -->  $1,921,651.16
//       E1                 -->  1.9E+006
//       F                  -->  1921651.16
//       G3                 -->  1.92E+06
//       N                  -->  1,921,651.16
//       #,##0.000          -->  1,921,651.160
//       0,000,000,000.0##  -->  0,001,921,651.16

In anderen Fällen ist die Verwendung einer Formatzeichenfolge implizit. Z. B. in der folgenden Methodenaufrufe auf den Standardwert oder parameterlosen Decimal.ToString() -Methode wird der Wert von der Decimal Instanz mithilfe der allgemeine Formatbezeichner ("G") und die Konventionen der aktuellen Kultur, in diesem Fall wird die Kultur En-US formatiert ist.

using System;

public class Example
{
   public static void Main()
   {
      Decimal[] values = { 1345.6538m, 1921651.16m };

      foreach (var value in values) {
         string resultString = value.ToString();
         Console.WriteLine(resultString);
         Console.WriteLine();      
      }   
   }
}
// The example displays the following output:
//       1345.6538
//       
//       1921651.16

Jede standardmäßige numerische Formatzeichenfolge verwendet, eine oder mehrere NumberFormatInfo Eigenschaften zur Bestimmung des Musters oder die Symbole in der Ergebniszeichenfolge verwendet. Auf ähnliche Weise jeder benutzerdefinierten Formatbezeichner für numerische außer "0" und "#" in der Ergebniszeichenfolge, die von definierten Symbole einfügen NumberFormatInfo Eigenschaften. Die folgende Tabelle enthält die Standard- und benutzerdefinierten Zahlenformatbezeichner und ihre zugeordneten NumberFormatInfo Eigenschaften. Um die Darstellung der Ergebniszeichenfolge für eine bestimmte Kultur zu ändern, finden Sie unter der Ändern NumberFormatInfo-Eigenschaften Abschnitt. Details zu diesen Formatbezeichnern finden Sie unter Standardmäßige Zahlenformatzeichenfolgen und Benutzerdefinierte Zahlenformatzeichenfolgen.

Formatbezeichner

Zugeordnete Eigenschaften.

"C" oder "c" (Währungsformatbezeichner)

CurrencyDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

CurrencyDecimalSeparator, um das Dezimaltrennzeichen definieren.

CurrencyGroupSeparator, der Gruppe oder gar tausenden definieren Trennzeichen.

CurrencyGroupSizes, um die Größe des ganzzahligen Gruppen definieren.

CurrencyNegativePattern, um das Muster für negative Währungsangaben zu definieren.

CurrencyPositivePattern, um das Muster für positive Währungsangaben zu definieren.

CurrencySymbol, um das Währungssymbol zu definieren.

NegativeSign, um das Minuszeichen zu definieren.

"D" oder "d" (Dezimalformatbezeichner)

NegativeSign, um das Minuszeichen zu definieren.

"E" oder "e" (exponentiellen oder wissenschaftliche Formatbezeichner)

NegativeSign, um das Minuszeichen in der Mantisse und dem Exponent zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen definieren.

PositiveSign, definieren Sie das Pluszeichen im Exponenten.

"F" oder "f" (Festkommaformatbezeichner)

NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen definieren.

"G" oder "g" (allgemeiner Formatbezeichner)

NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen definieren.

PositiveSign, auf das Pluszeichen für Ergebniszeichenfolgen im Exponentialformat definieren.

"N" oder "n" (Zahlenformatbezeichner)

NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen definieren.

NumberGroupSeparator, um das Gruppentrennzeichen (Tausende) zu definieren.

NumberGroupSizes, um die Anzahl von ganzzahligen Ziffern in einer Gruppe definieren.

NumberNegativePattern, um das Format von negativen Werten definieren.

"P" oder "p" (Prozentformatbezeichner)

NegativeSign, um das Minuszeichen zu definieren.

PercentDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

PercentDecimalSeparator, um das Dezimaltrennzeichen definieren.

PercentGroupSeparator, das Gruppentrennzeichen definiert.

PercentGroupSizes, um die Anzahl von ganzzahligen Ziffern in einer Gruppe definieren.

PercentNegativePattern, um die Platzierung des Prozentsymbols sowie des Minuszeichens für negative Werte zu definieren.

PercentPositivePattern, um die Platzierung des Prozentsymbols für positive Werte zu definieren.

PercentSymbol, definiert das Prozentsymbol.

"R" oder "R" (Schleifenformatbezeichner)

NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen definieren.

PositiveSign, auf das Pluszeichen in einem Exponenten zu definieren.

"X" oder "x" (Hexadezimal-Formatbezeichner)

Keiner.

"." (benutzerdefinierte Formatbezeichner Dezimaltrennzeichen)

NumberDecimalSeparator, um das Dezimaltrennzeichen definieren.

"," (benutzerdefiniertes Formatbezeichner für Gruppentrennzeichen)

NumberGroupSeparator, um das Gruppentrennzeichen (Tausende) zu definieren.

"%" (Prozentsatz Platzhalter benutzerdefinierte Formatbezeichner)

PercentSymbol, definiert das Prozentsymbol.

"‰" (pro Promillezeichen Platzhalter benutzerdefinierte Formatbezeichner)

PerMilleSymbol, definieren die Promillesymbol.

"E" (benutzerdefinierte Formatbezeichner Exponentialschreibweise)

NegativeSign, um das Minuszeichen in der Mantisse und dem Exponent zu definieren.

PositiveSign, definieren Sie das Pluszeichen im Exponenten.

Beachten Sie, dass die NumberFormatInfo -Klasse enthält eine NativeDigits Eigenschaft, die die Basis 10-Ziffern verwendet, die für eine bestimmte Kultur angibt. Die Eigenschaft wird jedoch nicht verwendet, bei Formatierungsvorgängen. nur die grundlegenden lateinischen Ziffern 0 (U + 0030) bis 9 (U + 0039) werden in der Ergebniszeichenfolge verwendet. Außerdem ist für Single und Double Werte NaN, PositiveInfinity, und NegativeInfinity, die Ergebniszeichenfolge besteht ausschließlich von definierten Symbole der NaNSymbol, PositiveInfinitySymbol, und NegativeInfinitySymbol Eigenschaften bzw..

Sie können die Eigenschaften ändern ein NumberFormatInfo Objekt zum Anpassen der Ergebniszeichenfolge in eine numerische Formatierung Vorgang erzeugt. Gehen Sie dazu wie folgt vor:

  1. Erstellen Sie eine Lese-/Schreibkopie der ein NumberFormatInfo Objekt, deren Formatierungskonventionen, die Sie ändern möchten. Weitere Informationen finden Sie unter der Instanziieren eines Objekts NumberFormatInfo Abschnitt.

  2. Ändern Sie die Eigenschaft bzw. Eigenschaften, die verwendet werden, um das gewünschte Ergebnis-Zeichenfolge zu erzeugen. Informationen wie Formatierung Methoden verwenden NumberFormatInfo Ergebniszeichenfolgen, Definieren von Eigenschaften finden Sie unter der Formatieren von Zeichenfolgen und NumberFormatInfo-Eigenschaften Abschnitt.

  3. Verwenden Sie das benutzerdefinierte NumberFormatInfo -Objekt als die IFormatProvider Argument in Aufrufen von Formatierungsmethoden.

System_CAPS_noteHinweis

Anstatt zu dynamisch ändern einer Kultur Eigenschaftswerte jedes Mal eine Anwendung gestartet wird, können Sie die CultureAndRegionInfoBuilder -Klasse definiert eine benutzerdefinierte Kultur (eine Kultur, die einen eindeutigen Namen hat und erweitert vorhandene, Kulturen) oder eine Kultur (eine anstelle einer bestimmten Kultur verwendet wird).

Die folgenden Abschnitte enthalten einige Beispiele.

Im folgenden Beispiel wird ein NumberFormatInfo Objekt, das die Formatierungskonventionen der Kultur En-US darstellt. Er weist das Währungssymbol nach ISO 4217 finden die CurrencySymbol Eigenschaft und definiert ein Muster für die Currency-Werte, der das Währungssymbol gefolgt von einem Leerzeichen und einen numerischen Wert besteht.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Retrieve a writable NumberFormatInfo object.
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      NumberFormatInfo nfi = enUS.NumberFormat;

      // Use the ISO currency symbol instead of the native currency symbol.
      nfi.CurrencySymbol =  (new RegionInfo(enUS.Name)).ISOCurrencySymbol;
      // Change the positive currency pattern to <code><space><value>.
      nfi.CurrencyPositivePattern = 2;
      // Change the negative currency pattern to <code><space><sign><value>.     
      nfi.CurrencyNegativePattern = 12;

      // Produce the result strings by calling ToString.
      Decimal[] values = { 1065.23m, 19.89m, -.03m, -175902.32m };
      foreach (var value in values)
         Console.WriteLine(value.ToString("C", enUS));

      Console.WriteLine();

      // Produce the result strings by calling a composite formatting method.
      foreach (var value in values)
         Console.WriteLine(String.Format(enUS, "{0:C}", value));      
   }
}
// The example displays the following output:
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32
//       
//       USD 1,065.23
//       USD 19.89
//       USD -0.03
//       USD -175,902.32

Viele Personalausweisnummer ausschließlich aus Ziffern bestehen und können daher einfach durch Ändern der Eigenschaften von formatiert werden ein NumberFormatInfo Objekt. Beispielsweise besteht eine Sozialversicherungsnummer in den Vereinigten Staaten von 9 Ziffern, die wie folgt angeordnet: XXX-XX-XXXX. Im folgende Beispiel wird davon ausgegangen, dass Sozialversicherungsnummern gespeichert werden, wie Werte für ganze Zahlen und diese entsprechend formatiert.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Instantiate a read-only NumberFormatInfo object.
      CultureInfo enUS = CultureInfo.CreateSpecificCulture("en-US");
      NumberFormatInfo nfi = enUS.NumberFormat;

      // Modify the relevant properties.
      nfi.NumberGroupSeparator = "-";
      nfi.NumberGroupSizes = new int[] { 3, 2, 4};
      nfi.NumberDecimalDigits = 0;

      int[] ids = { 111223333, 999776666 };

      // Produce the result string by calling ToString.
      foreach (var id in ids)
         Console.WriteLine(id.ToString("N", enUS));

      Console.WriteLine();

      // Produce the result string using composite formatting.
      foreach (var id in ids)
         Console.WriteLine(String.Format(enUS, "{0:N}", id));
   }
}
// The example displays the following output:
//       1112-23-333
//       9997-76-666
//       
//       1112-23-333
//       9997-76-666

Die Analyse betrifft die Darstellung einer Zahl in eine Zahl konvertieren. Jedes numerischen Typs in .NET Framework enthält zwei überladene Analysemethoden: Parse und TryParse. Die Parse -Methode konvertiert eine Zeichenfolge in eine Zahl und löst eine Ausnahme aus, wenn die Konvertierung fehlschlägt. Die TryParse Methode konvertiert eine Zeichenfolge in eine Zahl, die Zahl weist ein out Argument und gibt ein Boolean Wert, der angibt, ob die Konvertierung erfolgreich war.

Verwenden Sie die Analysemethoden implizit oder explizit eine NumberStyles Enumerationswert, um zu bestimmen, welche Style-Elemente (z. B. Gruppentrennzeichen, einem Dezimaltrennzeichen und ein Währungssymbol) in einer Zeichenfolge vorhanden sein können, wenn der Analysevorgang erfolgreich ausgeführt wird. Wenn ein NumberStyles Wert wird nicht verwendet werden, sofern im Aufruf Methode, der Standardwert ist eine NumberStyles -Wert, der umfasst die Float und AllowThousands Flags, die angibt, dass die analysierte Zeichenfolge kann Gruppe Symbole, Dezimaltrennzeichen, ein Minuszeichen und Leerzeichen enthalten, oder sie können die Darstellung einer Zahl in Exponentialschreibweise.

Verwenden Sie die Analysemethoden auch implizit oder explizit ein NumberFormatInfo -Objekt, das definiert, die bestimmte Symbole und Muster, die in der Zeichenfolge, die analysiert werden auftreten kann. Wenn ein NumberFormatInfo Objekt nicht angegeben wird, der Standardwert ist die NumberFormatInfo für die aktuelle Threadkultur. Weitere Informationen zu analysieren, finden Sie die einzelnen Analysemethoden, z. B. Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), und BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

Das folgende Beispiel veranschaulicht die Art der kulturabhängigen Zeichenfolgen. Analysiert eine Zeichenfolge, die Tausende versucht mit den Konventionen der invarianten Kulturen En-US, fr-FR und Trennzeichen. Eine Zeichenfolge mit Kommas als Gruppentrennzeichen und der Punkt als Dezimaltrennzeichen kann nicht analysiert werden in der Kultur "fr-FR", und eine Zeichenfolge mit White space als Gruppentrennzeichen und ein Komma als Dezimaltrennzeichen kann nicht in die invariante Kulturen und En-US analysiert.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] values = { "1,034,562.91", "9 532 978,07" };
      String[] cultureNames = { "en-US", "fr-FR", "" };

      foreach (var value in values) {
         foreach (var cultureName in cultureNames) {
            CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
            String name = culture.Name == "" ? "Invariant" : culture.Name;
            try {
               Decimal amount = Decimal.Parse(value, culture);
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name);
            }
            catch (FormatException) {
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name);
            }   
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '1,034,562.91' --> 1034562.91 (en-US)
//       '1,034,562.91': FormatException (fr-FR)
//       '1,034,562.91' --> 1034562.91 (Invariant)
//       
//       '9 532 978,07': FormatException (en-US)
//       '9 532 978,07' --> 9532978.07 (fr-FR)
//       '9 532 978,07': FormatException (Invariant)

Im Allgemeinen Analyse erfolgt in zwei Kontexten:

  • Als ein Vorgang, mit dem Benutzereingaben in einen numerischen Wert konvertieren.

  • Als ein Vorgang, der entworfen wurde für den Roundtrip einen numerischen Wert; d. h., einen numerischen Wert zu deserialisieren, der zuvor als Zeichenfolge serialisiert wurde.

Den folgenden Abschnitten werden diese beiden Vorgänge genauer an.

Wenn Sie numerische Zeichenfolgen, die vom Benutzer eingegebenen analysieren, sollte immer instanziiert ein NumberFormatInfo -Objekt, das kultureinstellungen des Benutzers entspricht. Informationen zum Instanziieren einer NumberFormatInfo -Objekt, das benutzeranpassungen, finden Sie unter der NumberFormatInfo und dynamic Data Abschnitt.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem Analysevorgang, der Benutzer kultureinstellungen wiedergibt und andere nicht. In diesem Fall die Standardkultur des Systems En-US ist, aber vom Benutzer definierten "," als Dezimaltrennzeichen und "." als das Gruppentrennzeichen in der Systemsteuerung Region und Sprache. Normalerweise werden diese Symbole in der Standard-En-US-Kultur rückgängig gemacht. Wenn der Benutzer gibt eine Zeichenfolge, die Benutzer-Einstellung entspricht, und die Zeichenfolge analysiert wird ein NumberFormatInfo -Objekt, das auch benutzereinstellungen (überschrieben), gibt der Analysevorgang ein richtiges Ergebnis zurückgibt. Jedoch, wenn die Zeichenfolge wird analysiert durch ein NumberFormatInfo -Objekt, das standard-En-US-kultureinstellungen, gibt es Fehler das Komma Symbol für Gruppentrennzeichen und ein falsches Ergebnis zurückgegeben.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      CultureInfo stdCulture = CultureInfo.GetCultureInfo("en-US");
      CultureInfo custCulture = CultureInfo.CreateSpecificCulture("en-US"); 

      String value = "310,16";
      try {
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           stdCulture.Name, stdCulture.UseUserOverride);
         Decimal amount = Decimal.Parse(value, stdCulture);
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));                                                                                        
      }
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'", value);
      }    
      Console.WriteLine();

      try {
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           custCulture.Name, custCulture.UseUserOverride);
         Decimal amount = Decimal.Parse(value, custCulture);
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture));                                                                                        
      }
      catch (FormatException) {
         Console.WriteLine("Unable to parse '{0}'", value);
      }   
   }
}
// The example displays the following output:
//       en-US culture reflects user overrides: False
//       '310,16' --> 31016
//       
//       en-US culture reflects user overrides: True
//       '310,16' --> 310.16

Wenn numerische Daten in einem Format serialisiert und später deserialisiert und analysiert, sollten die Zeichenfolgen generiert und mit den Konventionen der invarianten Kultur analysiert werden. Die Formatierung und Analyse Vorgänge sollten nie die Konventionen einer bestimmten Kultur widerspiegeln. Wenn kulturspezifische Einstellungen verwendet werden, ist die Portabilität von Daten beschränkt. Es kann nur auf einem Thread erfolgreich deserialisiert werden, dessen kulturspezifische Einstellungen mit denen des Threads identisch sind, auf denen er serialisiert wurde. In einigen Fällen werden bedeutet dies, die die Daten selbst können nicht deserialisiert, auf dem gleichen System auf dem er serialisiert wurde.

Im folgende Beispiel wird veranschaulicht, was passieren kann, wenn gegen dieses Prinzip verstoßen wird. Gleitkommawerte in einem Array werden in Zeichenfolgen konvertiert, wenn der aktuelle Thread die kulturspezifische Einstellungen der Kultur En-US verwendet. Die Daten werden von einem Thread, der die kulturspezifische Einstellungen der Kultur En-GB verwendet analysiert. In diesem Fall jedoch jede Analysevorgang erfolgreich ausgeführt wird, die Daten nicht Roundtrip erfolgreich und Beschädigung von Daten. In anderen Fällen kann ein Analysevorgang fehlschlagen und eine FormatException Ausnahme kann ausgelöst werden.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      PersistData();

      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB");
      RestoreData();
   }

   private static void PersistData()
   {
      // Define an array of floating-point values.
      Double[] values = { 160325.972, 8631.16, 1.304e5, 98017554.385, 
                          8.5938287084321676e94 };
      Console.WriteLine("Original values: ");
      foreach (var value in values) 
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture));

      // Serialize an array of doubles to a file 
      StreamWriter sw = new StreamWriter(@".\NumericData.bin");
      for (int ctr = 0; ctr < values.Length; ctr++) {
         sw.Write(values[ctr].ToString("R"));
         if (ctr < values.Length - 1) sw.Write("|");
      }
      sw.Close();
      Console.WriteLine();
   }

   private static void RestoreData()
   {   
      // Deserialize the data
      StreamReader sr = new StreamReader(@".\NumericData.bin");
      String data = sr.ReadToEnd();
      sr.Close();

      String[] stringValues = data.Split('|');
      List<Double> newValueList = new List<Double>();

      foreach (var stringValue in stringValues) {
         try {
            newValueList.Add(Double.Parse(stringValue));
         }
         catch (FormatException) {
            newValueList.Add(Double.NaN);
         }   
      }                                   

      Console.WriteLine("Restored values:");
      foreach (var newValue in newValueList) 
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo));
   }
}
// The example displays the following output:
//       Original values:
//       160325.972
//       8631.16
//       130400
//       98017554.385
//       8.5938287084321671E+94
//       
//       Restored values:
//       160325972
//       863116
//       130400
//       98017554385
//       8.5938287084321666E+110

Das folgende Beispiel zeigt das Abrufen einer NumberFormatInfo -Objekt für ein entsprechendes CultureInfo -Objekt und das abgerufene Objekt die Formatierungsinformationen für die jeweilige Kultur für Zahlen verwenden.

using System;
using System.Globalization;
using System.Text;

public sealed class App 
{
    static void Main() 
    {
        StringBuilder sb = new StringBuilder();

        // Loop through all the specific cultures known to the CLR.
        foreach (CultureInfo ci in CultureInfo.GetCultures(CultureTypes.SpecificCultures)) 
        {
            // Only show the currency symbols for cultures that speak English.
            if (ci.TwoLetterISOLanguageName != "en") continue;

            // Display the culture name and currency symbol.
            NumberFormatInfo nfi = ci.NumberFormat;
            sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                ci.DisplayName, nfi.CurrencySymbol);
            sb.AppendLine();
        }
        Console.WriteLine(sb.ToString());
    }
}

// This code produces the following output.
//
// The currency symbol for 'English (United States)' is '$'
// The currency symbol for 'English (United Kingdom)' is '�'
// The currency symbol for 'English (Australia)' is '$'
// The currency symbol for 'English (Canada)' is '$'
// The currency symbol for 'English (New Zealand)' is '$'
// The currency symbol for 'English (Ireland)' is '?'
// The currency symbol for 'English (South Africa)' is 'R'
// The currency symbol for 'English (Jamaica)' is 'J$'
// The currency symbol for 'English (Caribbean)' is '$'
// The currency symbol for 'English (Belize)' is 'BZ$'
// The currency symbol for 'English (Trinidad and Tobago)' is 'TT$'
// The currency symbol for 'English (Zimbabwe)' is 'Z$'
// The currency symbol for 'English (Republic of the Philippines)' is 'Php'

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: