NumberFormatInfo Sınıf

Tanım

Sayısal değerleri biçimlendirmek ve ayrıştırmak için kültüre özgü bilgiler sağlar.Provides culture-specific information for formatting and parsing numeric values.

public ref class NumberFormatInfo sealed : ICloneable, IFormatProvider
public sealed class NumberFormatInfo : ICloneable, IFormatProvider
[System.Serializable]
public sealed class NumberFormatInfo : 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
Devralma
NumberFormatInfo
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, karşılık gelen bir CultureInfo nesnesi için NumberFormatInfo nesnesinin nasıl alınacağını ve belirli kültürün sayı biçimlendirme bilgilerini sorgulamak için alınan nesneyi nasıl kullanacağınızı gösterir.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 '$'

Açıklamalar

NumberFormatInfo sınıfı, sayısal değerleri biçimlendirdiğinizde ve ayrıştırdığınızda kullanılan kültüre özgü bilgiler içerir.The NumberFormatInfo class contains culture-specific information that is used when you format and parse numeric values. Bu bilgiler; para birimi simgesini, ondalık sembolünü, Grup ayırıcı sembolünü ve pozitif ve negatif işaretler için sembolleri içerir.This information includes the currency symbol, the decimal symbol, the group separator symbol, and the symbols for positive and negative signs.

Bir NumberFormatInfo nesnesini örneklemeInstantiating a NumberFormatInfo object

Geçerli kültürün biçimlendirme kurallarını, sabit kültürü, belirli bir kültürü veya bağımsız kültürü temsil eden bir NumberFormatInfo nesnesi örneği oluşturabilirsiniz.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.

Geçerli kültür için bir NumberFormatInfo nesnesini örneklemeInstantiating a NumberFormatInfo object for the current culture

Aşağıdaki yollarla geçerli iş parçacığı kültürü için bir NumberFormatInfo nesnesi örneği oluşturabilirsiniz.You can instantiate a NumberFormatInfo object for the current thread culture in any of the following ways. Her durumda, döndürülen NumberFormatInfo nesnesi salt okunurdur.In each case, the returned NumberFormatInfo object is read-only.

Aşağıdaki örnek, geçerli kültürün biçimlendirme kurallarını temsil eden NumberFormatInfo nesneleri oluşturmak için bu üç yolu kullanır.The following example uses these three ways to create NumberFormatInfo objects that represent the formatting conventions of the current culture. Ayrıca, her bir nesnenin salt okunurdur olduğunu göstermek için IsReadOnly özelliğinin değerini alır.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

Aşağıdaki yollarla geçerli iş parçacığı kültürünün kurallarını temsil eden yazılabilir bir NumberFormatInfo nesnesi oluşturabilirsiniz:You can create a writable NumberFormatInfo object that represents the conventions of the current thread culture in any of the following ways:

Aşağıdaki örnek, bir NumberFormatInfo nesnesini örneketmenin iki yolunu gösterir ve nesnenin salt okunurdur olduğunu göstermek için IsReadOnly özelliğinin değerini gösterir.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

Windows işletim sisteminin, Kullanıcı tarafından sayısal biçimlendirme ve ayrıştırma işlemlerinde kullanılan NumberFormatInfo Özellik değerlerinden bazılarını, Denetim Masası 'ndaki bölge ve dil öğesi aracılığıyla geçersiz kılmasına izin verdiğini unutmayın.Note 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. Örneğin, kültürü Ingilizce (Birleşik Devletler) olan bir Kullanıcı, para birimi değerlerini varsayılan $1,1 yerine 1,1 ABD Doları olarak görüntülemeyi seçebilir.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. Daha önce tüm bu kullanıcı geçersiz kılmalarını yansıtan NumberFormatInfo nesneleri alındı.The NumberFormatInfo objects retrieved in the ways discussed previously all reflect these user overrides. Bu istenmezse, CultureInfo.CultureInfo(String, Boolean) oluşturucusunu çağırarak ve useUserOverride bağımsız değişkeni için bir false değeri sağlayarak Kullanıcı geçersiz kılmalarını yansıtmayan (ve salt okuma/yazma) bir NumberFormatInfo nesnesi oluşturabilirsiniz.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. Aşağıdaki örnek, geçerli kültürün Ingilizce (Birleşik Devletler) ve para birimi simgesi varsayılan $-USD ' den ABD Doları olarak değiştirilmiş olan bir sistem için bir çizim sağlar.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: $

CultureInfo.UseUserOverride özelliği trueolarak ayarlanırsa, Özellikler CultureInfo.DateTimeFormat, CultureInfo.NumberFormatve CultureInfo.TextInfo de kullanıcı ayarlarından alınır.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. Kullanıcı ayarları, CultureInfo nesnesiyle ilişkili kültür ile uyumsuzsa (örneğin, seçili takvim OptionalCalendars özelliği tarafından listelenen takvimlerden biri değilse), yöntemlerin sonuçları ve özelliklerin değerleri tanımsızdır.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.

Sabit kültür için bir NumberFormatInfo nesnesini örneklemeInstantiating a NumberFormatInfo object for the invariant culture

Sabit kültür, kültüre duyarlı olmayan bir kültürü temsil eder.The invariant culture represents a culture that is culture-insensitive. İngilizce dile dayalıdır, ancak herhangi bir Ingilizce-konuşma ülkesine/bölgesine uygulanmaz.It is based on the English language but not on any specific English-speaking country/region. Belirli kültürlerin verileri dinamik olabilir ve yeni kültürel kuralları veya Kullanıcı tercihlerini yansıtacak şekilde değişseler de, sabit kültürün verileri değişmez.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. Sabit kültürün biçimlendirme kurallarını temsil eden bir NumberFormatInfo nesnesi, sonuç dizelerinin kültüre göre değişiklik göstermesi gereken biçimlendirme işlemleri için kullanılabilir.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.

Aşağıdaki yollarla, sabit kültürün biçimlendirme kurallarını temsil eden bir NumberFormatInfo nesnesi örneğini oluşturabilirsiniz:You can instantiate a NumberFormatInfo object that represents the formatting conventions of the invariant culture in the following ways:

Aşağıdaki örnek, sabit kültürü temsil eden bir NumberFormatInfo nesnesi örneğini oluşturmak için bu yöntemlerin her birini kullanır.The following example uses each of these methods to instantiate a NumberFormatInfo object that represents the invariant culture. Daha sonra nesnenin salt okunurdur olduğunu belirtir,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

Belirli bir kültür için bir NumberFormatInfo nesnesini örneklemeInstantiating a NumberFormatInfo object for a specific culture

Belirli bir kültür, belirli bir ülkede/bölgede konuşulan bir dili temsil eder.A specific culture represents a language that is spoken in a particular country/region. Örneğin, en-US, Birleşik Devletler konuşulan Ingilizce dili temsil eden özel bir kültürdür ve en-CA, Kanada 'da konuşulan Ingilizce dili temsil eden belirli bir kültürdür.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. Aşağıdaki yollarla belirli bir kültürün biçimlendirme kurallarını temsil eden bir NumberFormatInfo nesnesi örneğini oluşturabilirsiniz:You can instantiate a NumberFormatInfo object that represents the formatting conventions of a specific culture in the following ways:

Aşağıdaki örnek, Endonezya dili (Endonezya) kültürünün biçimlendirme kurallarını yansıtan bir NumberFormatInfo nesnesi oluşturmak için bu dört yolu kullanır.The following example uses these four ways to create a NumberFormatInfo object that reflects the formatting conventions of the Indonesian (Indonesia) culture. Ayrıca, her bir nesnenin salt okunurdur.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

Bağımsız kültür için bir NumberFormatInfo nesnesini örneklemeInstantiating a NumberFormatInfo object for a neutral culture

Nötr kültür bir ülke/bölgeden bağımsız bir kültürü veya dili temsil eder.A neutral culture represents a culture or language that is independent of a country/region. Genellikle bir veya daha fazla belirli kültürlerin üst öğesidir.It is typically the parent of one or more specific cultures. Örneğin fr, Fransızca dili ve fr-FR kültürünün üst öğesi için nötr bir kültür.For example, fr is a neutral culture for the French language and the parent of the fr-FR culture. Belirli bir kültürün biçimlendirme kurallarını temsil eden bir NumberFormatInfo nesnesi oluşturduğunuz şekilde, nötr bir kültürün biçimlendirme kurallarını temsil eden bir NumberFormatInfo nesnesi oluşturun.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.

Not

.NET Framework 3.5.NET Framework 3.5 ve önceki sürümlerde, nötr bir kültürün biçimlendirme kurallarını yansıtan bir NumberFormatInfo nesnesi alınmaya çalışılması, bir NotSupportedException özel durumu oluşturur.In 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.

Ancak, belirli bir ülke/bölgeden bağımsız olduğu için, nötr kültür kültüre özgü biçimlendirme bilgilerine sahip değildir.However, because it is independent of a specific country/region, a neutral culture lacks culture-specific formatting information. NumberFormatInfo nesnesini genel değerlerle doldurmak yerine .NET Framework, nötr kültürün bir alt öğesi olan belirli bir kültürün biçimlendirme kurallarını yansıtan bir NumberFormatInfo nesnesi döndürür.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. Örneğin, nötr en kültür için NumberFormatInfo nesnesi, en-US kültürün biçimlendirme kurallarını yansıtır ve FR kültürü için NumberFormatInfo nesnesi fr-FR kültürünün biçimlendirme kurallarını yansıtır.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.

Her bir bağımsız kültür için hangi belirli kültürün biçimlendirme kurallarını temsil ettiğini öğrenmek için aşağıdaki gibi bir kod kullanabilirsiniz.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

NumberFormatInfo ve dinamik verilerNumberFormatInfo and dynamic data

NumberFormatInfo sınıfı tarafından sunulan sayısal değerleri biçimlendirmeye yönelik kültüre özgü veriler, CultureInfo sınıfı tarafından sunulan kültürel verileri gibi dinamiktir.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. Belirli CultureInfo nesneleriyle ilişkili NumberFormatInfo nesnelerinin değerlerinin kararlılığı hakkında herhangi bir varsayımın olmaması gerekir.You should not make any assumptions about the stability of values for NumberFormatInfo objects that are associated with particular CultureInfo objects. Yalnızca sabit kültür ve onunla ilişkili NumberFormatInfo nesnesi tarafından belirtilen veriler kararlı değildir.Only the data provided by the invariant culture and its associated NumberFormatInfo object is stable. Diğer veriler, uygulama oturumları arasında, hatta tek bir oturum içinde, aşağıdaki nedenlerle değişebilir:Other data can change between application sessions, or even within a single session, for the following reasons:

  • Sistem güncelleştirmeleri.System updates. Para birimi sembolü veya para birimi biçimleri gibi kültürel tercihleri zaman içinde değişir.Cultural preferences such as the currency symbol or currency formats change over time. Bu durumda Windows Update, belirli bir kültür için NumberFormatInfo özellik değerindeki değişiklikleri içerir.When this happens, Windows Update includes changes to the NumberFormatInfo property value for a particular culture.

  • Değiştirme kültürleri.Replacement cultures. CultureAndRegionInfoBuilder sınıfı, var olan bir kültürün verilerini değiştirmek için kullanılabilir.The CultureAndRegionInfoBuilder class can be used to replace the data of an existing culture.

  • Özellik değerlerinde yapılan değişiklikler basamaklandırıyor.Cascading changes to property values. Kültür ile ilgili birçok özellik, çalışma zamanında değişebilir. Bu, sırasıyla NumberFormatInfo verilerinin değişmesine neden olur.A number of culture-related properties can change at run time, which, in turn, causes NumberFormatInfo data to change. Örneğin, geçerli kültür programlı bir şekilde veya Kullanıcı eylemi aracılığıyla değiştirilebilir.For example, the current culture can be changed either programmatically or through user action. Bu durumda, CurrentInfo özelliği tarafından döndürülen NumberFormatInfo nesnesi, geçerli kültürle ilişkili bir nesne olarak değişir.When this happens, the NumberFormatInfo object returned by the CurrentInfo property changes to an object associated with the current culture.

  • Kullanıcı tercihleri.User preferences. Uygulamanızın kullanıcıları, Denetim Masası 'ndaki bölge ve dil seçenekleri aracılığıyla geçerli sistem kültürüyle ilişkili bazı değerleri geçersiz kılabilir.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. Örneğin, kullanıcılar farklı bir para birimi sembolü veya farklı bir ondalık ayırıcı sembolü seçebilir.For example, users might choose a different currency symbol or a different decimal separator symbol. CultureInfo.UseUserOverride özelliği true (varsayılan değeri) olarak ayarlandıysa, NumberFormatInfo nesnesinin özellikleri kullanıcı ayarlarından de alınır.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.

.NET Framework 2,0 ' den başlayarak, nesne oluşturulduğunda bir NumberFormatInfo nesnesinin tüm Kullanıcı tarafından geçersiz kılınabilir özellikleri başlatılır.Starting with the .NET Framework 2.0, all user-overridable properties of a NumberFormatInfo object are initialized when the object is created. Hiçbir nesne oluşturma veya Kullanıcı geçersiz kılma işlemi atomik olmadığından ve ilgili değerler nesne oluşturma sırasında değişeceğinden, tutarsızlık olasılığı vardır.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. Ancak, bu tutarsızlıklar son derece nadir olmalıdır.However, these inconsistencies should be extremely rare.

Kullanıcı geçersiz kılmalarının, geçerli iş parçacığı kültürüyle aynı kültürü temsil eden NumberFormatInfo nesneleri içinde yansıtıldığını denetleyebilirsiniz.You can control whether user overrides are reflected in NumberFormatInfo objects that represent the same culture as the current thread culture. Aşağıdaki tabloda NumberFormatInfo nesnenin alınma yolları listelenmektedir ve sonuçta elde edilen nesnenin Kullanıcı geçersiz kılmalarını yansıtmadığını gösterir.The following table lists the ways in which a NumberFormatInfo object can be retrieved and indicates whether the resulting object reflects user overrides.

CultureInfo ve NumberFormatInfo nesnesinin kaynağıSource of CultureInfo and NumberFormatInfo object Kullanıcı geçersiz kılmalarını yansıtırReflects user overrides
CultureInfo.CurrentCulture.NumberFormat özelliğiCultureInfo.CurrentCulture.NumberFormat property EvetYes
NumberFormatInfo.CurrentInfo özelliğiNumberFormatInfo.CurrentInfo property EvetYes
CultureInfo.CreateSpecificCulture yöntemiCultureInfo.CreateSpecificCulture method EvetYes
CultureInfo.GetCultureInfo yöntemiCultureInfo.GetCultureInfo method HayırNo
CultureInfo(String) OluşturucusuCultureInfo(String) constructor EvetYes
CultureInfo.CultureInfo(String, Boolean) OluşturucusuCultureInfo.CultureInfo(String, Boolean) constructor useUserOverride parametresinin değerine bağlıdırDepends on value of useUserOverride parameter

Bunu yapmak için etkileyici bir neden olmadıkça, Kullanıcı girişini biçimlendirmek ve ayrıştırmak ya da sayısal verileri göstermek için istemci uygulamalarında NumberFormatInfo nesnesini kullandığınızda Kullanıcı geçersiz kılmalara dikkat etmelisiniz.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. Sunucu uygulamaları veya katılımsız uygulamalar için, Kullanıcı geçersiz kılmalarını dikkate almalısınız.For server applications or unattended applications, you should not respect user overrides. Ancak, dize biçiminde sayısal verileri kalıcı olarak veya örtük olarak kalıcı hale getirmek için NumberFormatInfo nesnesini kullanıyorsanız, sabit kültürün biçimlendirme kurallarını yansıtan bir NumberFormatInfo nesnesi kullanmanız ya da kültürden bağımsız olarak kullandığınız özel bir sayısal biçim dizesi belirtmeniz gerekir.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, NumberFormatInfo ve sayısal biçimlendirmeIFormatProvider, NumberFormatInfo, and numeric formatting

NumberFormatInfo nesne, tüm sayısal biçimlendirme işlemlerinde örtük veya açık olarak kullanılır.A NumberFormatInfo object is used implicitly or explicitly in all numeric formatting operations. Bunlar aşağıdaki yöntemlere çağrılar içerir:These include calls to the following methods:

Tüm sayısal biçimlendirme işlemleri IFormatProvider uygulamasını kullanır.All numeric formatting operations make use of an IFormatProvider implementation. IFormatProvider arabirimi tek bir yöntemi içerir, GetFormat(Type).The IFormatProvider interface includes a single method, GetFormat(Type). Bu, biçimlendirme bilgilerini sağlamak için gereken türü temsil eden bir Type nesnesi geçen bir geri çağırma yöntemidir.This is a callback method that is passed a Type object that represents the type needed to provide formatting information. Yöntemi, türün bir örneğini sağlayabilmesinin bu tür bir örneği veya nulldöndürmekten sorumludur.The method is responsible for returning either an instance of that type or null, if it cannot provide an instance of the type. .NET Framework, biçimlendirme sayıları için iki IFormatProvider uygulaması sağlar:The .NET Framework provides two IFormatProvider implementations for formatting numbers:

Bir IFormatProvider uygulama açıkça bir biçimlendirme yöntemine sağlanmazsa, geçerli iş parçacığı kültürünü temsil eden CultureInfo.CurrentCulture özelliği tarafından döndürülen bir CultureInfo nesnesi kullanılır.If 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.

Aşağıdaki örnek, özel bir IFormatProvider uygulamasını tanımlayarak IFormatProvider arabirimi ile biçimlendirme işlemlerinde NumberFormatInfo sınıfı arasındaki ilişkiyi gösterir.The following example illustrates the relationship between the IFormatProvider interface and the NumberFormatInfo class in formatting operations by defining a custom IFormatProvider implementation. GetFormat yöntemi, biçimlendirme işlemi tarafından istenen nesnenin tür adını görüntüler.Its GetFormat method displays the type name of the object requested by the formatting operation. Arabirim bir NumberFormatInfo nesnesi istiyorsa, bu yöntem geçerli iş parçacığı kültürü için NumberFormatInfo nesnesi sağlar.If the interface is requesting a NumberFormatInfo object, this method provides the NumberFormatInfo object for the current thread culture. Örneğin çıkışının gösterdiği gibi, Decimal.ToString(IFormatProvider) yöntemi biçimlendirme bilgilerini sağlamak için bir NumberFormatInfo nesnesi ister, ancak String.Format(IFormatProvider, String, Object[]) yöntemi NumberFormatInfo ve DateTimeFormatInfo nesnelerini ve ICustomFormatter uygulamasını ister.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

Bir IFormatProvider uygulama bir sayısal biçimlendirme yöntemi çağrısında açık bir şekilde sağlanmamışsa, yöntemi, geçerli iş parçacığı kültürüne karşılık gelen NumberFormatInfo nesnesini döndüren CultureInfo.CurrentCulture.GetFormat yöntemini çağırır.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.

Biçim dizeleri ve NumberFormatInfo özellikleriFormat strings and NumberFormatInfo properties

Her biçimlendirme işlemi bir sayıdan sonuç dizesi üretmek için standart veya özel bir sayısal biçim dizesi kullanır.Every formatting operation uses either a standard or a custom numeric format string to produce a result string from a number. Bazı durumlarda, bir sonuç dizesi üretmek için bir biçim dizesinin kullanılması aşağıdaki örnekte olduğu gibi açıktır.In some cases, the use of a format string to produce a result string is explicit, as in the following example. Bu kod, en-US kültürün biçimlendirme kurallarını kullanarak bir Decimal değerini farklı dize temsillerine dönüştürmek için Decimal.ToString(IFormatProvider) yöntemini çağırır.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

Diğer durumlarda, bir biçim dizesinin kullanımı örtük bir şekilde gerçekleştirilir.In other cases, the use of a format string is implicit. Örneğin, aşağıdaki yöntem varsayılan veya parametresiz Decimal.ToString() yöntemine çağrılanıyorsa, Decimal örneğinin değeri genel ("G") Biçim belirleyicisi ve geçerli kültürün kuralları (Bu durumda en-US kültürü) kullanılarak biçimlendirilir.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

Her standart sayısal biçim dizesi, bir veya daha fazla NumberFormatInfo özelliğini kullanarak, bir veya daha fazla özellik kullanır ve sonuç dizesinde kullanılan sembolleri veya sembolleri belirlemektir.Each standard numeric format string uses one or more NumberFormatInfo properties to determine the pattern or the symbols used in the result string. Benzer şekilde, "0" ve "#" dışındaki her bir özel sayısal biçim belirticisi, NumberFormatInfo özellikleri tarafından tanımlanan sonuç dizesinde semboller ekler.Similarly, each custom numeric format specifier except "0" and "#" insert symbols in the result string that are defined by NumberFormatInfo properties. Aşağıdaki tabloda, standart ve özel sayısal biçim belirticileri ve bunlarla ilişkili NumberFormatInfo özellikleri listelenmektedir.The following table lists the standard and custom numeric format specifiers and their associated NumberFormatInfo properties. Belirli bir kültürün sonuç dizesinin görünümünü değiştirmek için NumberFormatInfo özelliklerini değiştirme bölümüne bakın.To change the appearance of the result string for a particular culture, see the Modifying NumberFormatInfo properties section. Bu biçim Belirticilerinin kullanımı hakkındaki ayrıntılar için bkz. Standart sayısal biçim dizeleri ve özel sayısal biçim dizeleri.For details about the use of these format specifiers, see Standard Numeric Format Strings and Custom Numeric Format Strings.

Biçim belirteciFormat specifier İlişkili özelliklerAssociated properties
"C" veya "c" (para birimi biçim Belirleyicisi)"C" or "c" (currency format specifier) CurrencyDecimalDigits, varsayılan kesirli basamak sayısını tanımlamak için.CurrencyDecimalDigits, to define the default number of fractional digits.

ondalık ayırıcı sembolünü tanımlamak için CurrencyDecimalSeparator.CurrencyDecimalSeparator, to define the decimal separator symbol.

grubu veya binlik ayırıcısını tanımlamak için CurrencyGroupSeparator.CurrencyGroupSeparator, to define the group or thousands separator.

integral gruplarının boyutlarını tanımlamak için CurrencyGroupSizes.CurrencyGroupSizes, to define the sizes of integral groups.

negatif para birimi değerlerinin modelini tanımlamak için CurrencyNegativePattern.CurrencyNegativePattern, to define the pattern of negative currency values.

pozitif para birimi değerlerinin modelini tanımlamak için CurrencyPositivePattern.CurrencyPositivePattern, to define the pattern of positive currency values.

para birimi simgesini tanımlamak için CurrencySymbol.CurrencySymbol, to define the currency symbol.

eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.
"D" veya "d" (ondalık biçim Belirleyicisi)"D" or "d" (decimal format specifier) eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.
"E" veya "e" (üs veya bilimsel Biçim Belirleyicisi)"E" or "e" (exponential or scientific format specifier) NegativeSign, Mantis ve üs içindeki negatif işaret sembolünü tanımlamak için.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

ondalık ayırıcı sembolünü tanımlamak için NumberDecimalSeparator.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, üs içinde pozitif işaret sembolünü tanımlamak için.PositiveSign, to define the positive sign symbol in the exponent.
"F" veya "f" (sabit noktalı Biçim Belirleyicisi)"F" or "f" (fixed-point format specifier) eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, varsayılan kesirli basamak sayısını tanımlamak için.NumberDecimalDigits, to define the default number of fractional digits.

ondalık ayırıcı sembolünü tanımlamak için NumberDecimalSeparator.NumberDecimalSeparator, to define the decimal separator symbol.
"G" veya "g" (Genel Biçim Belirleyicisi)"G" or "g" (general format specifier) eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.

ondalık ayırıcı sembolünü tanımlamak için NumberDecimalSeparator.NumberDecimalSeparator, to define the decimal separator symbol.

üstel biçimdeki sonuç dizeleri için pozitif işaret sembolünü tanımlamak için PositiveSign.PositiveSign, to define the positive sign symbol for result strings in exponential format.
"N" veya "n" (sayı Biçim Belirleyicisi)"N" or "n" (number format specifier) eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.

NumberDecimalDigits, varsayılan kesirli basamak sayısını tanımlamak için.NumberDecimalDigits, to define the default number of fractional digits.

ondalık ayırıcı sembolünü tanımlamak için NumberDecimalSeparator.NumberDecimalSeparator, to define the decimal separator symbol.

Grup ayırıcısı (binlerce) sembolünü tanımlamak için NumberGroupSeparator.NumberGroupSeparator, to define the group separator (thousands) symbol.

bir gruptaki integral basamak sayısını tanımlamak için NumberGroupSizes.NumberGroupSizes, to define the number of integral digits in a group.

negatif değerlerin biçimini tanımlamak için NumberNegativePattern.NumberNegativePattern, to define the format of negative values.
"P" veya "p" (yüzde Biçim Belirleyicisi)"P" or "p" (percent format specifier) eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.

PercentDecimalDigits, varsayılan kesirli basamak sayısını tanımlamak için.PercentDecimalDigits, to define the default number of fractional digits.

ondalık ayırıcı sembolünü tanımlamak için PercentDecimalSeparator.PercentDecimalSeparator, to define the decimal separator symbol.

Grup ayırıcı sembolünü tanımlamak için PercentGroupSeparator.PercentGroupSeparator, to define the group separator symbol.

bir gruptaki integral basamak sayısını tanımlamak için PercentGroupSizes.PercentGroupSizes, to define the number of integral digits in a group.

PercentNegativePattern, yüzde sembolünün yerleşimini ve negatif değerler için negatif sembolü tanımlamak için.PercentNegativePattern, to define the placement of the percent symbol and the negative symbol for negative values.

pozitif değerler için yüzde sembolünün yerleşimini tanımlamak üzere PercentPositivePattern.PercentPositivePattern, to define the placement of the percent symbol for positive values.

yüzde simgesini tanımlamak için PercentSymbol.PercentSymbol, to define the percent symbol.
"R" veya "r" (gidiş dönüş Biçim Belirleyicisi)"R" or "r" (round-trip format specifier) eksi işareti simgesini tanımlamak için NegativeSign.NegativeSign, to define the negative sign symbol.

ondalık ayırıcı sembolünü tanımlamak için NumberDecimalSeparator.NumberDecimalSeparator, to define the decimal separator symbol.

PositiveSign, bir üs içinde pozitif işaret sembolünü tanımlamak için.PositiveSign, to define the positive sign symbol in an exponent.
"X" veya "x" (onaltılı Biçim Belirleyicisi)"X" or "x" (hexadecimal format specifier) Yok.None.
"." (Decimal Point özel biçim Belirleyicisi)"." (decimal point custom format specifier) ondalık ayırıcı sembolünü tanımlamak için NumberDecimalSeparator.NumberDecimalSeparator, to define the decimal separator symbol.
"," (Grup ayırıcı özel biçim Belirleyicisi)"," (group separator custom format specifier) Grup (binlerce) ayırıcı sembolünü tanımlamak için NumberGroupSeparator.NumberGroupSeparator, to define the group (thousands) separator symbol.
"%" (yüzde yer tutucu özel biçim Belirleyicisi)"%" (percentage placeholder custom format specifier) yüzde simgesini tanımlamak için PercentSymbol.PercentSymbol, to define the percent symbol.
"‰" (her mille yer tutucu özel biçim Belirleyicisi)"‰" (per mille placeholder custom format specifier) PerMilleSymbol, her mille sembolünü tanımlamak için.PerMilleSymbol, to define the per mille symbol.
"E" (üstel gösterim özel biçim Belirleyicisi)"E" (exponential notation custom format specifier) NegativeSign, Mantis ve üs içindeki negatif işaret sembolünü tanımlamak için.NegativeSign, to define the negative sign symbol in the mantissa and exponent.

PositiveSign, üs içinde pozitif işaret sembolünü tanımlamak için.PositiveSign, to define the positive sign symbol in the exponent.

NumberFormatInfo sınıfının, belirli bir kültür tarafından kullanılan 10 tabanında basamağı belirten bir NativeDigits özelliği içerdiğini unutmayın.Note that the NumberFormatInfo class includes a NativeDigits property that specifies the base 10 digits used by a specific culture. Ancak, özelliği biçimlendirme işlemlerinde kullanılmaz; Sonuç dizesinde yalnızca 0 (u + 0030) ile 9 arasındaki (u + 0039) temel Latin rakamları kullanılır.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. Ayrıca, NaN, PositiveInfinityve NegativeInfinitySingle ve Double değerleri için, sonuç dizesi sırasıyla NaNSymbol, PositiveInfinitySymbolve NegativeInfinitySymbol özellikleri tarafından tanımlanan simgelerden oluşur.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.

NumberFormatInfo özelliklerini değiştirmeModifying NumberFormatInfo properties

Sayısal biçimlendirme işleminde üretilen sonuç dizesini özelleştirmek için bir NumberFormatInfo nesnesinin özelliklerini değiştirebilirsiniz.You can modify the properties of a NumberFormatInfo object to customize the result string produced in a numeric formatting operation. Bunu yapmak için:To do this:

  1. Biçimlendirme kurallarını değiştirmek istediğiniz NumberFormatInfo nesnenin okuma/yazma kopyasını oluşturun.Create a read/write copy of a NumberFormatInfo object whose formatting conventions you want to modify. Daha fazla bilgi için NumberFormatInfo nesnesini örnekleme bölümüne bakın.For more information, see the Instantiating a NumberFormatInfo object section.

  2. İstenen sonuç dizesini oluşturmak için kullanılan özelliği veya özellikleri değiştirin.Modify the property or properties that are used to produce the desired result string. Biçimlendirme yöntemlerinin sonuç dizelerini tanımlamak için NumberFormatInfo özellikleri nasıl kullandığını öğrenmek için, Biçim dizeleri ve NumberFormatInfo özellikleri bölümüne bakın.For information about how formatting methods use NumberFormatInfo properties to define result strings, see the Format strings and NumberFormatInfo properties section.

  3. Biçimlendirme yöntemlerine yapılan çağrılar içinde IFormatProvider bağımsız değişkeni olarak özel NumberFormatInfo nesnesini kullanın.Use the custom NumberFormatInfo object as the IFormatProvider argument in calls to formatting methods.

Not

Bir uygulama her başlatıldığında bir kültürün özellik değerlerini dinamik olarak değiştirmek yerine, özel bir kültür (benzersiz bir ada sahip olan ve var olan kültürleri tamamlayan kültür) ya da bir değiştirme kültürü (belirli bir kültür yerine kullanılan bir kültür) tanımlamak için CultureAndRegionInfoBuilder sınıfını kullanabilirsiniz.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).

Aşağıdaki bölümlerde bazı örnekler sağlanmaktadır.The following sections provide some examples.

Para birimi simgesini ve desenini değiştirmeModifying the currency symbol and pattern

Aşağıdaki örnek, en-US kültürün biçimlendirme kurallarını temsil eden bir NumberFormatInfo nesnesini değiştirir.The following example modifies a NumberFormatInfo object that represents the formatting conventions of the en-US culture. ISO-4217 para birimi sembolünü CurrencySymbol özelliğine atar ve para birimi simgesi ve ardından bir boşluk ve sayısal değer gelen para birimi değerleri için bir kalıp tanımlar.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

Ulusal kimlik numarası biçimlendirmeFormatting a national identification number

Birçok ulusal tanımlama numarası yalnızca rakamlardan oluşur ve bu nedenle, NumberFormatInfo nesnesinin özellikleri değiştirilerek kolayca biçimlendirilebilir.Many national identification numbers consist exclusively of digits and so can easily be formatted by modifying the properties of a NumberFormatInfo object. Örneğin, Birleşik Devletler sosyal güvenlik numarası aşağıdaki şekilde düzenlenmiş 9 basamaktan oluşur: XXX-XX-XXXX.For example, a social security number in the United States consists of 9 digits arranged as follows: XXX-XX-XXXX. Aşağıdaki örnek, sosyal güvenlik numaralarının tamsayı değerleri olarak depolandığını ve bunları uygun şekilde biçimlendirdiğinizi varsayar.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

Sayısal dizeleri ayrıştırmaParsing numeric strings

Ayrıştırma, bir sayının dize gösterimini sayıya dönüştürmeyi içerir.Parsing involves converting the string representation of a number to a number. .NET Framework her bir sayısal tür, iki aşırı yüklenmiş ayrıştırma yöntemi içerir: Parse ve TryParse.Each numeric type in the .NET Framework includes two overloaded parsing methods: Parse and TryParse. Parse yöntemi bir dizeyi sayıya dönüştürür ve dönüştürme başarısız olursa bir özel durum oluşturur.The Parse method converts a string to a number and throws an exception if the conversion fails. TryParse yöntemi bir dizeyi sayıya dönüştürür, sayıyı bir out bağımsız değişkenine atar ve dönüştürmenin başarılı olup olmadığını gösteren bir Boolean değeri döndürür.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.

Ayrıştırma işlemi başarılı olursa, hangi stil öğelerinin (örneğin, Grup ayırıcıları, ondalık ayırıcısı veya para birimi simgesi) bir dizede bulunabilir olduğunu belirlemek için NumberStyles numaralandırma değerini örtülü olarak veya açıkça kullanın.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. Yöntem çağrısında bir NumberStyles değeri sağlanmazsa, varsayılan değer, ayrıştırılmış dizenin Grup sembolleri, ondalık ayırıcı, eksi işareti ve boşluk karakterlerinden dahil edileceğini belirten Float ve AllowThousands bayraklarını içeren bir NumberStyles değeridir veya üstel gösterimde bir sayının dize gösterimi olabilir.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.

Ayrıştırma yöntemleri Ayrıca, ayrıştırılacak dizede gerçekleşebileceğini belirli sembolleri ve desenleri tanımlayan bir NumberFormatInfo nesnesini örtülü olarak veya açıkça kullanır.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. NumberFormatInfo nesne sağlanmazsa, varsayılan değer geçerli iş parçacığı kültürü için NumberFormatInfo.If a NumberFormatInfo object is not provided, the default is the NumberFormatInfo for the current thread culture. Ayrıştırma hakkında daha fazla bilgi için, Int16.Parse(String), Int32.Parse(String, NumberStyles), Int64.Parse(String, IFormatProvider), Decimal.Parse(String, NumberStyles, IFormatProvider), Double.TryParse(String, Double)ve BigInteger.TryParse(String, NumberStyles, IFormatProvider, BigInteger)gibi bireysel ayrıştırma yöntemlerine bakın.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).

Aşağıdaki örnek, dizelerin ayrıştırılmasındaki kültürün duyarlı yapısını gösterir.The following example illustrates the culture-sensitive nature of parsing strings. En-US, fr-FR ve sabit kültürlerin kurallarını kullanarak binlik ayırıcıları içeren bir dizeyi ayrıştırmaya çalışır.It tries to parse a string that include thousands separators by using the conventions of the en-US, fr-FR, and invariant cultures. Bir grup ayırıcısı olarak virgül içeren bir dize ve bir ondalık ayırıcısı olarak nokta, fr-FR kültürüne ayrıştırılamaz ve bir grup ayırıcısı olarak boşluk içeren bir dize ve ondalık ayırıcı olarak virgül, en-US ve sabit kültürlerde ayrıştırılamaz.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)

Ayrıştırma genellikle iki bağlamda oluşur:Parsing generally occurs in two contexts:

  • Kullanıcı girişini sayısal bir değere dönüştürmek için tasarlanan bir işlem.As an operation that is designed to convert user input into a numeric value.

  • Sayısal bir değere gidiş dönüş için tasarlanan bir işlem olarak; diğer bir deyişle, daha önce bir dize olarak serileştirilmiş bir sayısal değerin serisini kaldırmak için.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.

Aşağıdaki bölümlerde bu iki işlem daha ayrıntılı bir şekilde ele alınmaktadır.The following sections discuss these two operations in greater detail.

Kullanıcı dizelerini ayrıştırmaParsing user strings

Kullanıcı tarafından girilen sayısal dizeleri ayrıştırdığınızda, kullanıcının kültürel ayarlarını yansıtan bir NumberFormatInfo nesnesi örneğini her zaman oluşturmalısınız.When you are parsing numeric strings input by the user, you should always instantiate a NumberFormatInfo object that reflects the user's cultural settings. Kullanıcı özelleştirmelerini yansıtan bir NumberFormatInfo nesnesinin örneği oluşturma hakkında bilgi için, NumberFormatInfo ve Dynamic Data bölümüne bakın.For information about how to instantiate a NumberFormatInfo object that reflects user customizations, see the NumberFormatInfo and dynamic data section.

Aşağıdaki örnek, Kullanıcı kültürel ayarlarını ve olmayan birini yansıtan bir ayrıştırma işlemi arasındaki farkı gösterir.The following example illustrates the difference between a parsing operation that reflects user cultural settings and one that does not. Bu durumda, varsayılan sistem kültürü en-US olur, ancak Kullanıcı, Denetim Masası 'nda, bölge ve diliçinde Grup ayırıcısı olarak "," öğesini ondalık sembol ve "." olarak tanımlamıştır.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. Normalde, bu semboller varsayılan en-US kültürüne ters çevrilir.Ordinarily, these symbols are reversed in the default en-US culture. Kullanıcı, Kullanıcı ayarlarını yansıtan bir dize girdiğinde ve dize aynı zamanda Kullanıcı ayarlarını (geçersiz kılmalar) yansıtan bir NumberFormatInfo nesnesi tarafından ayrıştırıldığında, ayrıştırma işlemi doğru bir sonuç döndürür.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. Ancak, dize standart en-US kültürel ayarlarını yansıtan bir NumberFormatInfo nesnesi tarafından ayrıştırıldığında, bir grup ayırıcısı için virgül simgesine hata verir ve yanlış bir sonuç döndürür.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

Sayısal verileri serileştirme ve seri durumundan çıkarmaSerializing and deserializing numeric data

Sayısal veriler dize biçiminde serileştirildiğinde ve daha sonra seri durumdan çıkarılan ve ayrıştırıldığında, dizeler sabit kültürün kuralları kullanılarak oluşturulup ayrıştırılmalıdır.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. Biçimlendirme ve ayrıştırma işlemleri, belirli bir kültürün kurallarını hiçbir şekilde yansıtmamalıdır.The formatting and parsing operations should never reflect the conventions of a specific culture. Kültüre özgü ayarlar kullanılıyorsa, verilerin taşınabilirliği kesinlikle sınırlı olur; yalnızca kültüre özgü ayarları, serileştirildiği iş parçacığından özdeş olan bir iş parçacığında, başarıyla seri hale getirilebilir.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. Bazı durumlarda bu, verilerin serileştirildiği aynı sistem üzerinde bile başarılı bir şekilde seri durumdan çıkarılamayacağı anlamına gelir.In some cases, this means that the data cannot even be successfully deserialized on the same system on which it was serialized.

Aşağıdaki örnek, bu ilke ihlal edildiğinde neler olabileceğini gösterir.The following example illustrates what can happen when this principle is violated. Bir dizideki kayan nokta değerleri, geçerli iş parçacığı en-US kültürünün kültüre özgü ayarlarını kullandığında dizelere dönüştürülür.Floating-point values in an array are converted to strings when the current thread uses the culture-specific settings of the en-US culture. Daha sonra veriler, en-GB kültürün kültüre özgü ayarlarını kullanan bir iş parçacığı tarafından ayrıştırılır.The data is then parsed by a thread that uses the culture-specific settings of the en-GB culture. Bu durumda, her ayrıştırma işlemi başarılı olsa da veriler başarıyla geri dönmez ve veri bozulması oluşur.In this case, although each parsing operation succeeds, the data does not round-trip successfully and data corruption occurs. Diğer durumlarda, bir ayrıştırma işlemi başarısız olabilir ve FormatException bir özel durum oluşturulabilir.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

Oluşturucular

NumberFormatInfo()

Kültüre bağımsız (Sabit) olan NumberFormatInfo sınıfının yeni yazılabilir bir örneğini başlatır.Initializes a new writable instance of the NumberFormatInfo class that is culture-independent (invariant).

Özellikler

CurrencyDecimalDigits

Para birimi değerlerinde kullanılacak ondalık basamak sayısını alır veya ayarlar.Gets or sets the number of decimal places to use in currency values.

CurrencyDecimalSeparator

Para birimi değerlerinde ondalık ayırıcı olarak kullanılacak dizeyi alır veya ayarlar.Gets or sets the string to use as the decimal separator in currency values.

CurrencyGroupSeparator

Para birimi değerlerinde ondalık basamak gruplarının soluna ayıran dizeyi alır veya ayarlar.Gets or sets the string that separates groups of digits to the left of the decimal in currency values.

CurrencyGroupSizes

Para birimi değerlerinde ondalık sayının solunda bulunan her bir gruptaki basamak sayısını alır veya ayarlar.Gets or sets the number of digits in each group to the left of the decimal in currency values.

CurrencyNegativePattern

Negatif para birimi değerleri için biçim stilini alır veya ayarlar.Gets or sets the format pattern for negative currency values.

CurrencyPositivePattern

Pozitif para birimi değerlerinin biçim stilini alır veya ayarlar.Gets or sets the format pattern for positive currency values.

CurrencySymbol

Para birimi simgesi olarak kullanılacak dizeyi alır veya ayarlar.Gets or sets the string to use as the currency symbol.

CurrentInfo

Değerleri geçerli kültür temelinde biçimlendiren salt okunurdur NumberFormatInfo alır.Gets a read-only NumberFormatInfo that formats values based on the current culture.

DigitSubstitution

Grafik Kullanıcı arabiriminin bir basamak şeklini nasıl görüntülediğini belirten bir değer alır veya ayarlar.Gets or sets a value that specifies how the graphical user interface displays the shape of a digit.

InvariantInfo

Kültüre bağımsız (Sabit) bir salt okunurdur NumberFormatInfo nesnesi alır.Gets a read-only NumberFormatInfo object that is culture-independent (invariant).

IsReadOnly

Bu NumberFormatInfo nesnesinin salt okunurdur olup olmadığını gösteren bir değer alır.Gets a value that indicates whether this NumberFormatInfo object is read-only.

NaNSymbol

IEEE NaN (sayı değil) değerini temsil eden dizeyi alır veya ayarlar.Gets or sets the string that represents the IEEE NaN (not a number) value.

NativeDigits

0 ile 9 arasındaki Batı rakamlarının eşdeğeri olan yerel basamakların dize dizisini alır veya ayarlar.Gets or sets a string array of native digits equivalent to the Western digits 0 through 9.

NegativeInfinitySymbol

Negatif sonsuzu temsil eden dizeyi alır veya ayarlar.Gets or sets the string that represents negative infinity.

NegativeSign

İlişkili sayının negatif olduğunu belirten dizeyi alır veya ayarlar.Gets or sets the string that denotes that the associated number is negative.

NumberDecimalDigits

Sayısal değerlerde kullanılacak ondalık basamak sayısını alır veya ayarlar.Gets or sets the number of decimal places to use in numeric values.

NumberDecimalSeparator

Sayısal değerlerde ondalık ayırıcı olarak kullanılacak dizeyi alır veya ayarlar.Gets or sets the string to use as the decimal separator in numeric values.

NumberGroupSeparator

Sayısal değerlerde ondalık basamak gruplarının solunda bulunan basamak gruplarını ayıran dizeyi alır veya ayarlar.Gets or sets the string that separates groups of digits to the left of the decimal in numeric values.

NumberGroupSizes

Her bir gruptaki basamak sayısını sayısal değerlerde ondalık değerlerin solunda alır veya ayarlar.Gets or sets the number of digits in each group to the left of the decimal in numeric values.

NumberNegativePattern

Negatif sayısal değerler için biçim stilini alır veya ayarlar.Gets or sets the format pattern for negative numeric values.

PercentDecimalDigits

Yüzde değerlerinde kullanılacak ondalık basamak sayısını alır veya ayarlar.Gets or sets the number of decimal places to use in percent values.

PercentDecimalSeparator

Yüzde değerleri içinde ondalık ayırıcı olarak kullanılacak dizeyi alır veya ayarlar.Gets or sets the string to use as the decimal separator in percent values.

PercentGroupSeparator

Ondalık basamak gruplarını yüzde değerleri cinsinden ondalık basamak sola ayıran dizeyi alır veya ayarlar.Gets or sets the string that separates groups of digits to the left of the decimal in percent values.

PercentGroupSizes

Yüzde değerleri içinde ondalık sayının solunda her bir gruptaki basamakların sayısını alır veya ayarlar.Gets or sets the number of digits in each group to the left of the decimal in percent values.

PercentNegativePattern

Negatif yüzde değerlerinin biçim stilini alır veya ayarlar.Gets or sets the format pattern for negative percent values.

PercentPositivePattern

Pozitif yüzde değerlerinin biçim stilini alır veya ayarlar.Gets or sets the format pattern for positive percent values.

PercentSymbol

Yüzde simgesi olarak kullanılacak dizeyi alır veya ayarlar.Gets or sets the string to use as the percent symbol.

PerMilleSymbol

Frele başına simge olarak kullanılacak dizeyi alır veya ayarlar.Gets or sets the string to use as the per mille symbol.

PositiveInfinitySymbol

Pozitif sonsuz temsil eden dizeyi alır veya ayarlar.Gets or sets the string that represents positive infinity.

PositiveSign

İlişkili sayının pozitif olduğunu belirten dizeyi alır veya ayarlar.Gets or sets the string that denotes that the associated number is positive.

Yöntemler

Clone()

NumberFormatInfo nesnesinin basit bir kopyasını oluşturur.Creates a shallow copy of the NumberFormatInfo object.

Equals(Object)

Belirtilen nesnenin geçerli nesneyle eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetFormat(Type)

Belirtilen türde bir sayı biçimlendirme hizmeti sağlayan bir nesne alır.Gets an object of the specified type that provides a number formatting service.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetInstance(IFormatProvider)

Belirtilen IFormatProviderilişkili NumberFormatInfo alır.Gets the NumberFormatInfo associated with the specified IFormatProvider.

GetType()

Geçerli örneğin Type alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
MemberwiseClone()

Geçerli Objectbasit bir kopyasını oluşturur.Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
ReadOnly(NumberFormatInfo)

Salt okunurdur NumberFormatInfo sarmalayıcı döndürür.Returns a read-only NumberFormatInfo wrapper.

ToString()

Geçerli nesneyi temsil eden bir dize döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)

Şunlara uygulanır

Ayrıca bkz.