NumberFormatInfo Klasse

Definition

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

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

Beispiele

Das folgende Beispiel zeigt, wie sie ein -Objekt für ein entsprechendes -Objekt abrufen und das abgerufene -Objekt verwenden, um Zahlenformatierungsinformationen für die jeweilige NumberFormatInfo CultureInfo Kultur abzurufen.

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. Diese Informationen umfassen das Währungssymbol, das Dezimalzeichen, das Gruppentrennzeichen und die Symbole für positive und negative Zeichen.

Instanziieren eines NumberFormatInfo-Objekts

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

Instanziieren eines NumberFormatInfo-Objekts für die aktuelle Kultur

Sie können ein NumberFormatInfo -Objekt für die aktuelle Kultur auf eine der folgenden Arten instanziieren. In jedem Fall ist das NumberFormatInfo zurückgegebene Objekt schreibgeschützt.

Im folgenden Beispiel werden diese drei Methoden verwendet, um Objekte zu NumberFormatInfo erstellen, die die Formatierungskonventionen der aktuellen Kultur darstellen. Außerdem wird der Wert der IsReadOnly -Eigenschaft abgerufen, um zu veranschaulichen, dass jedes Objekt schreibgeschützt ist.

using System;
using System.Globalization;

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

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

      NumberFormatInfo current3 = NumberFormatInfo.GetInstance(CultureInfo.CurrentCulture);
      Console.WriteLine(current3.IsReadOnly);
   }
}
// The example displays the following output:
//       True
//       True
//       True
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 NumberFormatInfo schreibbares Objekt erstellen, das die Konventionen der aktuellen Kultur auf eine der folgenden Arten darstellt:

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

using System;
using System.Globalization;

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

      CultureInfo culture2 = CultureInfo.CreateSpecificCulture(CultureInfo.CurrentCulture.Name);
      NumberFormatInfo current2 = culture2.NumberFormat;
      Console.WriteLine(current2.IsReadOnly);
   }
}
// The example displays the following output:
//       False
//       False
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 das Windows Betriebssystem es dem Benutzer ermöglicht, einige der Eigenschaftswerte außer Kraft zu setzen, die NumberFormatInfo in numerischen Formatierungs- und Analysevorgängen über das Element Region und Sprache in Systemsteuerung verwendet werden. Beispielsweise kann ein Benutzer, dessen Kultur Englisch (USA) ist, Währungswerte als 1,1 USD anstelle des Standardwerts von 1,1 USD anzeigen. Die NumberFormatInfo -Objekte, die auf die zuvor beschriebene Weise abgerufen wurden, spiegeln alle diese Benutzerüberschreibungen wider. Wenn dies nicht erwünscht ist, können Sie ein -Objekt erstellen, NumberFormatInfo das keine Benutzerüberschreibungen widerspiegelt (und das auch Lese-/Schreibzugriff statt schreibgeschützt ist), indem Sie den CultureInfo.CultureInfo(String, Boolean) Konstruktor aufrufen und einen Wert von für das Argument false useUserOverride angeben. Das folgende Beispiel zeigt ein System, dessen aktuelle Kultur Englisch (USA) ist und dessen Währungssymbol von der Standardeinstellung $in USD geändert wurde.

using System;
using System.Globalization;

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

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

      culture = new CultureInfo(CultureInfo.CurrentCulture.Name, false);
      Console.WriteLine("Culture Name:    {0}", culture.Name);
      Console.WriteLine("User Overrides:  {0}", culture.UseUserOverride);
      Console.WriteLine("Currency Symbol: {0}", culture.NumberFormat.CurrencySymbol);
   }
}
// The example displays the following output:
//       Culture Name:    en-US
//       User Overrides:  True
//       Currency Symbol: USD
//
//       Culture Name:    en-US
//       User Overrides:  False
//       Currency Symbol: $
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 festgelegt true ist, werden auch die Eigenschaften CultureInfo.DateTimeFormat , und aus den CultureInfo.NumberFormat CultureInfo.TextInfo Benutzereinstellungen abgerufen. Wenn die Benutzereinstellungen nicht mit der dem -Objekt zugeordneten Kultur kompatibel sind CultureInfo (z. B. wenn der ausgewählte Kalender keiner der von der -Eigenschaft aufgelisteten Kalender OptionalCalendars ist), sind die Ergebnisse der Methoden und die Werte der Eigenschaften nicht definiert.

Instanziieren eines NumberFormatInfo-Objekts für die invariante Kultur

Die invariante Kultur stellt eine Kultur dar, die kulturunabhängig ist. Sie basiert auf der englischen Sprache, aber nicht auf einem bestimmten englischsprachigen Land bzw. einer bestimmten englischsprachigen Region. Obwohl die Daten bestimmter Kulturen dynamisch sein können und sich ändern können, um neue kulturelle Konventionen oder Benutzereinstellungen widerzuspiegeln, ändern sich die Daten der invarianten Kultur nicht. Ein NumberFormatInfo -Objekt, das die Formatierungskonventionen der invarianten Kultur darstellt, kann für Formatierungsvorgänge verwendet werden, bei denen Ergebniszeichenfolgen nicht je nach Kultur variieren sollten.

Sie können ein NumberFormatInfo -Objekt, das die Formatierungskonventionen der invarianten Kultur darstellt, wie folgt instanziieren:

Im folgenden Beispiel wird jede dieser Methoden verwendet, um ein -Objekt zu instanziieren, NumberFormatInfo das die invariante Kultur darstellt. Anschließend wird angegeben, ob das Objekt schreibgeschützt ist.

using System;
using System.Globalization;

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

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

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

      nfi = new NumberFormatInfo();
      Console.WriteLine(nfi.IsReadOnly);
   }
}
// The example displays the following output:
//       True
//       True
//       False
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 NumberFormatInfo-Objekts für eine bestimmte Kultur

Eine bestimmte Kultur stellt eine Sprache dar, die in einem bestimmten Land/einer bestimmten Region gesprochen wird. Beispielsweise ist en-US eine bestimmte Kultur, die die in der USA gesprochene englische Sprache darstellt, und en-CA eine bestimmte Kultur, die die in Kanada gesprochene englische Sprache darstellt. Sie können ein NumberFormatInfo -Objekt, das die Formatierungskonventionen einer bestimmten Kultur darstellt, wie folgt instanziieren:

Im folgenden Beispiel werden diese vier Methoden verwendet, um ein -Objekt zu NumberFormatInfo erstellen, das die Formatierungskonventionen der Kultur "Indonesisch (Indonesisch)" widerspiegelt. Außerdem wird angegeben, ob jedes Objekt schreibgeschützt ist.

using System;
using System.Globalization;

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

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

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

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

      culture = new CultureInfo("id-ID");
      nfi = culture.NumberFormat;
      Console.WriteLine("Read-only: {0}", nfi.IsReadOnly);
   }
}
// The example displays the following output:
//       Read-only: True
//       Read-only: False
//       Read-only: False
//       Read-only: False
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 NumberFormatInfo-Objekts für eine neutrale Kultur

Eine neutrale Kultur stellt eine Kultur oder Sprache dar, die von einem Land/einer Region unabhängig ist. Es ist in der Regel das übergeordnete Element einer oder mehrerer spezifischer Kulturen. Beispielsweise ist fr eine neutrale Kultur für die französische Sprache und das übergeordnete Element der fr-FR-Kultur. Sie erstellen ein NumberFormatInfo -Objekt, das die Formatierungskonventionen einer neutralen Kultur auf die gleiche Weise darstellt wie ein NumberFormatInfo -Objekt, das die Formatierungskonventionen einer bestimmten Kultur darstellt.

Hinweis

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

Da sie jedoch unabhängig von einem bestimmten Land/einer bestimmten Region ist, fehlen in einer neutralen Kultur kulturspezifische Formatierungsinformationen. Anstatt das NumberFormatInfo Objekt mit generischen Werten aufzufüllen, gibt der .NET Framework ein NumberFormatInfo -Objekt zurück, das die Formatierungskonventionen einer bestimmten Kultur widerspiegelt, die ein untergeordnetes Element der neutralen Kultur ist. Beispielsweise spiegelt das NumberFormatInfo -Objekt für die neutrale en-Kultur die Formatierungskonventionen der Kultur "en-US" wider, und das NumberFormatInfo -Objekt für die kultur fr spiegelt die Formatierungskonventionen der kultur fr-FR wider.

Sie können Code wie den folgenden verwenden, um zu bestimmen, welche Formatierungskonventionen für eine bestimmte Kultur von jeder neutralen Kultur dargestellt werden.

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

NumberFormatInfo und dynamische Daten

Die kulturspezifischen Daten zum Formatieren numerischer Werte, die von der -Klasse bereitgestellt NumberFormatInfo werden, sind dynamisch, genau wie die Kulturdaten, die von der -Klasse bereitgestellt CultureInfo werden. Sie sollten keine Annahmen über die Stabilität von Werten für NumberFormatInfo Objekte treffen, die bestimmten Objekten zugeordnet CultureInfo sind. Nur die daten, die von der invarianten Kultur und dem zugehörigen Objekt bereitgestellt NumberFormatInfo werden, sind stabil. Andere Daten können sich aus den folgenden Gründen zwischen Anwendungssitzungen oder sogar innerhalb einer einzelnen Sitzung ändern:

  • Systemupdates. Kultureinstellungen wie das Währungssymbol oder Währungsformate ändern sich im Laufe der Zeit. In diesem Fall enthält Windows Update Änderungen am NumberFormatInfo Eigenschaftswert für eine bestimmte Kultur.

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

  • Kaskadierende Änderungen an Eigenschaftswerten. Eine Reihe kulturbezogener Eigenschaften kann sich zur Laufzeit ändern, was wiederum dazu führt, dass NumberFormatInfo sich Daten ändern. Beispielsweise kann die aktuelle Kultur entweder programmgesteuert oder über eine Benutzeraktion geändert werden. In diesem Fall ändert sich das NumberFormatInfo von der -Eigenschaft zurückgegebene Objekt CurrentInfo in ein Objekt, das der aktuellen Kultur zugeordnet ist.

  • Benutzereinstellungen. Benutzer Ihrer Anwendung überschreiben möglicherweise einige der Werte, die der aktuellen Systemkultur über die Regions- und Sprachoptionen in Systemsteuerung zugeordnet sind. Beispielsweise können Benutzer ein anderes Währungssymbol oder ein anderes Dezimaltrennzeichen auswählen. Wenn die CultureInfo.UseUserOverride -Eigenschaft auf true (ihr Standardwert) festgelegt ist, werden die Eigenschaften des NumberFormatInfo -Objekts auch aus den Benutzereinstellungen abgerufen.

Ab .NET Framework 2.0 werden alle benutzerüberschreibbaren Eigenschaften eines NumberFormatInfo -Objekts initialisiert, wenn das -Objekt erstellt wird. Es besteht weiterhin die Möglichkeit einer Inkonsistenz, da weder die Objekterstellung noch der Benutzerüberschreibungsprozess atomar ist und sich die relevanten Werte während der Objekterstellung ändern können. Diese Inkonsistenzen sollten jedoch äußerst selten sein.

Sie können steuern, ob Benutzerüberschreibungen in Objekten wiedergegeben NumberFormatInfo werden, die dieselbe Kultur wie die aktuelle Kultur darstellen. In der folgenden Tabelle sind die Möglichkeiten zum Abrufen eines NumberFormatInfo -Objekts aufgeführt, und es wird angegeben, ob das resultierende Objekt Benutzerüberschreibungen widerspiegelt.

Quelle des CultureInfo- und NumberFormatInfo-Objekts Spiegelt Benutzerüberschreibungen wider
CultureInfo.CurrentCulture.NumberFormat -Eigenschaft Ja
NumberFormatInfo.CurrentInfo -Eigenschaft Ja
CultureInfo.CreateSpecificCulture-Methode Ja
CultureInfo.GetCultureInfo-Methode Nein
CultureInfo(String)-Konstruktor Ja
CultureInfo.CultureInfo(String, Boolean)-Konstruktor Hängt vom Wert des Parameters ab. useUserOverride

Sofern es keinen überzeugenden Grund dafür gibt, sollten Sie Benutzerüberschreibungen berücksichtigen, wenn Sie das NumberFormatInfo -Objekt in Clientanwendungen verwenden, um Benutzereingaben zu formatieren und zu analysieren oder numerische Daten anzuzeigen. Bei Serveranwendungen oder unbeaufsichtigten Anwendungen sollten Sie keine Benutzerüberschreibungen berücksichtigen. Wenn Sie das -Objekt jedoch NumberFormatInfo entweder explizit oder implizit zum Beibehalten numerischer Daten in Zeichenfolgenform verwenden, sollten Sie entweder ein -Objekt verwenden, das die NumberFormatInfo Formatierungskonventionen der invarianten Kultur widerspiegelt, oder Sie sollten eine benutzerdefinierte numerische Formatzeichenfolge angeben, die Sie unabhängig von der Kultur verwenden.

IFormatProvider, NumberFormatInfo und numerische Formatierung

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

Alle numerischen Formatierungsvorgänge verwenden eine IFormatProvider -Implementierung. Die IFormatProvider -Schnittstelle enthält eine einzelne Methode, GetFormat(Type) . Dies ist eine Rückrufmethode, an die ein -Objekt übergeben Type wird, das den Typ darstellt, der zum Bereitstellen von Formatierungsinformationen erforderlich ist. Die -Methode ist dafür verantwortlich, entweder eine Instanz dieses Typs oder null zurückzugeben, wenn sie keine Instanz des Typs bereitstellen kann. Der .NET Framework stellt zwei IFormatProvider Implementierungen zum Formatieren von Zahlen bereit:

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

Im folgenden Beispiel wird die Beziehung zwischen der IFormatProvider -Schnittstelle und der NumberFormatInfo -Klasse in Formatierungsvorgängen durch Definieren einer benutzerdefinierten IFormatProvider Implementierung veranschaulicht. Die -Methode zeigt den Typnamen des Objekts an, GetFormat das vom Formatierungsvorgang angefordert wird. Wenn die Schnittstelle ein NumberFormatInfo -Objekt anfordert, stellt diese Methode das NumberFormatInfo -Objekt für die aktuelle Kultur bereit. Wie die Ausgabe des Beispiels zeigt, fordert die Decimal.ToString(IFormatProvider) Methode ein NumberFormatInfo -Objekt an, um Formatierungsinformationen bereitzustellen, während die String.Format(IFormatProvider, String, Object[]) -Methode - und NumberFormatInfo DateTimeFormatInfo -Objekte sowie eine -Implementierung anfordert. ICustomFormatter

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 Numerischen Formatierungsmethodenaufruf bereitgestellt wird, ruft die -Methode die CultureInfo.CurrentCulture.GetFormat -Methode auf, die das -Objekt zurückgibt, NumberFormatInfo das der aktuellen Kultur entspricht.

Formatzeichenfolgen und NumberFormatInfo-Eigenschaften

Jeder Formatierungsvorgang verwendet entweder eine standard- oder eine benutzerdefinierte numerische Formatzeichenfolge, um eine Ergebniszeichenfolge aus einer Zahl zu erstellen. In einigen Fällen ist die Verwendung einer Formatzeichenfolge zum Erstellen einer Ergebniszeichenfolge explizit, wie im folgenden Beispiel dargestellt. Dieser Code ruft die Decimal.ToString(IFormatProvider) -Methode auf, um einen Decimal Wert mithilfe der Formatierungskonventionen der Kultur "en-US" in eine Reihe verschiedener Zeichenfolgendarstellungen zu konvertieren.

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 Formatzeichenfolge implizit. In den folgenden Methodenaufrufen der Standard- oder parameterlosen Methode wird der Wert der -Instanz beispielsweise Decimal.ToString() Decimal mithilfe des allgemeinen Formatbezeichners ("G") und der Konventionen der aktuellen Kultur formatiert, in diesem Fall der Kultur en-US.

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 Formatzeichenfolge verwendet eine oder mehrere NumberFormatInfo Eigenschaften, um das Muster oder die in der Ergebniszeichenfolge verwendeten Symbole zu bestimmen. Auf ähnliche Weise fügt jeder benutzerdefinierte numerische Formatbezeichner mit Ausnahme von "0" und "#" Symbole in die Ergebniszeichenfolge ein, die durch Eigenschaften definiert NumberFormatInfo werden. In der folgenden Tabelle sind die standardmäßigen und benutzerdefinierten numerischen Formatbezeichner und die zugehörigen NumberFormatInfo Eigenschaften aufgeführt. Informationen zum Ändern der Darstellung der Ergebniszeichenfolge für eine bestimmte Kultur finden Sie im Abschnitt Ändern der NumberFormatInfo-Eigenschaften. Ausführliche Informationen zur Verwendung dieser Formatbezeichner finden Sie unter Standardmäßige numerische Formatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.

Formatbezeichner Zugeordnete Eigenschaften
"C" oder "c" (Währungsformatbezeichner) CurrencyDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

CurrencyDecimalSeparator, um das Dezimaltrennzeichen zu definieren.

CurrencyGroupSeparator, um die Gruppe oder tausend Trennzeichen zu definieren.

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

CurrencyNegativePattern, um das Muster negativer Währungswerte zu definieren.

CurrencyPositivePattern, um das Muster positiver Währungswerte zu definieren.

CurrencySymbol, um das Währungssymbol zu definieren.

NegativeSign, um das Minuszeichen zu definieren.
"D" oder "d" (Dezimalformatbezeichner) NegativeSign, um das Minuszeichen zu definieren.
"E" oder "e" (Exponential- oder wissenschaftlicher Formatbezeichner) NegativeSign, um das negative Vorzeichen in der Mantisse und dem Exponenten zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.

PositiveSign, um das positive Vorzeichen im Exponenten zu definieren.
"F" oder "f" (Festkommaformatbezeichner) NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.
"G" oder "g" (allgemeiner Formatbezeichner) NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.

PositiveSign, um das positive Vorzeichen für Ergebniszeichenfolgen im exponentiellen Format zu definieren.
"N" oder "n" (Zahlenformatbezeichner) NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.

NumberGroupSeparator, um das Gruppentrennzeichen (Tausende) zu definieren.

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

NumberNegativePattern, um das Format negativer Werte zu definieren.
"P" oder "p" (Prozentformatbezeichner) NegativeSign, um das Minuszeichen zu definieren.

PercentDecimalDigits, um die Standardanzahl von Dezimalstellen zu definieren.

PercentDecimalSeparator, um das Dezimaltrennzeichen zu definieren.

PercentGroupSeparator, um das Gruppentrennzeichen zu definieren.

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

PercentNegativePattern, um die Platzierung des Prozentsymbols und des negativen Symbols für negative Werte zu definieren.

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

PercentSymbol, um das Prozentsymbol zu definieren.
"R" oder "r" (Roundtripformatbezeichner) NegativeSign, um das Minuszeichen zu definieren.

NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.

PositiveSign, um das positive Vorzeichen in einem Exponenten zu definieren.
"X" oder "x" (Hexadezimalformatbezeichner) Keine.
"." (benutzerdefinierter Dezimaltrennzeichenformatbezeichner) NumberDecimalSeparator, um das Dezimaltrennzeichen zu definieren.
"," (benutzerdefinierter Formatbezeichner für Gruppentrennzeichen) NumberGroupSeparator, um das Gruppentrennzeichen (Tausende) zu definieren.
"%" (benutzerdefinierter Formatbezeichner für Prozentplatzhalter) PercentSymbol, um das Prozentsymbol zu definieren.
"," (benutzerdefinierter Formatbezeichner pro Mille-Platzhalter) PerMilleSymbol, um das Pro mille-Symbol zu definieren.
"E" (benutzerdefinierter Formatbezeichner für exponentielle Notation) NegativeSign, um das negative Vorzeichensymbol in der Mantisse und dem Exponenten zu definieren.

PositiveSign, um das positive Vorzeichensymbol im Exponenten zu definieren.

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

Ändern von NumberFormatInfo-Eigenschaften

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

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

  2. Ändern Sie die Eigenschaft oder die Eigenschaften, die zum Erzeugen der gewünschten Ergebniszeichenfolge verwendet werden. Informationen dazu, wie Formatierungsmethoden Eigenschaften verwenden, um Ergebniszeichenfolgen zu definieren, finden Sie im Abschnitt NumberFormatInfo Formatzeichenfolgen und NumberFormatInfo-Eigenschaften.

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

Hinweis

Anstatt die Eigenschaftswerte einer Kultur bei jedem Start einer Anwendung dynamisch zu ändern, können Sie die -Klasse verwenden, um entweder eine benutzerdefinierte Kultur (eine Kultur, die einen eindeutigen Namen hat und vorhandene Kulturen ergänzt) oder eine Ersetzungskultur (eine Kultur, die anstelle einer bestimmten Kultur verwendet wird) zu CultureAndRegionInfoBuilder definieren.

Die folgenden Abschnitte enthalten einige Beispiele.

Ändern des Währungssymbols und -musters

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

using System;
using System.Globalization;

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

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

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

      Console.WriteLine();

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

Viele nationale Identifikationsnummern bestehen ausschließlich aus Ziffern und können daher problemlos formatiert werden, indem die Eigenschaften eines Objekts geändert NumberFormatInfo werden. Beispielsweise besteht eine Sozialversicherungsnummer im USA aus neun Ziffern, die wie folgt angeordnet sind: XXX-XX-XXXX . Im folgenden Beispiel wird davon ausgegangen, dass Sozialversicherungsnummern als ganzzahlige Werte gespeichert und entsprechend formatiert werden.

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 Zeichenfolgen

Bei der Analyse wird die Zeichenfolgendarstellung einer Zahl in eine Zahl konvertiert. Jeder numerische Typ in der .NET Framework enthält zwei überladene Analysemethoden: Parse und TryParse . Die Parse -Methode konvertiert eine Zeichenfolge in eine Zahl und löst eine Ausnahme aus, wenn die Konvertierung fehlschlägt. Die TryParse -Methode konvertiert eine Zeichenfolge in eine Zahl, weist die Zahl einem Argument zu und gibt einen Wert zurück, der angibt, ob die out Konvertierung erfolgreich Boolean war.

Die Analysemethoden verwenden implizit oder explizit einen -Enumerationswert, um zu bestimmen, welche Stilelemente (z. B. Gruppentrennzeichen, Dezimaltrennzeichen oder Währungssymbole) in einer Zeichenfolge vorhanden sein können, wenn der Analysevorgang erfolgreich sein NumberStyles soll. Wenn im Methodenaufruf kein Wert angegeben wird, ist der Standardwert ein Wert, der die Flags und enthält. Dies gibt an, dass die analysierte Zeichenfolge Gruppensymbole, ein Dezimaltrennzeichen, ein negatives Vorzeichen und Leerzeichen enthalten kann, oder es kann sich um die Zeichenfolgendarstellung einer Zahl NumberStyles NumberStyles in Float AllowThousands exponentieller Notation handelt.

Die Analysemethoden verwenden auch implizit oder explizit ein -Objekt, das die spezifischen Symbole und Muster definiert, die in der zu analysierenden NumberFormatInfo Zeichenfolge auftreten können. Wenn kein NumberFormatInfo -Objekt bereitgestellt wird, ist der Standardwert der NumberFormatInfo für die aktuelle Kultur. Weitere Informationen zur Analyse finden Sie in den einzelnen Analysemethoden, z. B. Int16.Parse(String) , , , , und Int32.Parse(String, NumberStyles) Int64.Parse(String, IFormatProvider) Decimal.Parse(String, NumberStyles, IFormatProvider) Double.TryParse(String, Double) BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger) .

Das folgende Beispiel veranschaulicht die kultursensible Natur der Analyse von Zeichenfolgen. Es wird versucht, eine Zeichenfolge zu analysieren, die Tausende Trennzeichen enthält, indem die Konventionen der Kulturen "en-US", "fr-FR" und "invariant" verwendet werden. Eine Zeichenfolge, die das Komma als Gruppentrennzeichen und den Punkt als Dezimaltrennzeichen enthält, kann in der kultur fr-FR nicht analysiert werden, und eine Zeichenfolge mit Leerzeichen als Gruppentrennzeichen und ein Komma als Dezimaltrennzeichen kann in den en-US- und invarianten Kulturen nicht analysiert werden.

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 Analyse erfolgt im Allgemeinen in zwei Kontexten:

  • Als Vorgang, der entwickelt wurde, um Benutzereingaben in einen numerischen Wert zu konvertieren.

  • Als Vorgang, der für einen Roundtrip eines numerischen Werts konzipiert ist. das heißt, um einen numerischen Wert zu deserialisieren, der zuvor als Zeichenfolge serialisiert wurde.

In den folgenden Abschnitten werden diese beiden Vorgänge ausführlicher erläutert.

Analyse von Benutzerzeichenfolgen

Wenn Sie vom Benutzer eingegebene numerische Zeichenfolgen analysen, sollten Sie immer ein -Objekt instanziieren, das die NumberFormatInfo Kultureinstellungen des Benutzers widerspiegelt. Informationen zum Instanziieren eines -Objekts, das Benutzeranpassungen widerspiegelt, finden Sie im Abschnitt NumberFormatInfo NumberFormatInfo und dynamische Daten.

Das folgende Beispiel veranschaulicht den Unterschied zwischen einem Analysevorgang, der die Kultureinstellungen des Benutzers widerspiegelt, und einem, der dies nicht tut. In diesem Fall ist die Standardsystemkultur en-US, aber der Benutzer hat "," als Dezimalsymbol und "." als Gruppentrennzeichen in Systemsteuerung, Region und Sprache definiert. Normalerweise werden diese Symbole in der Standardkultur "en-US" umgekehrt. Wenn der Benutzer eine Zeichenfolge eingibt, die Benutzereinstellungen widerspiegelt, und die Zeichenfolge von einem -Objekt analysiert wird, das auch Benutzereinstellungen wiedergibt (Außerkraftsetzungen), gibt der Analysevorgang ein NumberFormatInfo korrektes Ergebnis zurück. Wenn die Zeichenfolge jedoch von einem -Objekt analysiert wird, das standardmäßige en-US-Kultureinstellungen widerspiegelt, wird das Kommasymbol für ein Gruppentrennzeichen falsch gekennzeichnet und ein NumberFormatInfo falsches Ergebnis zurückgegeben.

using System;
using System.Globalization;

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

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

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

Wenn numerische Daten im Zeichenfolgenformat serialisiert und später deserialisiert und analysiert werden, sollten die Zeichenfolgen mithilfe der Konventionen der invarianten Kultur generiert und analysiert werden. Die Formatierungs- und Analysevorgänge sollten nie die Konventionen einer bestimmten Kultur widerspiegeln. 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. In einigen Fällen bedeutet dies, dass die Daten nicht einmal erfolgreich auf demselben System deserialisiert werden können, auf dem sie serialisiert wurden.

Im folgenden Beispiel wird veranschaulicht, was passieren kann, wenn gegen dieses Prinzip verstoßen wird. Gleitkommawerte in einem Array werden in Zeichenfolgen konvertiert, wenn der aktuelle Thread die kulturspezifischen Einstellungen der Kultur "en-US" verwendet. Die Daten werden dann von einem Thread analysiert, der die kulturspezifischen Einstellungen der pt-BR-Kultur verwendet. Obwohl in diesem Fall jeder Analysevorgang erfolgreich ist, werden die Daten nicht erfolgreich gerundet, und es kommt zu einer Datenbeschädigung. In anderen Fällen kann ein Analysevorgang fehlschlagen und eine FormatException Ausnahme ausgelöst werden.

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

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

      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR");
      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()
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      PersistData()
      
      CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("pt-BR")
      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()

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

Eigenschaften

CurrencyDecimalDigits

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

CurrencyDecimalSeparator

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

CurrencyGroupSeparator

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

CurrencyGroupSizes

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

CurrencyNegativePattern

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

CurrencyPositivePattern

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

CurrencySymbol

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

CurrentInfo

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

DigitSubstitution

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

InvariantInfo

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

IsReadOnly

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

NaNSymbol

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

NativeDigits

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

NegativeInfinitySymbol

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

NegativeSign

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

NumberDecimalDigits

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

NumberDecimalSeparator

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

NumberGroupSeparator

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

NumberGroupSizes

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

NumberNegativePattern

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

PercentDecimalDigits

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

PercentDecimalSeparator

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

PercentGroupSeparator

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

PercentGroupSizes

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

PercentNegativePattern

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

PercentPositivePattern

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

PercentSymbol

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

PerMilleSymbol

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

PositiveInfinitySymbol

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

PositiveSign

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

Methoden

Clone()

Erstellt eine flache Kopie des NumberFormatInfo-Objekts.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetFormat(Type)

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

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetInstance(IFormatProvider)

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

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ReadOnly(NumberFormatInfo)

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

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Gilt für

Siehe auch