NumberFormatInfo NumberFormatInfo NumberFormatInfo NumberFormatInfo Class

Definition

Stellt kulturspezifische Informationen für Formatierung und Analyse für numerische Werte bereitstellt.Provides culture-specific information for formatting and parsing numeric values.

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

Beispiele

Im folgenden Beispiel wird gezeigt, wie ein NumberFormatInfo -Objekt für ein CultureInfo entsprechendes-Objekt abgerufen wird und wie das abgerufene Objekt verwendet wird, um Zahlen Formatierungsinformationen für die jeweilige Kultur abzufragen.The following example shows how to retrieve a NumberFormatInfo object for a corresponding CultureInfo object, and use the retrieved object to query number formatting information for the particular culture.

using namespace System;
using namespace System::Globalization;
using namespace System::Text;

int main()
{
    StringBuilder^ builder = gcnew StringBuilder();

    // Loop through all the specific cultures known to the CLR.
    for each(CultureInfo^ culture in 
        CultureInfo::GetCultures (CultureTypes::SpecificCultures)) 
    {
        // Only show the currency symbols for cultures 
        // that speak English.
        if (culture->TwoLetterISOLanguageName == "en")
        {
            // Display the culture name and currency symbol.
            NumberFormatInfo^ numberFormat = culture->NumberFormat;
            builder->AppendFormat("The currency symbol for '{0}'"+
                "is '{1}'",culture->DisplayName,
                numberFormat->CurrencySymbol);
            builder->AppendLine();
        }
    }
    Console::WriteLine(builder);
}

// 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'
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'
Imports System.Globalization
Imports System.Text

Public Module Example
   Public Sub Main() 
      Dim sb As New StringBuilder()

      ' Loop through all the specific cultures known to the CLR.
      For Each ci In CultureInfo.GetCultures(CultureTypes.SpecificCultures) 
         ' Only show the currency symbols for cultures that speak English.
         If ci.TwoLetterISOLanguageName <> "en" Then Continue For

         ' Display the culture name and currency symbol.
         Dim nfi As NumberFormatInfo = ci.NumberFormat
         sb.AppendFormat("The currency symbol for '{0}' is '{1}'",
                         ci.DisplayName, nfi.CurrencySymbol)
         sb.AppendLine()
      Next
      Console.WriteLine(sb.ToString())
   End Sub
End Module
' The example displays output like the following:
'       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'
'       The currency symbol for 'English (India)' is 'Rs.'
'       The currency symbol for 'English (Malaysia)' is 'RM'
'       The currency symbol for 'English (Singapore)' is '$'

Hinweise

Die NumberFormatInfo -Klasse enthält kulturspezifische Informationen, die beim Formatieren und analysieren numerischer Werte verwendet werden.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Zu diesen Informationen gehören das Währungssymbol, das Dezimal Symbol, das Gruppen Trennzeichen und die Symbole für positive und negative Vorzeichen.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Instanziieren eines numformatinfo-ObjektsInstantiating a NumberFormatInfo object

Sie können ein NumberFormatInfo -Objekt instanziieren, das die Formatierungs Konventionen der aktuellen Kultur, der invarianten Kultur, einer bestimmten Kultur oder einer neutralen Kultur darstellt.You can instantiate a NumberFormatInfo object that represents the formatting conventions of the current culture, the invariant culture, a specific culture, or a neutral culture.

Instanziieren eines "numformatinfo"-Objekts für die aktuelle KulturInstantiating a NumberFormatInfo object for the current culture

Sie können ein NumberFormatInfo -Objekt für die aktuelle Thread Kultur auf eine der folgenden Arten instanziieren.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. In jedem Fall ist das zurück NumberFormatInfo gegebene Objekt schreibgeschützt.In each case, the returned NumberFormatInfo object is read-only.

Im folgenden Beispiel werden diese drei Methoden verwendet, NumberFormatInfo um-Objekte zu erstellen, die die Formatierungs Konventionen der aktuellen Kultur darstellen.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Er ruft auch den Wert IsReadOnly der-Eigenschaft ab, um zu veranschaulichen, dass jedes-Objekt schreibgeschützt ist.It also retrieves the value of the IsReadOnly property to illustrate that each object is read-only.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = CultureInfo.CurrentCulture.NumberFormat
      Console.WriteLine(current1.IsReadOnly)
      
      Dim current2 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      Console.WriteLine(current2.IsReadOnly)
      
      Dim current3 As NumberFormatInfo = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture)
      Console.WriteLine(current3.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       True

Sie können ein beschreibbares NumberFormatInfo Objekt, das die Konventionen der aktuellen Thread Kultur darstellt, mit einer der folgenden Methoden erstellen:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

Das folgende Beispiel veranschaulicht diese beiden Methoden zum Instanziieren eines NumberFormatInfo -Objekts und zeigt den Wert seiner IsReadOnly -Eigenschaft an, um zu veranschaulichen, dass das Objekt nicht schreibgeschützt ist.The following example illustrates these two ways of instantiating a NumberFormatInfo object, and displays the value of its IsReadOnly property to illustrate that the object is not read-only.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim current1 As NumberFormatInfo = NumberFormatInfo.CurrentInfo
      current1 = CType(current1.Clone(), NumberFormatInfo)
      Console.WriteLine(current1.IsReadOnly)

      Dim culture2 As CultureInfo = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name)
      Dim current2 As NumberFormatInfo = culture2.NumberFormat
      Console.WriteLine(current2.IsReadOnly)
   End Sub
End Module
' The example displays the following output:
'       False
'       False

Beachten Sie, dass der Benutzer mithilfe des Windows-Betriebssystems einige NumberFormatInfo der Eigenschaftswerte, die in numerischen Formatierungs-und Verarbeitungsvorgängen verwendet werden, über das Regions-und sprach Element in der Systemsteuerung überschreiben kannNote that the Windows operating system allows the user to override some of the NumberFormatInfo property values used in numeric formatting and parsing operations through the Region and Language item in Control Panel. Beispielsweise kann ein Benutzer, dessen Kultur Englisch (USA) ist, die Währungswerte als 1,1 USD anstelle des Standardwerts $1,1 anzeigen.For example, a user whose culture is English (United States) might choose to display currency values as 1.1 USD instead of the default of $1.1. Die NumberFormatInfo Objekte, die in den zuvor erläuterten Methoden abgerufen wurden, spiegeln diese Benutzer Überschreibungen wider.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Wenn dies nicht erwünscht ist, können Sie ein NumberFormatInfo false -Objekt erstellen, das keine Benutzer Überschreibungen widerspiegelt (und auch Lese-/Schreibzugriff und nicht schreibgeschützt ist CultureInfo.CultureInfo(String, Boolean) ), indem Sie den-Konstruktor aufrufen useUserOverride und den Wert für das gestritten.If this is undesirable, you can create a NumberFormatInfo object that does not reflect user overrides (and that is also read/write rather than read-only) by calling the CultureInfo.CultureInfo(String, Boolean) constructor and supplying a value of false for the useUserOverride argument. Das folgende Beispiel enthält eine Abbildung für ein System, dessen aktuelle Kultur Englisch (USA) und dessen Währungssymbol von der Standardeinstellung $ in USD geändert wurde.The following example provides an illustration for a system whose current culture is English (United States) and whose currency symbol has been changed from the default of $ to USD.

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: $
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      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}", culture.NumberFormat.CurrencySymbol)
      Console.WriteLine()
            
      culture = New CultureInfo(CultureInfo.CurrentCulture.Name, False)
      Console.WriteLine("Culture Name:    {0}", culture.Name)
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride)
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol)
   End Sub
End Module
' 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 truefestgelegt ist, CultureInfo.DateTimeFormatwerden auch die CultureInfo.TextInfo Eigenschaften, CultureInfo.NumberFormatund aus den Benutzereinstellungen abgerufen.If the CultureInfo.UseUserOverride property is set to true, the properties CultureInfo.DateTimeFormat, CultureInfo.NumberFormat, and CultureInfo.TextInfo are also retrieved from the user settings. Wenn die Benutzereinstellungen mit der Kultur, die dem CultureInfo Objekt zugeordnet ist, nicht kompatibel sind (wenn der ausgewählte Kalender z. b. keiner der von der OptionalCalendars -Eigenschaft aufgelisteten Kalender ist), werden die Ergebnisse der Methoden und die Werte der Eigenschaften definiert.If the user settings are incompatible with the culture associated with the CultureInfo object (for example, if the selected calendar is not one of the calendars listed by the OptionalCalendars property), the results of the methods and the values of the properties are undefined.

Instanziieren eines numformatinfo-Objekts für die invariante KulturInstantiating a NumberFormatInfo object for the invariant culture

Die invariante Kultur stellt eine Kultur dar, die Kultur unabhängig ist.The invariant culture represents a culture that is culture-insensitive. Es basiert auf der englischen Sprache, aber nicht auf einem bestimmten englischsprachigen Land/einer bestimmten Region.It is based on the English language but not on any specific English-speaking country/region. Obwohl die Daten bestimmter Kulturen dynamisch sein können und sich ändern können, um neue Kultur Konventionen oder Benutzereinstellungen widerzuspiegeln, ändern sich die Daten der invarianten Kultur nicht.Although the data of specific cultures can be dynamic and can change to reflect new cultural conventions or user preferences, the data of the invariant culture does not change. Ein NumberFormatInfo -Objekt, das die Formatierungs Konventionen der invarianten Kultur darstellt, kann für Formatierungs Vorgänge verwendet werden, bei denen Ergebnis Zeichenfolgen nicht je nach Kultur variieren sollten.A NumberFormatInfo object that represents the formatting conventions of the invariant culture can be used for formatting operations in which result strings should not vary by culture.

Sie können ein NumberFormatInfo -Objekt, das die Formatierungs Konventionen der invarianten Kultur darstellt, auf folgende Weise instanziieren:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Im folgenden Beispiel wird jede dieser Methoden verwendet, um ein NumberFormatInfo -Objekt zu instanziieren, das die invariante Kultur darstellt.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Dann gibt es an, ob das Objekt schreibgeschützt ist.It then indicates whether the object is read-only,

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nfi As NumberFormatInfo
      
      nfi = System.Globalization.NumberFormatInfo.InvariantInfo
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = CultureInfo.InvariantCulture.NumberFormat
      Console.WriteLine(nfi.IsReadOnly)               
      
      nfi = New NumberFormatInfo()
      Console.WriteLine(nfi.IsReadOnly)               
   End Sub
End Module
' The example displays the following output:
'       True
'       True
'       False

Instanziieren eines numformatinfo-Objekts für eine bestimmte KulturInstantiating a NumberFormatInfo object for a specific culture

Eine bestimmte Kultur stellt eine Sprache dar, die in einem bestimmten Land oder einer bestimmten Region gesprochen wird.A specific culture represents a language that is spoken in a particular country/region. Beispielsweise ist "en-US" eine bestimmte Kultur, die die in der USA gesprochene Englische Sprache darstellt, und "en-ca" ist eine bestimmte Kultur, die die in Kanada gesprochene Englische Sprache darstellt.For example, en-US is a specific culture that represents the English language spoken in the United States, and en-CA is a specific culture that represents the English language spoken in Canada. Sie können ein NumberFormatInfo -Objekt, das die Formatierungs Konventionen einer bestimmten Kultur darstellt, auf folgende Weise instanziieren:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Im folgenden Beispiel werden diese vier Methoden zum Erstellen eines NumberFormatInfo -Objekts verwendet, das die Formatierungs Konventionen der indonesischen Kultur (Indonesien) wieder gibt.The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Außerdem wird angegeben, ob jedes Objekt schreibgeschützt ist.It also indicates whether each object is read-only.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim culture As CultureInfo
      Dim nfi As NumberFormatInfo
      
      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)
   End Sub
End Module
' The example displays the following output:
'       Read-only: True
'       Read-only: False
'       Read-only: False
'       Read-only: False

Instanziieren eines numformatinfo-Objekts für eine neutrale KulturInstantiating a NumberFormatInfo object for a neutral culture

Eine neutrale Kultur stellt eine Kultur oder Sprache dar, die unabhängig von einem Land bzw. einer Region ist.A neutral culture represents a culture or language that is independent of a country/region. Es ist in der Regel das übergeordnete Element einer oder mehrerer spezifischer Kulturen.It is typically the parent of one or more specific cultures. Beispielsweise ist fr eine neutrale Kultur für die französische Sprache und das übergeordnete Element der fr-FR-Kultur.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Sie erstellen ein NumberFormatInfo -Objekt, das die Formatierungs Konventionen einer neutralen Kultur darstellt, auf dieselbe Weise, wie NumberFormatInfo Sie ein-Objekt erstellen, das die Formatierungs Konventionen einer bestimmten Kultur darstellt.You create a NumberFormatInfo object that represents the formatting conventions of a neutral culture in the same way that you create a NumberFormatInfo object that represents the formatting conventions of a specific culture.

Hinweis

In und früheren Versionen löst der Versuch, ein NumberFormatInfo -Objekt abzurufen, das die Formatierungs Konventionen einer neutralen Kultur wider NotSupportedException spiegelt, eine-Ausnahme aus. .NET Framework 3,5.NET Framework 3.5In the .NET Framework 3,5.NET Framework 3.5 and earlier versions, trying to retrieve a NumberFormatInfo object that reflects the formatting conventions of a neutral culture throws a NotSupportedException exception.

Da es jedoch unabhängig von einem bestimmten Land oder einer bestimmten Region ist, fehlen bei einer neutralen Kultur kulturspezifische Formatierungsinformationen.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. Anstatt das NumberFormatInfo Objekt mit generischen Werten zu füllen, gibt die .NET Framework ein NumberFormatInfo -Objekt zurück, das die Formatierungs Konventionen einer bestimmten Kultur widerspiegelt, die ein untergeordnetes Element der neutralen Kultur ist.Rather than populating the NumberFormatInfo object with generic values, the .NET Framework returns a NumberFormatInfo object that reflects the formatting conventions of a specific culture that is a child of the neutral culture. Beispielsweise reflektiert das NumberFormatInfo -Objekt für die neutrale Kultur "en-US" die Formatierungs Konventionen der Kultur "en NumberFormatInfo -US", und das-Objekt für die FR-Kultur reflektiert die Formatierungs Konventionen der Kultur "fr-FR".For example, the NumberFormatInfo object for the neutral en culture reflects the formatting conventions of the en-US culture, and the NumberFormatInfo object for the fr culture reflects the formatting conventions of the fr-FR culture.

Sie können Code wie den folgenden verwenden, um zu bestimmen, welche Formatierungs Konventionen der jeweiligen Kultur jede neutrale Kultur darstellt.You can use code like the following to determine which specific culture's formatting conventions each neutral culture represents.

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();
   }
}
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Imports System.Reflection

Module Example
   Public Sub Main()
      ' Get all the neutral cultures
      Dim names As New List(Of String)
      Array.ForEach(CultureInfo.GetCultures(CultureTypes.NeutralCultures),
                    Sub(culture) names.Add(culture.Name))
      names.Sort()
      For Each name In names
         ' Ignore the invariant culture.
         If name = "" Then Continue For
         
         ListSimilarChildCultures(name)        
      Next
   End Sub

   Private Sub ListSimilarChildCultures(name As String)
      ' Create the neutral NumberFormatInfo object.
      Dim nfi As NumberFormatInfo = CultureInfo.GetCultureInfo(name).NumberFormat
      ' Retrieve all specific cultures of the neutral culture.
      Dim cultures() As CultureInfo = Array.FindAll(CultureInfo.GetCultures(CultureTypes.SpecificCultures), 
                               Function(culture) culture.Name.StartsWith(name + "-", StringComparison.OrdinalIgnoreCase))
      ' Create an array of NumberFormatInfo properties
      Dim properties() As PropertyInfo = GetType(NumberFormatInfo).GetProperties(BindingFlags.Instance Or BindingFlags.Public)
      Dim hasOneMatch As Boolean = False

      For Each ci In cultures
         Dim match As Boolean = True     
         ' Get the NumberFormatInfo for a specific culture.
         Dim specificNfi As NumberFormatInfo = ci.NumberFormat
         ' Compare the property values of the two.
         For Each prop In properties
            ' We're not interested in the value of IsReadOnly.     
            If prop.Name = "IsReadOnly" Then Continue For
            
            ' For arrays, iterate the individual elements to see if they are the same.
            If prop.PropertyType.IsArray Then 
               Dim nList As IList = CType(prop.GetValue(nfi, Nothing), IList)
               Dim sList As IList = CType(prop.GetValue(specificNfi, Nothing), IList)
               If nList.Count <> sList.Count Then
                  match = false
                  Exit For
               End If 

               For ctr As Integer = 0 To nList.Count - 1
                  If Not nList(ctr).Equals(sList(ctr)) 
                     match = false
                     Exit For
                  End If     
               Next
            Else If Not prop.GetValue(specificNfi).Equals(prop.GetValue(nfi))
               match = false
               Exit For   
            End If        
         Next
         If match Then
            Console.WriteLine("NumberFormatInfo object for '{0}' matches '{1}'", 
                                      name, ci.Name)
            hasOneMatch = true
         End If                                       
      Next
      If Not hasOneMatch Then
         Console.WriteLine("NumberFormatInfo object for '{0}' --> No Match", name)            
      End If
      
      Console.WriteLine()
   End Sub
End Module

"Numformatinfo" und "Dynamic Data"NumberFormatInfo and dynamic data

Die kulturspezifischen Daten zum Formatieren von numerischen Werten, die NumberFormatInfo von der-Klasse bereitgestellt werden, sind dynamisch, genau CultureInfo wie die von der-Klasse bereitgestellten kulturellen Daten.The culture-specific data for formatting numeric values provided by the NumberFormatInfo class is dynamic, just like the cultural data provided by the CultureInfo class. Sie sollten keine Annahmen über die Stabilität von Werten für NumberFormatInfo Objekte treffen, die bestimmten CultureInfo Objekten zugeordnet sind.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Nur die Daten, die von der invarianten Kultur und dem NumberFormatInfo zugeordneten-Objekt bereitgestellt werden, sind stabil.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Andere Daten können aus den folgenden Gründen zwischen Anwendungs Sitzungen oder sogar innerhalb einer einzelnen Sitzung geändert werden:Other data can change between application sessions, or even within a single session, for the following reasons:

  • System Updates.System updates. Kulturelle Einstellungen wie Währungssymbol oder Währungsformate ändern sich im Laufe der Zeit.Cultural preferences such as the currency symbol or currency formats change over time. In diesem Fall enthält Windows Update Änderungen am NumberFormatInfo Eigenschafts Wert für eine bestimmte Kultur.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Ersetzungs Kulturen.Replacement cultures. Die CultureAndRegionInfoBuilder -Klasse kann verwendet werden, um die Daten einer vorhandenen Kultur zu ersetzen.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Kaskadierende Änderungen an Eigenschafts Werten.Cascading changes to property values. Eine Reihe von kulturbezogenen Eigenschaften kann zur Laufzeit geändert werden, was wiederum bewirkt NumberFormatInfo , dass sich die Daten ändern.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Beispielsweise kann die aktuelle Kultur entweder Programm gesteuert oder durch eine Benutzeraktion geändert werden.For example, the current culture can be changed either programmatically or through user action. In diesem Fall ändert sich NumberFormatInfo das von der CurrentInfo -Eigenschaft zurückgegebene-Objekt in ein-Objekt, das der aktuellen Kultur zugeordnet ist.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Benutzereinstellungen.User preferences. Benutzer der Anwendung können einige der Werte, die mit der aktuellen System Kultur verknüpft sind, über die Regions-und Sprachoptionen in der Systemsteuerung überschreiben.Users of your application might override some of the values associated with the current system culture through the region and language options in Control Panel. Beispielsweise können Benutzer ein anderes Währungssymbol oder ein anderes Dezimaltrennzeichen auswählen.For example, users might choose a different currency symbol or a different decimal separator symbol. Wenn die CultureInfo.UseUserOverride Eigenschaft auf true (den Standardwert) festgelegt ist NumberFormatInfo , werden die Eigenschaften des Objekts auch aus den Benutzereinstellungen abgerufen.If the CultureInfo.UseUserOverride property is set to true (its default value), the properties of the NumberFormatInfo object are also retrieved from the user settings.

Beginnend mit dem .NET Framework 2,0 werden alle vom Benutzer über schreibbaren Eigenschaften eines NumberFormatInfo -Objekts initialisiert, wenn das-Objekt erstellt wird.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Es besteht immer noch eine Möglichkeit einer Inkonsistenz, da weder die Objekt Erstellung noch der Überschreibungs Prozess des Benutzers atomarisch ist und die relevanten Werte sich während der Objekt Erstellung ändern können.There is still a possibility of inconsistency, because neither object creation nor the user override process is atomic, and the relevant values may change during object creation. Diese Inkonsistenzen sollten jedoch sehr selten auftreten.However, these inconsistencies should be extremely rare.

Sie können steuern, ob Benutzer Überschreibungen in NumberFormatInfo Objekten reflektiert werden, die dieselbe Kultur wie die aktuelle Thread Kultur darstellen.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. In der folgenden Tabelle sind die Methoden aufgeführt, NumberFormatInfo mit denen ein-Objekt abgerufen werden kann, und es wird angegeben, ob das resultierende Objekt Benutzer Überschreibungen widerspiegelt.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

Quelle von CultureInfo-und numformatinfo-ObjektSource of CultureInfo and NumberFormatInfo object Spiegelt Benutzer Überschreibungen widerReflects user overrides
CultureInfo.CurrentCulture.NumberFormat -EigenschaftCultureInfo.CurrentCulture.NumberFormat property JaYes
NumberFormatInfo.CurrentInfo -EigenschaftNumberFormatInfo.CurrentInfo property JaYes
CultureInfo.CreateSpecificCulture-MethodeCultureInfo.CreateSpecificCulture method JaYes
CultureInfo.GetCultureInfo-MethodeCultureInfo.GetCultureInfo method NeinNo
CultureInfo(String)-KonstruktorCultureInfo(String) constructor JaYes
CultureInfo.CultureInfo(String, Boolean)-KonstruktorCultureInfo.CultureInfo(String, Boolean) constructor Hängt vom Wert des useUserOverride Parameters ab.Depends on value of useUserOverride parameter

Sofern es keinen überzeugenden Grund dafür gibt, sollten Sie Benutzer Überschreibungen beachten, wenn Sie das NumberFormatInfo -Objekt in Client Anwendungen verwenden, um Benutzereingaben zu formatieren und zu analysieren oder um numerische Daten anzuzeigen.Unless there is a compelling reason to do otherwise, you should respect user overrides when you use the NumberFormatInfo object in client applications to format and parse user input or to display numeric data. Bei Server Anwendungen oder unbeaufsichtigten Anwendungen sollten Sie keine Benutzer Überschreibungen berücksichtigen.For server applications or unattended applications, you should not respect user overrides. Wenn Sie das NumberFormatInfo Objekt jedoch entweder explizit oder implizit verwenden, um numerische Daten im Zeichen folgen Format beizubehalten, sollten Sie entweder ein NumberFormatInfo -Objekt verwenden, das die Formatierungs Konventionen der invarianten Kultur widerspiegelt, oder Sie müssen einen benutzerdefinierte numerische Format Zeichenfolge, die Sie unabhängig von der Kultur verwenden.However, if you are using the NumberFormatInfo object either explicitly or implicitly to persist numeric data in string form, you should either use a NumberFormatInfo object that reflects the formatting conventions of the invariant culture, or you should specify a custom numeric format string that you use regardless of culture.

IFormatProvider, numformatinfo und numerische FormatierungIFormatProvider, NumberFormatInfo, and numeric formatting

Ein NumberFormatInfo -Objekt wird implizit oder explizit in allen numerischen Formatierungs Vorgängen verwendet.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Hierzu gehören auch Aufrufe der folgenden Methoden:These include calls to the following methods:

Bei allen numerischen Formatierungs Vorgängen wird IFormatProvider eine-Implementierung verwendet.All numeric formatting operations make use of an IFormatProvider implementation. Die IFormatProvider -Schnittstelle enthält eine einzige GetFormat(Type)Methode,.The IFormatProvider interface includes a single method, GetFormat(Type). Dabei handelt es sich um eine Rückruf Methode, Type die ein-Objekt, das den für die Bereitstellung von Formatierungsinformationen erforderlichen Typ darstellt,This is a callback method that is passed a Type object that represents the type needed to provide formatting information. Die-Methode ist für die Rückgabe einer Instanz dieses Typs oder nullverantwortlich, wenn keine Instanz des Typs bereitgestellt werden kann.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. Der .NET Framework stellt zwei IFormatProvider Implementierungen zum Formatieren von zahlen bereit:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Wenn eine CultureInfo CultureInfo.CurrentCulture Implementierung nicht explizit für eine Formatierungs Methode bereitgestellt wird, wird ein-Objekt verwendet, das von der-Eigenschaft zurückgegeben wird, die die aktuelle Thread Kultur darstellt. IFormatProviderIf an IFormatProvider implementation is not provided to a formatting method explicitly, a CultureInfo object returned by the CultureInfo.CurrentCulture property that represents the current thread culture is used.

Das folgende Beispiel veranschaulicht die Beziehung zwischen der IFormatProvider -Schnittstelle NumberFormatInfo und der-Klasse in Formatierungs Vorgängen durch Definieren einer benutzerdefinierten IFormatProvider -Implementierung.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. Die zugehörige-Methode zeigt den Typnamen des Objekts an, das vom Formatierungs Vorgang angefordert wird. GetFormatIts GetFormat method displays the type name of the object requested by the formatting operation. Wenn die Schnittstelle ein NumberFormatInfo -Objekt anfordert, stellt diese Methode das NumberFormatInfo -Objekt für die aktuelle Thread Kultur bereit.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Wie die Ausgabe des Beispiels zeigt, fordert die Decimal.ToString(IFormatProvider) -Methode ein NumberFormatInfo NumberFormatInfo -Objekt auf, um Formatierungsinformationen String.Format(IFormatProvider, String, Object[]) bereitzustellen, DateTimeFormatInfo während die-Methode und ICustomFormatter -Objekte sowie ein Ausführungs.As the output from the example shows, the Decimal.ToString(IFormatProvider) method requests a NumberFormatInfo object to provide formatting information, whereas the String.Format(IFormatProvider, String, Object[]) method requests NumberFormatInfo and DateTimeFormatInfo objects as well as an ICustomFormatter implementation.

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
Imports System.Globalization

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

Module Example
   Public Sub Main()
      Dim amount As Decimal = 1203.541d
      Dim value As String = amount.ToString("C2", New CurrentCultureFormatProvider())
      Console.WriteLine(value)
      Console.WriteLine()
      Dim composite As String = String.Format(New CurrentCultureFormatProvider, 
                                              "Date: {0}   Amount: {1}   Description: {2}",
                                              Date.Now, 1264.03d, "Service Charge")
      Console.WriteLine(composite)
      Console.WriteLine()
   End Sub
End Module
' The example displays output like the following:
'    Requesting an object of type 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 Aufruf der numerischen Formatierungs Methode bereitgestellt wird, ruft CultureInfo.CurrentCulture.GetFormat die-Methode die- NumberFormatInfo Methode auf, die das-Objekt zurückgibt, das der aktuellen Thread Kultur entspricht.If an IFormatProvider implementation is not explicitly provided in a numeric formatting method call, the method calls the CultureInfo.CurrentCulture.GetFormat method, which returns the NumberFormatInfo object that corresponds to the current thread culture.

Format Zeichenfolgen und Eigenschaften von "numformatinfo"Format strings and NumberFormatInfo properties

Jeder Formatierungs Vorgang verwendet entweder eine Standard-oder eine benutzerdefinierte numerische Format Zeichenfolge, um eine Ergebnis Zeichenfolge aus einer Zahl zu erhaltenEvery formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. In einigen Fällen ist die Verwendung einer Format Zeichenfolge zum Entwickeln einer Ergebnis Zeichenfolge explizit, wie im folgenden Beispiel gezeigt.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Dieser Code Ruft die Decimal.ToString(IFormatProvider) -Methode auf, Decimal um einen Wert unter Verwendung der Formatierungs Konventionen der Kultur "en-US" in eine Reihe unterschiedlicher Zeichen folgen Darstellungen zu konvertieren.This code calls the Decimal.ToString(IFormatProvider) method to convert a Decimal value to a number of different string representations by using the formatting conventions of the en-US culture.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim formatStrings() As String = { "C2", "E1", "F", "G3", "N", 
                                        "#,##0.000", "0,000,000,000.0##" }
      Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         For Each formatString In formatStrings
            Dim resultString As String = value.ToString(formatString, culture)
            Console.WriteLine("{0,-18} -->  {1}", formatString, resultString)
         Next
         Console.WriteLine()      
      Next   
   End Sub
End Module
' 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 Format Zeichenfolge implizit.In other cases, the use of a format string is implicit. Beispielsweise wird im folgenden Methodenaufruf der Standardmethode oder der Parameter losen Decimal.ToString() -Methode der Wert Decimal der-Instanz mit dem allgemeinen Format Bezeichner "G" und den Konventionen der aktuellen Kultur formatiert, in diesem Fall: Kultur "en-US".For example, in the following method calls to the default or parameterless Decimal.ToString() method, the value of the Decimal instance is formatted by using the general ("G") format specifier and the conventions of the current culture, which in this case is the en-US culture.

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
Module Example
   Public Sub Main()
      Dim values() As Decimal = { 1345.6538d, 1921651.16d }
      
      For Each value In values
         Dim resultString As String = value.ToString()
         Console.WriteLine(resultString)
         Console.WriteLine()      
      Next   
   End Sub
End Module
' The example displays the following output:
'       1345.6538
'       
'       1921651.16

Jede standardmäßige numerische Format Zeichenfolge verwendet NumberFormatInfo eine oder mehrere Eigenschaften, um das Muster oder die in der Ergebnis Zeichenfolge verwendeten Symbole zu bestimmen.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. Analog dazu werden von jedem benutzerdefinierten numerischen Format Bezeichner mit Ausnahme von "0" und "#" Symbole in die Ergebnis Zeichenfolge eingefügt, die durch NumberFormatInfo Eigenschaften definiert werden.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. In NumberFormatInfo der folgenden Tabelle werden die standardmäßigen und benutzerdefinierten numerischen Format Bearbeiter und deren zugeordnete Eigenschaften aufgelistet.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Informationen zum Ändern der Darstellung der Ergebnis Zeichenfolge für eine bestimmte Kultur finden Sie im Abschnitt Ändern der Eigenschaften von " numformatinfo ".To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Ausführliche Informationen zur Verwendung dieser Format Bearbeiter finden Sie unter Standard mäßige Zahlenformat Zeichenfolgen und benutzerdefinierte ZahlenformatZeichenfolgen.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

FormatbezeichnerFormat specifier Zugeordnete EigenschaftenAssociated properties
"C" oder "c" (Currency Format-Spezifizierer)"C" or "c" (currency format specifier) CurrencyDecimalDigits, um die Standard Anzahl von Dezimalstellen zu definieren.CurrencyDecimalDigits, to define the default number of fractional digits.

CurrencyDecimalSeparator, um das Dezimaltrennzeichen zu definieren.CurrencyDecimalSeparator, to define the decimal separator symbol.

CurrencyGroupSeparator, um die Gruppe oder Tausender Trennzeichen zu definieren.CurrencyGroupSeparator, to define the group or thousands separator.

CurrencyGroupSizes, um die Größen von ganzzahligen Gruppen zu definieren.CurrencyGroupSizes, to define the sizes of integral groups.

CurrencyNegativePattern, um das Muster negativer Währungswerte zu definieren.CurrencyNegativePattern, to define the pattern of negative currency values.

CurrencyPositivePattern, um das Muster positiver Währungswerte zu definieren.CurrencyPositivePattern, to define the pattern of positive currency values.

CurrencySymbolzum Definieren des Währungs Symbols.CurrencySymbol, to define the currency symbol.

NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.
"D" oder "d" (Dezimal Format Bezeichner)"D" or "d" (decimal format specifier) NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.
"E" oder "e" (exponentieller oder wissenschaftlicher Format Bezeichner)"E" or "e" (exponential or scientific format specifier) NegativeSign, um das negative Vorzeichen Symbol in der Mantisse und dem Exponenten zu definieren.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, um das positive Vorzeichen Symbol im Exponent zu definieren.PositiveSign, to define the positive sign symbol in the exponent.
"F" oder "f" (fixpointformatspezifizierer)"F" or "f" (fixed-point format specifier) NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, um die Standard Anzahl von Dezimalstellen zu definieren.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.NumberDecimalSeparator, to define the decimal separator symbol.
"G" oder "g" (allgemeiner Format Bezeichner)"G" or "g" (general format specifier) NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, um das positive Vorzeichen Symbol für Ergebnis Zeichenfolgen im exponentiellen Format zu definieren.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" oder "n" (Zahlenformat Bezeichner)"N" or "n" (number format specifier) NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, um die Standard Anzahl von Dezimalstellen zu definieren.NumberDecimalDigits, to define the default number of fractional digits.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.NumberDecimalSeparator, to define the decimal separator symbol.

NumberGroupSeparator, um das Gruppen Trennzeichen (Tausender) zu definieren.NumberGroupSeparator, to define the group separator (thousands) symbol.

NumberGroupSizes, um die Anzahl der ganzzahligen Ziffern in einer Gruppe zu definieren.NumberGroupSizes, to define the number of integral digits in a group.

NumberNegativePattern, um das Format von negativen Werten zu definieren.NumberNegativePattern, to define the format of negative values.
"P" oder "p" (Prozent Format Bezeichner)"P" or "p" (percent format specifier) NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, um die Standard Anzahl von Dezimalstellen zu definieren.PercentDecimalDigits, to define the default number of fractional digits.

PercentDecimalSeparator, um das Dezimaltrennzeichen zu definieren.PercentDecimalSeparator, to define the decimal separator symbol.

PercentGroupSeparator, um das Gruppen Trennzeichen zu definieren.PercentGroupSeparator, to define the group separator symbol.

PercentGroupSizes, um die Anzahl der ganzzahligen Ziffern in einer Gruppe zu definieren.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, um die Platzierung des Prozent Symbols und das negative Symbol für negative Werte zu definieren.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

PercentPositivePattern, um die Platzierung des Prozent Symbols für positive Werte zu definieren.PercentPositivePattern, to define the placement of the percent symbol for positive values.

PercentSymbol, um das Prozent Symbol zu definieren.PercentSymbol, to define the percent symbol.
"R" oder "r" (Roundtrip-Formatspezifizierer)"R" or "r" (round-trip format specifier) NegativeSign, um das Symbol für das negative Vorzeichen zu definieren.NegativeSign, to define the negative sign symbol.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, um das positive Vorzeichen Symbol in einem Exponenten zu definieren.PositiveSign, to define the positive sign symbol in an exponent.
"X" oder "x" (hexadezimal Formatspezifizierer)"X" or "x" (hexadecimal format specifier) KeineNone.
"." (benutzerdefinierter Format Bezeichner für Dezimaltrennzeichen)"." (decimal point custom format specifier) NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.NumberDecimalSeparator, to define the decimal separator symbol.
"," (benutzerdefinierter Format Bezeichner für Gruppen Trennzeichen)"," (group separator custom format specifier) NumberGroupSeparator, um das Trennzeichen für Gruppen (Tausender) zu definieren.NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (benutzerdefinierter Format Bezeichner für Platzhalter)"%" (percentage placeholder custom format specifier) PercentSymbol, um das Prozent Symbol zu definieren.PercentSymbol, to define the percent symbol.
"°" (benutzerdefinierter Format Bezeichner pro Mille-Platzhalter)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, um das Promille Symbol zu definieren.PerMilleSymbol, to define the per mille symbol.
"E" (benutzerdefinierter Format Bezeichner für Exponentialnotation)"E" (exponential notation custom format specifier) NegativeSign, um das negative Vorzeichen Symbol in der Mantisse und dem Exponenten zu definieren.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, um das positive Vorzeichen Symbol im Exponent zu definieren.PositiveSign, to define the positive sign symbol in the exponent.

Beachten Sie, NumberFormatInfo dass die- NativeDigits Klasse eine-Eigenschaft enthält, die die von einer bestimmten Kultur verwendeten Basis 10 Ziffern angibt.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Die-Eigenschaft wird jedoch nicht in Formatierungs Vorgängen verwendet. nur die grundlegenden lateinischen Ziffern 0 (u + 0030) bis 9 (u + 0039) werden in der Ergebnis Zeichenfolge verwendet.However, the property is not used in formatting operations; only the Basic Latin digits 0 (U+0030) through 9 (U+0039) are used in the result string. Außerdem Single besteht für-und Double -Werte NaNvon PositiveInfinity, und NegativeInfinitydie Ergebnis Zeichenfolge ausschließlich aus den Symbolen, die von NaNSymbolden PositiveInfinitySymbolEigenschaften, NegativeInfinitySymbol und definiert werden. bzw.In addition, for Single and Double values of NaN, PositiveInfinity, and NegativeInfinity, the result string consists exclusively of the symbols defined by the NaNSymbol, PositiveInfinitySymbol, and NegativeInfinitySymbol properties, respectively.

Ändern von Eigenschaften vom datformatinfoModifying NumberFormatInfo properties

Sie können die Eigenschaften eines NumberFormatInfo -Objekts ändern, um die in einem numerischen Formatierungs Vorgang erstellte Ergebnis Zeichenfolge anzupassen.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Gehen Sie dazu wie folgt vor:To do this:

  1. Erstellen Sie eine Lese-/Schreibkopie eines NumberFormatInfo -Objekts, dessen Formatierungs Konventionen Sie ändern möchten.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Weitere Informationen finden Sie im Abschnitt Instanziieren eines numformatinfo-Objekts .For more information, see the Instantiating a NumberFormatInfo object section.

  2. Ändern Sie die-Eigenschaft oder die-Eigenschaften, die zum Entwickeln der gewünschten Ergebnis Zeichenfolge verwendet werden.Modify the property or properties that are used to produce the desired result string. Informationen dazu, wie Formatierungs Methoden NumberFormatInfo Eigenschaften zum Definieren von Ergebnis Zeichenfolgen verwenden, finden Sie im Abschnitt Formatieren von Zeichen folgen und Eigenschaften von "Eigenschaften".For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Verwenden Sie das NumberFormatInfo benutzerdefinierte Objekt IFormatProvider als Argument in Aufrufen von Formatierungs Methoden.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Hinweis

Anstatt die Eigenschaftswerte einer Kultur bei jedem Start einer Anwendung dynamisch zu ändern, können Sie die CultureAndRegionInfoBuilder -Klasse verwenden, um entweder eine benutzerdefinierte Kultur (eine Kultur mit einem eindeutigen Namen, die vorhandene Kulturen ergänzt) oder einen Ersatz zu definieren. Kultur (eine, die anstelle einer bestimmten Kultur verwendet wird).Instead of dynamically modifying a culture's property values each time an application is started, you can use the CultureAndRegionInfoBuilder class to define either a custom culture (a culture that has a unique name and that supplements existing cultures) or a replacement culture (one that is used instead of a specific culture).

In den folgenden Abschnitten finden Sie einige Beispiele.The following sections provide some examples.

Ändern des Währungs Symbols und des MustersModifying the currency symbol and pattern

Im folgenden Beispiel wird ein NumberFormatInfo -Objekt geändert, das die Formatierungs Konventionen der Kultur "en-US" darstellt.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. Er weist der- CurrencySymbol Eigenschaft das Währungssymbol ISO-4217 zu und definiert ein Muster für Währungswerte, das aus dem Währungssymbol gefolgt von einem Leerzeichen und einem numerischen Wert besteht.It assigns the ISO-4217 currency symbol to the CurrencySymbol property and defines a pattern for currency values that consists of the currency symbol followed by a space and a numeric value.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Retrieve a writable NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = 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.
      Dim values() As Decimal = { 1065.23d, 19.89d, -.03d, -175902.32d }
      For Each value In values
         Console.WriteLine(value.ToString("C", enUS))
      Next      
      Console.WriteLine()
      
      ' Produce the result strings by calling a composite formatting method.
      For Each value In values
         Console.WriteLine(String.Format(enUS, "{0:C}", value))      
      Next
   End Sub
End Module
' 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

Formatieren einer nationalen IdentifikationsnummerFormatting a national identification number

Viele nationale Identifikationsnummern bestehen ausschließlich aus Ziffern und können daher leicht formatiert werden, indem Sie die Eigenschaften NumberFormatInfo eines-Objekts ändern.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Beispielsweise besteht eine Sozialversicherungsnummer in der USA aus 9 Ziffern wie folgt: XXX-XX-XXXX.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. Im folgenden Beispiel wird davon ausgegangen, dass die Sozialversicherungsnummern als ganzzahlige Werte gespeichert und entsprechend formatiert werden.The following example assumes that social security numbers are stored as integer values and formats them appropriately.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Instantiate a read-only NumberFormatInfo object.
      Dim enUS As CultureInfo = CultureInfo.CreateSpecificCulture("en-US")
      Dim nfi As NumberFormatInfo = enUS.NumberFormat

      ' Modify the relevant properties.
      nfi.NumberGroupSeparator = "-"
      nfi.NumberGroupSizes = { 3, 2, 4}
      nfi.NumberDecimalDigits = 0
      
      Dim ids() As Integer = { 111223333, 999776666 }
      
      ' Produce the result string by calling ToString.
      For Each id In ids
         Console.WriteLine(id.ToString("N", enUS))
      Next 
      Console.WriteLine()
      
      ' Produce the result string using composite formatting.
      For Each id In ids
         Console.WriteLine(String.Format(enUS, "{0:N}", id))
      Next
   End Sub
End Module
' The example displays the following output:
'       1112-23-333
'       9997-76-666
'       
'       1112-23-333
'       9997-76-666

Verarbeiten numerischer ZeichenfolgenParsing numeric strings

Bei der-Initialisierung wird die Zeichen folgen Darstellung einer Zahl in eine Zahl konvertiert.Parsing involves converting the string representation of a number to a number. Jeder numerische Typ in der .NET Framework enthält zwei überladene Methoden zum Parse über TryParseLaden von Methoden: und.Each numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. Die Parse -Methode konvertiert eine Zeichenfolge in eine Zahl und löst eine Ausnahme aus, wenn bei der Konvertierung ein Fehler auftritt.The Parse method converts a string to a number and throws an exception if the conversion fails. Die TryParse -Methode konvertiert eine Zeichenfolge in eine Zahl, weist die Zahl out einem Argument zu und gibt Boolean einen Wert zurück, der angibt, ob die Konvertierung erfolgreich abgeschlossen wurde.The TryParse method converts a string to a number, assigns the number to an out argument, and returns a Boolean value that indicates whether the conversion succeeded.

Die Analyse-Methoden verwenden implizit oder explizit NumberStyles einen-Enumerationswert, um zu bestimmen, welche Stilelemente (z. b. Gruppen Trennzeichen, ein Dezimaltrennzeichen oder ein Währungssymbol) in einer Zeichenfolge vorhanden sein können, wenn der Analyse-Vorgang erfolgreich ist.The parsing methods implicitly or explicitly use a NumberStyles enumeration value to determine what style elements (such as group separators, a decimal separator, or a currency symbol) can be present in a string if the parsing operation is to succeed. Wenn im Methoden NumberStyles Float AllowThousands Aufrufwert kein Wert angegeben wird, ist der Standardwert ein Wert, der die Flags und enthält, die angeben, dass die analysierte Zeichenfolge Gruppen Symbole, ein Dezimaltrennzeichen, ein negatives Vorzeichen, NumberStyles und Leerzeichen oder die Zeichen folgen Darstellung einer Zahl in Exponentialnotation.If a NumberStyles value is not provided in the method call, the default is a NumberStyles value that includes the Float and AllowThousands flags, which specifies that the parsed string can include group symbols, a decimal separator, a negative sign, and white-space characters, or it can be the string representation of a number in exponential notation.

Die Analysemethoden verwenden auch implizit oder explizit ein NumberFormatInfo -Objekt, das die spezifischen Symbole und Muster definiert, die in der zu testenden Zeichenfolge vorkommen können.The parsing methods also implicitly or explicitly use a NumberFormatInfo object that defines the specific symbols and patterns that can occur in the string to be parsed. Wenn kein- NumberFormatInfo Objektbereitgestelltwird,istderStandardwertderfürdieNumberFormatInfo aktuelle Thread Kultur.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Weitere Informationen zur-Verarbeitung finden Sie Int16.Parse(String)in den einzelnen Methoden zum Auswerten, wie z. b., Double.TryParse(String, Double) Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger) Decimal.Parse(String, NumberStyles, IFormatProvider), und.For more information about parsing, see the individual parsing methods, such as Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double), and BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger).

Im folgenden Beispiel wird die Kultur abhängige Darstellung von Zeichen folgen veranschaulicht.The following example illustrates the culture-sensitive nature of parsing strings. Es wird versucht, eine Zeichenfolge zu analysieren, die Tausende Trennzeichen enthält, indem die Konventionen der Kultur en-US, fr-FR und invariante verwendet werden.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Eine Zeichenfolge, die das Komma als Gruppen Trennzeichen enthält, und der Zeitraum als Dezimaltrennzeichen kann nicht in der fr-FR-Kultur analysiert werden, und eine Zeichenfolge mit Leerraum als Gruppen Trennzeichen und ein Komma als Dezimaltrennzeichen können nicht in den en-US-und invarianten Kulturen analysiert werden.A string that includes the comma as a group separator and the period as a decimal separator fails to parse in the fr-FR culture, and a string with white space as a group separator and a comma as a decimal separator fails to parse in the en-US and invariant cultures.

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)
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As String = { "1,034,562.91", "9 532 978,07" }
      Dim cultureNames() As String = { "en-US", "fr-FR", "" }
      
      For Each value In values
         For Each cultureName In cultureNames
            Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
            Dim name As String = If(culture.Name = "", "Invariant", culture.Name)
            Try
               Dim amount As Decimal = Decimal.Parse(value, culture)
               Console.WriteLine("'{0}' --> {1} ({2})", value, amount, name)
            Catch e As FormatException
               Console.WriteLine("'{0}': FormatException ({1})",
                                 value, name)
            End Try   
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' 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)

Die Verarbeitung erfolgt in der Regel in zwei Kontexten:Parsing generally occurs in two contexts:

  • Als Vorgang, der zum Konvertieren von Benutzereingaben in einen numerischen Wert entworfen wurde.As an operation that is designed to convert user input into a numeric value.

  • Als Vorgang, der für einen Roundtrip für einen numerischen Wert konzipiert ist. Das heißt, um einen numerischen Wert zu deserialisieren, der zuvor als Zeichenfolge serialisiert wurde.As an operation that is designed to round-trip a numeric value; that is, to deserialize a numeric value that was previously serialized as a string.

In den folgenden Abschnitten werden diese beiden Vorgänge ausführlicher erläutert.The following sections discuss these two operations in greater detail.

Benutzer Zeichenfolgen werden verarbeitet.Parsing user strings

Wenn Sie numerische Zeichen folgen Eingaben durch den Benutzer durchlaufen, sollten Sie immer ein NumberFormatInfo -Objekt instanziieren, das die Kultur Einstellungen des Benutzers widerspiegelt.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Informationen dazu, wie Sie ein NumberFormatInfo - Objekt instanziieren, das Benutzeranpassungen widerspiegelt, finden Sie im Abschnitt zu den Informationen zu ""For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem-Verarbeitungsvorgang, der Benutzer Kultur Einstellungen widerspiegelt, und einem, der nicht.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. In diesem Fall ist die Standardsystem Kultur "en-US", aber der Benutzer hat "," als Dezimalzeichen und "." als Gruppen Trennzeichen in der Systemsteuerung, der Region und der Sprachedefiniert.In this case, the default system culture is en-US, but the user has defined "," as the decimal symbol and "." as the group separator in Control Panel, Region and Language. Normalerweise werden diese Symbole in der Standard Kultur "en-US" umgekehrt.Ordinarily, these symbols are reversed in the default en-US culture. Wenn der Benutzer eine Zeichenfolge eingibt, die Benutzereinstellungen widerspiegelt, und die Zeichenfolge NumberFormatInfo durch ein-Objekt analysiert wird, das auch Benutzereinstellungen (außer Kraft setzungen) widerspiegelt, gibt der Analyse Vorgang ein korrektes Ergebnis zurück.When the user enters a string that reflects user settings, and the string is parsed by a NumberFormatInfo object that also reflects user settings (overrides), the parsing operation returns a correct result. Wenn die Zeichenfolge jedoch von einem NumberFormatInfo -Objekt analysiert wird, das die standardmäßigen en-US-Kultur Einstellungen widerspiegelt, ist das Komma Symbol für ein Gruppen Trennzeichen fehlerhaft, und es wird ein falsches Ergebnis zurückgegeben.However, when the string is parsed by a NumberFormatInfo object that reflects standard en-US cultural settings, it mistakes the comma symbol for a group separator and returns an incorrect result.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim stdCulture As CultureInfo = CultureInfo.GetCultureInfo("en-US")
      Dim custCulture As CultureInfo = CultureInfo.CreateSpecificCulture("en-US") 
            
      Dim value As String = "310,16"
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           stdCulture.Name, stdCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, stdCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
      Console.WriteLine()
                                            
      Try
         Console.WriteLine("{0} culture reflects user overrides: {1}", 
                           custCulture.Name, custCulture.UseUserOverride)
         Dim amount As Decimal = Decimal.Parse(value, custCulture)
         Console.WriteLine("'{0}' --> {1}", value, amount.ToString(CultureInfo.InvariantCulture))                                                                                        
      Catch e As FormatException
         Console.WriteLine("Unable to parse '{0}'", value)
      End Try   
   End Sub
End Module
' 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

Serialisieren und Deserialisieren von numerischen DatenSerializing and deserializing numeric data

Wenn numerische Daten im Zeichen folgen Format serialisiert und später deserialisiert und analysiert werden, sollten die Zeichen folgen mithilfe der Konventionen der invarianten Kultur generiert und analysiert werden.When numeric data is serialized in string format and later deserialized and parsed, the strings should be generated and parsed by using the conventions of the invariant culture. Die Formatierungs-und die-Diagnose Vorgänge sollten niemals die Konventionen einer bestimmten Kultur widerspiegeln.The formatting and parsing operations should never reflect the conventions of a specific culture. Wenn kulturspezifische Einstellungen verwendet werden, ist die Portabilität der Daten streng eingeschränkt. Sie kann nur in einem Thread deserialisiert werden, dessen kulturspezifische Einstellungen mit denen des Threads identisch sind, in dem Sie serialisiert wurde.If culture-specific settings are used, the portability of the data is strictly limited; it can be successfully deserialized only on a thread whose culture-specific settings are identical to those of the thread on which it was serialized. In einigen Fällen bedeutet dies, dass die Daten nicht einmal erfolgreich auf dem gleichen System deserialisiert werden können, auf dem Sie serialisiert wurde.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

Im folgenden Beispiel wird veranschaulicht, was passieren kann, wenn dieses Prinzip verletzt wird.The following example illustrates what can happen when this principle is violated. Gleit Komma Werte in einem Array werden in Zeichen folgen konvertiert, wenn der aktuelle Thread die kulturspezifischen Einstellungen der Kultur "en-US" verwendet.Floating-point values in an array are converted to strings when the current thread uses the culture-specific settings of the en-US culture. Die Daten werden dann von einem Thread analysiert, der die kulturspezifischen Einstellungen der Kultur "en-GB" verwendet.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. In diesem Fall werden zwar die einzelnen Verarbeitungsvorgänge erfolgreich ausgeführt, die Daten werden jedoch nicht erfolgreich gerundet, und es tritt eine Beschädigung der Daten auf.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. In anderen Fällen kann ein-Verarbeitungsvorgang fehlschlagen, und FormatException es könnte eine-Ausnahme ausgelöst werden.In other cases, a parsing operation could fail and a FormatException exception could be thrown.

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
Imports System.Collections.Generic
Imports System.Globalization
Imports System.IO
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      PersistData()
      
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-GB")
      RestoreData()
   End Sub
   
   Private Sub PersistData()
      ' Define an array of floating-point values.
      Dim values() As Double = { 160325.972, 8631.16, 1.304e5, 98017554.385, 
                                 8.5938287084321676e94 }
      Console.WriteLine("Original values: ")
      For Each value In values
         Console.WriteLine(value.ToString("R", CultureInfo.InvariantCulture))
      Next
         
      ' Serialize an array of doubles to a file 
      Dim sw As New StreamWriter(".\NumericData.bin")
      For ctr As Integer = 0 To values.Length - 1
         sw.Write(values(ctr).ToString("R"))
         If ctr < values.Length - 1 Then sw.Write("|")
      Next
      sw.Close()
      Console.WriteLine()
   End Sub
   
   Private Sub RestoreData()   
      ' Deserialize the data
      Dim sr AS New StreamReader(".\NumericData.bin")
      Dim data As String = sr.ReadToEnd()
      sr.Close()
      
      Dim stringValues() As String = data.Split("|"c)
      Dim newValueList As New List(Of Double)
      
      For Each stringValue In stringValues
         Try
            newValueList.Add(Double.Parse(stringValue))
         Catch e As FormatException
            newValueList.Add(Double.NaN)
         End Try   
      Next                                   

      Console.WriteLine("Restored values:")
      For Each newValue In newValueList
         Console.WriteLine(newValue.ToString("R", NumberFormatInfo.InvariantInfo))
      Next
   End Sub
End Module
' 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

Konstruktoren

NumberFormatInfo() NumberFormatInfo() NumberFormatInfo() NumberFormatInfo()

Initialisiert eine neue, schreibbare Instanz der NumberFormatInfo-Klasse, die kulturunabhängig (invariant) ist.Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Eigenschaften

CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits CurrencyDecimalDigits

Ruft die Anzahl der in Währungswerten zu verwendenden Dezimalstellen ab oder legt diese fest.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator CurrencyDecimalSeparator

Ruft die in Währungsangaben als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator CurrencyGroupSeparator

Ruft die Zeichenfolge ab, mit der bei Währungsangaben Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes CurrencyGroupSizes

Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in Währungsangaben ab oder legt diese fest.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern CurrencyNegativePattern

Ruft das Formatmuster für negative Währungsangaben ab oder legt dieses fest.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern CurrencyPositivePattern

Ruft das Formatmuster für positive Währungsangaben ab oder legt dieses fest.Gets or sets the format pattern for positive currency values.

CurrencySymbol CurrencySymbol CurrencySymbol CurrencySymbol

Ruft die als Währungssymbol zu verwendende Zeichenfolge ab oder legt diese fest.Gets or sets the string to use as the currency symbol.

CurrentInfo CurrentInfo CurrentInfo CurrentInfo

Ruft eine schreibgeschützte NumberFormatInfo ab, die Werte auf Grundlage der aktuellen Kultur formatiert.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution DigitSubstitution DigitSubstitution DigitSubstitution

Ruft einen Wert ab oder legt einen Wert fest, der angibt, in welcher Form die grafische Benutzeroberfläche Ziffern anzeigt.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo InvariantInfo InvariantInfo InvariantInfo

Ruft ein schreibgeschütztes NumberFormatInfo-Objekt ab, das kulturunabhängig (invariant) ist.Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ruft einen Wert ab, der angibt, ob dieses NumberFormatInfo-Objekt schreibgeschützt ist.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol NaNSymbol NaNSymbol NaNSymbol

Ruft die Zeichenfolge ab, die den IEEE-NaN-Wert (Not a Number) darstellt, oder legt diese fest.Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits NativeDigits NativeDigits NativeDigits

Ruft ein Zeichenfolgenarray mit systemeigenen Ziffern ab, die den europäischen Ziffern 0 (null) bis 9 entsprechen, oder legt ein entsprechendes Zeichenfolgenarray fest.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol NegativeInfinitySymbol

Ruft die Zeichenfolge ab, die minus unendlich darstellt, oder legt diese fest.Gets or sets the string that represents negative infinity.

NegativeSign NegativeSign NegativeSign NegativeSign

Ruft die Zeichenfolge ab, die kennzeichnet, dass die zugeordnete Zahl negativ ist, oder legt diese fest.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits NumberDecimalDigits

Ruft die Anzahl der in numerischen Werten zu verwendenden Dezimalstellen ab oder legt diese fest.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator NumberDecimalSeparator

Ruft die in numerischen Werten als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator NumberGroupSeparator

Ruft die Zeichenfolge ab, mit der bei numerischen Werten Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes NumberGroupSizes NumberGroupSizes NumberGroupSizes

Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in numerischen Werten ab oder legt diese fest.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern NumberNegativePattern NumberNegativePattern NumberNegativePattern

Ruft das Formatmuster für negative numerische Werte ab oder legt dieses fest.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits PercentDecimalDigits

Ruft die Anzahl der in Prozentwerten zu verwendenden Dezimalstellen ab oder legt diese fest.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator PercentDecimalSeparator

Ruft die in Prozentwerten als Dezimaltrennzeichen zu verwendende Zeichenfolge ab oder legt diese fest.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator PercentGroupSeparator

Ruft die Zeichenfolge ab, mit der in Prozentwerten Zifferngruppen links vom Dezimaltrennzeichen getrennt werden, oder legt diese fest.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes PercentGroupSizes PercentGroupSizes PercentGroupSizes

Ruft die Anzahl von Ziffern in jeder Gruppe links vom Dezimaltrennzeichen in Prozentwerten ab oder legt diese fest.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern PercentNegativePattern PercentNegativePattern PercentNegativePattern

Ruft das Formatmuster für negative Prozentangaben ab oder legt dieses fest.Gets or sets the format pattern for negative percent values.

PercentPositivePattern PercentPositivePattern PercentPositivePattern PercentPositivePattern

Ruft das Formatmuster für positive Prozentangaben ab oder legt dieses fest.Gets or sets the format pattern for positive percent values.

PercentSymbol PercentSymbol PercentSymbol PercentSymbol

Ruft die als Prozentsymbol zu verwendende Zeichenfolge ab oder legt diese fest.Gets or sets the string to use as the percent symbol.

PerMilleSymbol PerMilleSymbol PerMilleSymbol PerMilleSymbol

Ruft die als Promillesymbol zu verwendende Zeichenfolge ab oder legt diese fest.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol PositiveInfinitySymbol

Ruft die Zeichenfolge ab, die plus unendlich darstellt, oder legt diese fest.Gets or sets the string that represents positive infinity.

PositiveSign PositiveSign PositiveSign PositiveSign

Ruft die Zeichenfolge ab, die kennzeichnet, dass die zugeordnete Zahl positiv ist, oder legt diese fest.Gets or sets the string that denotes that the associated number is positive.

Methoden

Clone() Clone() Clone() Clone()

Erstellt eine flache Kopie des NumberFormatInfo-Objekts.Creates a shallow copy of the NumberFormatInfo object.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetFormat(Type) GetFormat(Type) GetFormat(Type) GetFormat(Type)

Ruft ein Objekt vom angegebenen Typ ab, das einen Zahlenformatierungsdienst bereitstellt.Gets an object of the specified type that provides a number formatting service.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider) GetInstance(IFormatProvider)

Ruft die NumberFormatInfo ab, die dem angegebenen IFormatProvider zugeordnet ist.Gets the NumberFormatInfo associated with the specified IFormatProvider.

GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo) ReadOnly(NumberFormatInfo)

Gibt einen schreibgeschützten NumberFormatInfo-Wrapper zurück.Returns a read-only NumberFormatInfo wrapper.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Gilt für:

Siehe auch