(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
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

NumberFormatInfo-Klasse

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

System.Object
  System.Globalization.NumberFormatInfo

Namespace:  System.Globalization
Assembly:  mscorlib (in mscorlib.dll)
[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class NumberFormatInfo : ICloneable, 
	IFormatProvider

Der NumberFormatInfo-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-AppsNumberFormatInfo Initialisiert eine neue, schreibbare Instanz der NumberFormatInfo-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-AppsCurrencyDecimalDigits Ruft die Anzahl der in Währungswerten zu verwendenden Dezimalstellen ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrencyDecimalSeparator Ruft die in Währungsangaben als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrencyGroupSeparator Ruft die Zeichenfolge ab, mit der bei Währungsangaben Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrencyGroupSizes Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in Währungsangaben ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrencyNegativePattern Ruft das Formatmuster für negative Währungsangaben ab oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrencyPositivePattern Ruft das Formatmuster für positive Währungsangaben ab oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrencySymbol Ruft die als Währungssymbol zu verwendende Zeichenfolge ab oder legt diese fest.
Öffentliche EigenschaftStatischer MemberUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsCurrentInfo Ruft eine schreibgeschützte NumberFormatInfo ab, die Werte auf Grundlage der aktuellen Kultur formatiert.
Öffentliche EigenschaftDigitSubstitution Ruft einen Wert ab oder legt einen Wert fest, der angibt, in welcher Form die grafische Benutzeroberfläche Ziffern anzeigt.
Öffentliche EigenschaftStatischer MemberUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsInvariantInfo Ruft ein schreibgeschütztes NumberFormatInfo Objekt ab, das kulturunabhängig (invariant) ist.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsIsReadOnly Ruft einen Wert ab, der angibt, ob dieses NumberFormatInfo-Objekt schreibgeschützt ist.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNaNSymbol Ruft die Zeichenfolge ab, die den IEEE-NaN-Wert (Not a Number) darstellt, oder legt diese fest.
Öffentliche EigenschaftNativeDigits Ruft ein Zeichenfolgenarray mit systemeigenen Ziffern ab, die den europäischen Ziffern 0 (null) bis 9 entsprechen, oder legt ein entsprechendes Zeichenfolgenarray fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNegativeInfinitySymbol Ruft die Zeichenfolge ab, die minus unendlich darstellt, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNegativeSign Ruft die Zeichenfolge ab, die kennzeichnet, dass die zugeordnete Zahl negativ ist, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNumberDecimalDigits Ruft die Anzahl der in numerischen Werten zu verwendenden Dezimalstellen ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNumberDecimalSeparator Ruft die in numerischen Werten als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNumberGroupSeparator Ruft die Zeichenfolge ab, mit der bei numerischen Werten Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNumberGroupSizes Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in numerischen Werten ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsNumberNegativePattern Ruft das Formatmuster für negative numerische Werte ab oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentDecimalDigits Ruft die Anzahl der in Prozentwerten zu verwendenden Dezimalstellen ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentDecimalSeparator Ruft die in Prozentwerten als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentGroupSeparator Ruft die Zeichenfolge ab, mit der in Prozentwerten Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentGroupSizes Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in Prozentwerten ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentNegativePattern Ruft das Formatmuster für negative Prozentangaben ab oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentPositivePattern Ruft das Formatmuster für positive Prozentangaben ab oder legt dieses fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPercentSymbol Ruft die als Prozentsymbol zu verwendende Zeichenfolge ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPerMilleSymbol Ruft die als Promillesymbol zu verwendende Zeichenfolge ab oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPositiveInfinitySymbol Ruft die Zeichenfolge ab, die plus unendlich darstellt, oder legt diese fest.
Öffentliche EigenschaftUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsPositiveSign Ruft die Zeichenfolge ab, die kennzeichnet, dass die zugeordnete Zahl positiv ist, oder legt diese fest.
Zum Seitenanfang
  NameBeschreibung
Öffentliche MethodeUnterstützt von XNA FrameworkUnterstützt von  Portable KlassenbibliothekUnterstützt in .NET für Windows Store-AppsClone Erstellt eine flache Kopie des NumberFormatInfo-Objekts.
Ö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-AppsGetFormat Ruft ein Objekt vom angegebenen Typ ab, das einen Zahlenformatierungsdienst 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-AppsGetInstance Ruft den NumberFormatInfo ab, der dem angegebenen IFormatProvider 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-AppsReadOnly Gibt einen schreibgeschützten NumberFormatInfo-Wrapper zurück.
Ö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 NumberFormatInfo-Klasse enthält kulturbezogene Informationen, die verwendet wird, wenn Sie numerische Werte formatieren und analysieren. Diese Informationen umfassen das Währungssymbol, das Dezimaltrennzeichen einschließen Symbol, das Gruppentrennzeichen und Symbole für positive und negative Vorzeichen.

Instanziieren eines NumberFormatInfo-Objekts

Sie können ein NumberFormatInfo-Objekt instanziieren, das die Formatierungskonventionen der aktuellen Kultur, der invarianten Kultur, der bestimmten Kultur oder der neutralen Kultur darstellt.

Instanziieren eines NumberFormatInfo-Objekts für die aktuelle Kultur

Sie können ein NumberFormatInfo-Objekt für die aktuelle Threadkultur in folgenden Methoden instanziieren. In jedem Fall ist das zurückgegebene NumberFormatInfo-Objekt schreibgeschützt.

Im folgenden Beispiel werden diese drei Methoden, NumberFormatInfo-Objekte zu erstellen, die Formatierungskonventionen der aktuellen Kultur darstellen. Sie ruft auch den Wert der IsReadOnly-Eigenschaft ab, 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 ein NumberFormatInfo schreibbares Objekt erstellen, das die Konventionen der aktuellen Threadkultur in folgenden Methoden darstellt:

  • Durch das Abrufen eines NumberFormatInfo-Objekts in den Methoden veranschaulicht im obigen Codebeispiel und die Methode Clone für den zurückgegebenen NumberFormatInfo-Objekt. Dadurch wird eine Kopie des ursprünglichen Objekts NumberFormatInfo, 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.NumberFormat, um das Objekt dann ein NumberFormatInfo abzurufen.

Das folgende Beispiel veranschaulicht diese beiden Methoden des Instanziierens Objekts eines NumberFormatInfo und zeigt den Wert der IsReadOnly-Eigenschaft an, 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 dem Benutzer ermöglicht, um einige der NumberFormatInfo-Eigenschaftswerte zu überschreiben, die in numerischen Formatierungs- und Analysevorgängen durch das Element Region und Sprache in der Systemsteuerung verwendet werden. Beispielsweise ein Benutzer auswählen, dessen Kultur Englisch (USA Macht, ist, um als Währungswerte 1,1 USD anstelle von $1,1 anzuzeigen. Alle NumberFormatInfo-Objekte, die auf die Weise abgerufen wurden, zuvor erläuterten entsprechen diese benutzerdefinierte Überschreibungen. Wenn dieses unerwünscht ist, können Sie ein NumberFormatInfo-Objekt erstellen, das wieder benutzerdefinierte Überschreibungen (und auch nicht als schreibgeschützt Lese-/Schreibzugriffe unterstützt) nicht, indem sie den CultureInfo.CultureInfo(String, Boolean)-Konstruktor aufrufen und einen Wert von false für das useUserOverride-Argument angeben. Im folgenden Beispiel wird eine Abbildung für ein System bereit, dessen aktuelle Kultur Englisch (USA) und Währungssymbol aus dessen Standardwert zu $ USD 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 true festgelegt ist, werden auch die Eigenschaften CultureInfo.DateTimeFormat, CultureInfo.NumberFormat und CultureInfo.TextInfo aus den Benutzereinstellungen abgerufen. Wenn die Benutzereinstellungen mit der Kultur nicht kompatibel sind, die mit dem CultureInfo-Objekt zugeordnet wird (beispielsweise, wenn der Kalender ausgewählte keiner der Kalender ist, die durch die OptionalCalendars-Eigenschaft aufgeführt), um die Ergebnisse der Methoden und die Werte der Eigenschaften werden undefiniert.

Instanziieren eines NumberFormatInfo-Objekts für die invariante Kultur

Die invariante Kultur stellt eine Kultur dar, die kulturunabhängig ist. Sie basiert auf der englischen Sprache nicht jedoch 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. Ein NumberFormatInfo-Objekt, das die Formatierungskonventionen der invarianten Kultur darstellt, kann für Formatierungsvorgänge verwendet, in denen Ergebniszeichenfolgen nicht von Kultur zu Kultur unterscheiden sollen.

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

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

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

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

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


Instanziieren eines NumberFormatInfo-Objekts für eine bestimmte Kultur

Eine bestimmte 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 gesprochene wird. Sie können ein NumberFormatInfo-Objekt instanziieren, das die Formatierungskonventionen einer bestimmten Kultur folgendermaßen darstellt:

  • Durch Aufrufen der CultureInfo.GetCultureInfo(String)-Methode und das Abrufen des Werts der CultureInfoNumberFormat-Eigenschaft des zurückgegebenen Objekts. Das zurückgegebene NumberFormatInfo-Objekt ist schreibgeschützt.

  • Durch das Übergeben eines CultureInfo-Objekts, das die Kultur darstellt, deren NumberFormatInfo-Objekt Sie zu statische GetInstance-Methode abrufen möchten. Das zurückgegebene Objekt NumberFormatInfo ist eine Lese-/Schreibeigenschaft.

  • Durch Aufrufen der CultureInfo.CreateSpecificCulture-Methode und das Abrufen des Werts der CultureInfoNumberFormat-Eigenschaft des zurückgegebenen Objekts. Das zurückgegebene Objekt NumberFormatInfo ist eine Lese-/Schreibeigenschaft.

  • Durch Aufrufen einer der CultureInfo.CultureInfo-Klassenkonstruktoren und das Abrufen des Werts der CultureInfoNumberFormat-Eigenschaft des zurückgegebenen Objekts. Das zurückgegebene Objekt NumberFormatInfo ist eine Lese-/Schreibeigenschaft.

Im folgenden Beispiel wird diese vier Möglichkeiten, ein NumberFormatInfo-Objekt, das die Formatierungskonventionen der indonesischen (Indonesien-) Kultur widerspiegelt wird. Es gibt auch an, 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


Instanziieren eines NumberFormatInfo-Objekts für eine neutrale Kultur

Eine neutrale Kultur stellt eine Kultur oder Sprache dar, die unabhängig Land/eine Region ist. Es ist in der Regel 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 erstellen ein NumberFormatInfo-Objekt, das die Formatierungskonventionen einer neutralen Kultur wie darstellt, ein NumberFormatInfo-Objekt erstellen, das die Formatierungskonventionen einer bestimmten Kultur darstellt.

HinweisHinweis

In .NET Framework 3.5 und früheren Versionen ist, ein NumberFormatInfo-Objekt abzurufen, das die Formatierungskonventionen der auslöst Kultur einer neutralen NotSupportedException eine Ausnahme aus.

Da er unabhängig von bestimmten Land/Region ist, fehlt eine neutrale Kultur kulturspezifische Formatierungsinformationen. Anstatt, das NumberFormatInfo-Objekt mit generischen Werten herum ein Abstand, gibt .NET Framework ein NumberFormatInfo-Objekt zurück, das die Formatierungskonventionen einer bestimmten Kultur widergespiegelt, die ein untergeordnetes Element der neutralen Kultur ist. Beispielsweise gibt das NumberFormatInfo-Objekt für die neutrale en-Kultur die Formatierungskonventionen der Kultur en-US, und das NumberFormatInfo-Objekt für von der Kultur widerspiegelt die Formatierungskonventionen der Kultur fr-FR.

Sie können folgenden Code verwenden, um zu bestimmen, das die Formatierungskonventionen der bestimmten Kultur eine 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();
   }
}


NumberFormatInfo und dynamische Daten

Mit kulturspezifischen Daten zum Formatieren von numerischen Werten, die von der NumberFormatInfo-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 NumberFormatInfo-Objekte machen, die bestimmten CultureInfo-Objekten zugeordnet sind. Nur die Daten, die von der invarianten Kultur und von dem zugeordneten NumberFormatInfo-Objekt bereitgestellt werden, sind weiterhin. Weitere Daten können zwischen Anwendungssitzungen oder sogar innerhalb einer einzelnen Sitzung, für die folgenden Gründe ändern:

  • Systemupdates. Kulturelle Einstellungen wie die Währungssymbol- Währungsformate ändern oder im Zeitverlauf. Wenn dies geschieht, enthält Windows Update Änderungen am Eigenschaftswert NumberFormatInfo für eine bestimmte Kultur.

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

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

  • Benutzereinstellungen. Benutzer der Anwendung überschrieben möglicherweise einige der Werte, die der aktuellen Systemkultur durch die Bereichs- und Sprachoptionen in der Systemsteuerung zugeordnet werden. Beispielsweise können Benutzer ein anderes Währungssymbol oder ein anderes Dezimaltrennzeichensymbol aus. Wenn die Eigenschaft CultureInfo.UseUserOverride auf true (der Standardwert) festgelegt wird, werden die Eigenschaften des Objekts NumberFormatInfo auch von den Benutzereinstellungen abgerufen.

Ab .NET Framework 2.0, werden alle vom Benutzer schreibbaren Eigenschaften eines NumberFormatInfo-Objekts initialisiert, wenn das Objekt erstellt wird. Es gibt noch eine Möglichkeit der führt, da weder noch der Objekterstellung Benutzerüberschreibungsprozess atomar ist, und die entsprechenden Werte möglicherweise ändern während der Objekterstellung. Allerdings sollten diese Inkonsistenzen äußerst selten sein.

Sie können steuern, ob benutzerdefinierte Überschreibungen in NumberFormatInfo-Objekte auswirken, die dieselbe Kultur darstellen, die die aktuelle Threadkultur. Die folgende Tabelle enthält die Methoden, in denen ein NumberFormatInfo-Objekt abgerufen werden kann auf und gibt an, ob das Objekt benutzerdefinierte Überschreibungen wiedergegeben.

Quelle von CultureInfo-Objekt und NumberFormatInfo

Reflektiert benutzerdefinierte Überschreibungen

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 von useUserOverride ab Parameter

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

IFormatProvider, NumberFormatInfo und numerische Formatierung

Ein NumberFormatInfo-Objekt wird implizit oder explizit in alle numerischen Formatierungsvorgängen verwendet. Diese Einschließungsaufrufe zu den folgenden Methoden:

Alle numerischen Formatierungsvorgänge nutzen eine IFormatProvider Implementierung aus. Die IFormatProvider-Schnittstelle verfügt über eine einzige Methode, GetFormat(Type). Dies ist eine Rückrufmethode, der ein Type-Objekt übergeben wird, das den Typ darstellt, der benötigt wird, um Formatierungsinformationen bereitzustellen. Die Methode ist für die Rückgabe entweder eine Instanz dieses Typs oder des null zuständig, wenn eine Instanz des Typs nicht bereitstellen kann. . .NET Framework stellt zwei IFormatProvider - Implementierungen für das Formatieren von Zahlen bereit:

  • Die CultureInfo-Klasse, die eine bestimmte Kultur darstellt (oder eine bestimmte Sprache in einer bestimmten Land/Region). In einem numerischen Formatierungsvorgang gibt die CultureInfo.GetFormat-Methode NumberFormatInfo dem Objekt zurück, das mit der CultureInfo.NumberFormat-Eigenschaft zugeordnet ist.

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

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

Im folgenden Beispiel wird die Beziehung zwischen der Schnittstelle und IFormatProvider der NumberFormatInfo-Klasse bei Formatierungsvorgängen, indem eine benutzerdefinierte IFormatProvider Implementierung definiert. Die GetFormat-Methode zeigt den Typnamen des Objekts an, das durch den Formatierungsvorgang angefordert wird. Wenn die Schnittstelle ein NumberFormatInfo-Objekt anfordert, erstellt diese Methode das NumberFormatInfo-Objekt für die aktuelle Threadkultur bereit. Die Ausgabe im Beispiel zeigt, wird die Decimal.ToString(IFormatProvider)-Methode um ein NumberFormatInfo-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()
   {
      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 eine IFormatProvider Implementierung nicht explizit in einem numerischen Formatierungsmethodenaufruf bereitgestellt wird, ruft die Methode die CultureInfo.CurrentCulture.GetFormat-Methode, die das NumberFormatInfo-Objekt zurückgibt, das der aktuellen Threadkultur entspricht.

Formatzeichenfolgen- und NumberFormatInfo-Eigenschaften

Jeder Formatierungsvorgang verwendet entweder eine standardmäßige oder benutzerdefinierte numerische Formatzeichenfolge, um eine Ergebniszeichenfolge von einer Nummer zu erzeugen. In einigen Fällen ist die Verwendung aus einer Formatzeichenfolge, eine Ergebniszeichenfolge erzeugt, wie im folgenden Beispiel explizit. Dieser Code ruft die Decimal.ToString(IFormatProvider)-Methode auf, um einen Decimal-Wert zu verschiedenen Zeichenfolgendarstellungen zu konvertieren, indem die Formatierungskonventionen der Kultur en-US verwendet.


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 aus einer Formatzeichenfolge implizit. In den folgenden Methodenaufrufe zum Standard oder parameterlosen Decimal.ToString()-Methode, wird der Wert der Decimal formatierten Instanz, den allgemeinen Formatbezeichner "G" und Konventionen der aktuellen Kultur verwendet, die in diesem Fall die Kultur 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 numerische Standardformatzeichenfolge verwendet eine oder mehrere NumberFormatInfo-Eigenschaften, um das Muster oder die Symbole zu bestimmen, die in der Ergebniszeichenfolge verwendet werden. Entsprechend Zeichenfolgenformatierung jede benutzerdefinierte numerische Formatbezeichner außer "0 " und "#" Einfügungssymbole im Ergebnis auf, die von NumberFormatInfo-Eigenschaften definiert werden. Die folgende Tabelle zeigt den standardmäßigen und die benutzerdefinierten Zahlenformatbezeichner und zugehörigen Eigenschaften NumberFormatInfo auf. Um die Darstellung der Ergebniszeichenfolge für eine bestimmte Kultur zu ändern, finden Sie im Abschnitt Ändern von NumberFormatInfo-Eigenschaften. Ausführliche Informationen zu diesen Formatbezeichnern finden Sie unter Standardmäßige Zahlenformatzeichenfolgen und Benutzerdefinierte Zahlenformatzeichenfolgen.

Formatbezeichner

Zugeordnete Eigenschaften

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

CurrencyDecimalDigits , die Standardanzahl von Dezimalstellen definieren.

CurrencyDecimalSeparator , das Dezimaltrennzeichen definieren.

CurrencyGroupSeparator , die Gruppe oder des Tausendertrennzeichens definieren.

CurrencyGroupSizes , die Größen von ganzzahligen Gruppen definieren.

CurrencyNegativePattern , das Muster von negativen Währungswerten definieren.

CurrencyPositivePattern , das Muster von positiven Währungswerten definieren.

CurrencySymbol , das Währungssymbol definieren.

NegativeSign , das Minuszeichen definieren.

"D" oder "d") (Dezimalformatbezeichner

NegativeSign , das Minuszeichen definieren.

"E" oder "e" oder wissenschaftlicher (exponentieller Formatbezeichner)

NegativeSign , das in der Mantisse Minuszeichen und im Exponenten definieren.

NumberDecimalSeparator , das Dezimaltrennzeichen definieren.

PositiveSign , das Pluszeichen im Exponenten definieren.

"F" oder "f (Festkommaformatbezeichner")

NegativeSign , das Minuszeichen definieren.

NumberDecimalDigits , die Standardanzahl von Dezimalstellen definieren.

NumberDecimalSeparator , das Dezimaltrennzeichen definieren.

"G" oder "g" allgemeiner Formatbezeichner()

NegativeSign , das Minuszeichen definieren.

NumberDecimalSeparator , das Dezimaltrennzeichen definieren.

PositiveSign , das Pluszeichen für Ergebniszeichenfolgen im exponentiellen Format an.

"N" oder "n") (Zahlenformatbezeichner

NegativeSign , das Minuszeichen definieren.

NumberDecimalDigits , die Standardanzahl von Dezimalstellen definieren.

NumberDecimalSeparator , das Dezimaltrennzeichen definieren.

NumberGroupSeparator , das Symbol des Gruppentrennzeichens (Tausendergruppen) definieren.

NumberGroupSizes , die Anzahl von ganzzahligen Ziffern einer Gruppe definieren.

NumberNegativePattern , das Format von negativen Werten definieren.

"P" oder "p" (Prozentformatbezeichner)

NegativeSign , das Minuszeichen definieren.

PercentDecimalDigits , die Standardanzahl von Dezimalstellen definieren.

PercentDecimalSeparator , das Dezimaltrennzeichen definieren.

PercentGroupSeparator , das Gruppentrennzeichen definiert.

PercentGroupSizes , die Anzahl von ganzzahligen Ziffern einer Gruppe definieren.

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

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

PercentSymbol , das Prozentsymbol definieren.

"R" oder "r") (Schleifenformatbezeichner

NegativeSign , das Minuszeichen definieren.

NumberDecimalSeparator , das Dezimaltrennzeichen definieren.

PositiveSign , das Pluszeichen in einem Exponenten definieren.

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

Keine.

"." (Dezimaltrennzeichenbenutzerdefinierter formatbezeichner)

NumberDecimalSeparator , das Dezimaltrennzeichen definieren.

"," Gruppentrennzeichenbenutzerdefinierter (formatbezeichner)

NumberGroupSeparator , das Trennzeichensymbol (.vbg Tausendergruppen) definieren.

"%" (Prozentsatzplatzhalterbenutzerdefinierter formatbezeichner)

PercentSymbol , das Prozentsymbol definieren.

"‰" (pro mille Platzhalterbenutzerdefinierter formatbezeichner)

PerMilleSymbol , das Promillesymbol definieren.

"E" (Exponentialschreibweisenbenutzerdefinierter formatbezeichner)

NegativeSign , das in der Mantisse Minuszeichen und im Exponenten definieren.

PositiveSign , das Pluszeichen im Exponenten definieren.

Beachten Sie, dass NumberFormatInfo die Klasse eine NativeDigits-Eigenschaft enthält, die Ziffern mit Basis 10 angibt, die von einer bestimmten Kultur verwendet werden. Allerdings wird die Eigenschaft nicht bei Formatierungsvorgängen verwendet; nur die Ziffern 0 (U+0030) des Grundalphabets lateinischen durch 9 (U+0039) werden in der Ergebniszeichenfolge verwendet. Außerdem für Single und Double-Werte von NaN, PositiveInfinity und NegativeInfinity, besteht die Ergebniszeichenfolge ausschließlich aus den Symbolen, die von NaNSymbol, PositiveInfinitySymbol und NegativeInfinitySymbol bzw. Eigenschaften, definiert werden.

Ändern von NumberFormatInfo-Eigenschaften

Sie können die Eigenschaften eines NumberFormatInfo-Objekts ändern, um die Ergebniszeichenfolge anpassen, die in einem numerischen Formatierungsvorgang erstellte. Gehen Sie dazu wie folgt vor:

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

  2. Ändern Sie die Eigenschaft oder die Eigenschaften, die verwendet werden, um die Zeichenfolge des gewünschte Ergebnis zu erzeugen. Informationen darüber, wie NumberFormatInfo, Methodenverwendungs- Eigenschaften Formatieren Ergebniszeichenfolgen, um zu definieren, finden Sie den Abschnitt Formatzeichenfolgen- und NumberFormatInfo-Eigenschaften.

  3. Verwenden Sie das benutzerdefinierte NumberFormatInfo-Objekt IFormatProvider als das Argument in Aufrufen in Formatierung von Methoden.

HinweisHinweis

Anstatt, die Eigenschaftswerte einer Kultur dynamisch ändern, wenn eine Anwendung gestartet wird, können Sie 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 mithilfe (eine, die anstelle einer bestimmten Kultur verwendet wird) zu definieren.

Die folgenden Abschnitte enthalten einige Beispiele.

2xdwt6xx.collapse_all(de-de,VS.110).gifÄndern des Währungssymbols und des Musters

Im folgenden Beispiel wird ein NumberFormatInfo-Objekt, dem das die Formatierungskonventionen der Kultur darstellt. Es weist das Währungssymbol ISO-4217 der Eigenschaft CurrencySymbol zu und definiert ein Muster für Währungswerte, das aus dem Währungssymbol besteht, das aus einem Leerzeichen und einem numerischen Wert gefolgt.


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


2xdwt6xx.collapse_all(de-de,VS.110).gifFormatieren einer nationalen ID

Viele nationalen IDs bestehen ausschließlich aus Ziffern und damit leicht formatiert werden, indem die Eigenschaften eines NumberFormatInfo-Objekts ändern. Beispielsweise besteht eine Sozialunterstützungsnummer in den USA aus 9 Ziffern, die wie folgt positioniert werden: XXX-XX-XXXX. Im folgenden Beispiel wird angenommen, dass Sozialversicherungsnummern als ganzzahlige Werte gespeichert werden, und formatiert sie entsprechend.


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


Analyseziffernfolgen

Zur Analyse gehört das Konvertieren der Zeichenfolgendarstellung einer Zahl in eine Zahl. Jeder numerische Typ 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, wird die Zahl einem Argument out zu und gibt einen Boolean-Wert zurück, der angibt, dass die Konvertierung erfolgreich.

Die Analysemethoden verwenden implizit oder explizit einen NumberStyles-Enumerationswert, um zu bestimmen, welche Formatelemente (z, Gruppentrennzeichen ein Dezimaltrennzeichen oder ein Währungssymbol) in einer Zeichenfolge vorhanden sein kann, wenn der Analysevorgang zu folgen. Wenn ein Wert NumberStyles nicht im Methodenaufruf bereitgestellt wird, der Standard NumberStyles ist ein Wert, der Float enthält und das AllowThousands-Flag, das angibt, dass die Zeichenfolge die analysierte Gruppensymbole, Dezimaltrennzeichen enthalten kann, ein negatives Vorzeichen, und Leerzeichen, oder er kann die Zeichenfolgendarstellung einer Zahl in der Exponentialschreibweise sein.

Die Analysemethoden auch implizit oder explizit verwenden ein NumberFormatInfo-Objekt, das die einzelnen Symbole und Muster definiert, die in der zu analysierende Zeichenfolge erfolgen können. Wenn ein NumberFormatInfo-Objekt nicht bereitgestellt wird, ist der standardmäßige NumberFormatInfo für die aktuelle Threadkultur. Weitere Informationen zum Analysieren, finden Sie die einzelnen Analysemethoden, wie 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 kulturabhängige Weise von die Übertragung von Zeichenfolgen. Es wird versucht, eine Zeichenfolge zu analysieren, das Tausendertrennzeichen einschließen, indem die Konventionen en-US, des fr-FRs und der invarianten Kulturen verwendet. Eine Zeichenfolge, die das Komma als Gruppentrennzeichen und der Punkt enthält, während ein Dezimaltrennzeichen in der Kultur fr-FR nicht analysieren kann und eine Zeichenfolge mit Leerzeichen als Gruppentrennzeichen und ein Dezimaltrennzeichen Komma, wie in " und die invariante Kulturen nicht analysieren kann.


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)


Das Analysieren tritt im Allgemeinen in zwei Kontexten auf:

  • Ein Operation, die entworfen wird, um Benutzereingaben in einen numerischen Wert zu konvertieren.

  • Ein Operation, die entworfen wird, um eines numerischen Werts einen Roundtrip zu übergeben; das heißt, einen numerischen Wert deserialisieren, der zuvor als Zeichenfolge serialisiert wurde.

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

2xdwt6xx.collapse_all(de-de,VS.110).gifAnalysebenutzerzeichenfolgen

Wenn Sie die numerischen Zeichenfolgen analysieren, die vom Benutzer eingegeben werden, sollte ein NumberFormatInfo-Objekt instanziieren, das immer die Kultureinstellungen des Benutzers übernommen. Informationen, wie Sie NumberFormatInfo-Objekts, die Benutzeranpassungen widergespiegelt, den Abschnitt NumberFormatInfo und dynamische Daten finden instanziiert.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem Analysevorgang, der Benutzerkultureinstellungen wiedergegeben und einen, der nicht vorhanden ist. In diesem Fall ist die Standardsystemkultur en-US, der Benutzer ist definiert "," als das Dezimaltrennzeichen einschließen Symbol und "." Gruppentrennzeichen als das in der Systemsteuerung, Region und Sprache. Normalerweise werden diese Symbole in die Standarden-us-Kultur umgekehrt. Wenn der Benutzer eine Zeichenfolge, die Benutzer und die Zeichenfolge widergespiegelt, analysiert wird durch ein NumberFormatInfo-Objekt eingibt, das auch (Benutzereinstellungen Überschreibungen) wiedergibt, gibt der Analysevorgang ein richtiges Ergebnis zurück. Wenn die Zeichenfolge durch ein NumberFormatInfo-Objekt analysiert wird, das Standard-en-US-Kultureinstellungen widergespiegelt, verwechselt er das Kommasymbol für ein Gruppentrennzeichen und gibt einem falschen Ergebnis zurück.


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


2xdwt6xx.collapse_all(de-de,VS.110).gifNumerische Daten serialisieren und Deserialisieren

Wenn numerische Daten im Zeichenfolgenformat serialisiert und deserialisiert höher und analysiert, sollten die Zeichenfolgen generiert und analysiert werden, indem die Konventionen der invarianten Kultur verwendet. Die Formatierungs- und Analyseoperationen sollten die Konventionen einer bestimmten Kultur nicht entsprechen. Wenn kulturabhängige Einstellungen verwendet werden, wird die Portabilität der ausschließlich Daten beschränkt; Sie kann nur in einem Thread erfolgreich deserialisiert werden, dessen kulturspezifische Einstellungen zu 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 deserialisiert werden können, auf dem er serialisiert wurde.

Im folgenden Beispiel wird dargestellt, was geschehen kann, wenn dieses Prinzip verstoßen wird. In einem Array werden in Zeichenfolgen konvertiert, wenn der aktuelle Thread die kulturspezifischen Einstellungen der Kultur en-US verwendet. Die Daten werden dann von einem Thread analysiert, der die kulturspezifischen Einstellungen der en-GB-Kultur verwendet. In diesem Fall jedoch jeder Analysevorgang erfolgreich, werden die Daten nicht erfolgreich einen Roundtrip und Datenbeschädigungen tritt auf. In anderen Fällen kann ein Analysevorgang fehlschlägt 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


Im folgenden Beispiel wird gezeigt, wie ein NumberFormatInfo-Objekt für ein entsprechendes CultureInfo-Objekt abgerufen wird und wie mit dem abgerufenen Objekt die Formatierungsinformationen für Zahlen für die jeweilige Kultur abgerufen werden.


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'


.NET Framework

Unterstützt in: 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

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)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. 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.
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.