Standardowe ciągi formatujące liczby

Ciągi standardowych formatów liczb służą do formatowania popularnych typów liczbowych. Standardowy ciąg formatu liczbowego ma postać [format specifier][precision specifier], gdzie:

  • Specyfikator formatu to pojedynczy znak alfabetyczny, który określa typ formatu liczbowego, na przykład walutę lub procent. Dowolny ciąg formatu liczb, który zawiera więcej niż jeden znak alfabetyczny, w tym znak odstępu, jest interpretowany jako ciąg niestandardowego formatu liczb. Aby uzyskać więcej informacji, zobacz Niestandardowe ciągi formatu liczbowego.

  • Specyfikator dokładności to opcjonalna liczba całkowita, która wpływa na liczbę cyfr w wynikowym ciągu. W wersjach .NET 7 i nowszych maksymalna dokładność wynosi 999 999 999 999 999. Na platformie .NET 6 maksymalna wartość dokładności to Int32.MaxValue. W poprzednich wersjach platformy .NET dokładność może wahać się od 0 do 99. Specyfikator dokładności określa liczbę cyfr w ciągu reprezentującym liczbę. Nie zaokrągla samej liczby. Aby wykonać operację zaokrąglania, użyj Math.Ceilingmetody , Math.Floorlub Math.Round .

    Gdy specyfikator dokładności kontroluje liczbę cyfr ułamkowych w ciągu wynikowym, ciąg wynikowy odzwierciedla liczbę zaokrągloną do możliwego do reprezentowania wyniku najbliższego nieskończonie precyzyjnego wyniku. Jeśli istnieją dwa równie zbliżone do reprezentowania wyniki:

    • W .NET Framework i .NET Core do platformy .NET Core 2.0 środowisko uruchomieniowe wybiera wynik z najmniej znaczącą cyfrą (czyli przy użyciu polecenia MidpointRounding.AwayFromZero).
    • W programie .NET Core 2.1 lub nowszym środowisko uruchomieniowe wybiera wynik z co najmniej znaczącą cyfrą (czyli przy użyciu polecenia MidpointRounding.ToEven).

    Uwaga

    Specyfikator dokładności określa liczbę cyfr w ciągu wynikowym. Aby utworzyć ciąg wynikowy z spacjami wiodącymi lub końcowymi, użyj funkcji formatowania złożonego i zdefiniuj składnik wyrównania w elemencie formatu.

Standardowe ciągi formatu liczbowego są obsługiwane przez:

Porada

Możesz pobrać narzędzie formatowania, aplikację platformy .NET Core Windows Forms, która umożliwia stosowanie ciągów formatu do wartości liczbowych lub daty i godziny oraz wyświetlania ciągu wynikowego. Kod źródłowy jest dostępny dla języka C# i Visual Basic.

Specyfikatory formatu standardowego

W poniższej tabeli opisano standardowe specyfikatory formatu liczbowego i przedstawiono przykładowe dane wyjściowe generowane przez każdy specyfikator formatu. Aby uzyskać dodatkowe informacje na temat używania standardowych ciągów formatu liczbowego, zobacz sekcjęPrzykładowy kod , aby uzyskać kompleksową ilustrację ich użycia.

Wynik sformatowanego ciągu dla określonej kultury może się różnić od poniższych przykładów. Ustawienia systemu operacyjnego, ustawienia użytkownika, zmienne środowiskowe i używana wersja platformy .NET mogą mieć wpływ na format. Na przykład, począwszy od platformy .NET 5, platforma .NET próbuje ujednolicić formaty kulturowe na różnych platformach. Aby uzyskać więcej informacji, zobacz Globalizacja platformy .NET i ICU.

Specyfikator formatu Nazwa Opis Przykłady
„C” lub „c” Waluta Wynik: wartość waluty.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.CurrencyDecimalDigits.

Więcej informacji: Specyfikator formatu waluty ("C").
123.456 ("C", en-US)
-> \$123.46

123.456 ("C", fr-FR)
-> 123,46 €

123.456 ("C", ja-JP)
-> {123

-123.456 ("C3", en-US)
-> (\$123.456)

-123.456 ("C3", fr-FR)
-> -123,456 €

-123.456 ("C3", ja-JP)
-> -~123.456
„D” lub „d” Liczba dziesiętna Wynik: liczby całkowite z opcjonalnym znakiem minus.

Obsługiwane przez: tylko typy całkowite.

Specyfikator dokładności: minimalna liczba cyfr.

Domyślny specyfikator dokładności: minimalna liczba wymaganych cyfr.

Więcej informacji: Specyfikator formatu dziesiętnego("D").
1234 ("D")
-> 1234

-1234 ("D6")
-> -001234
„E” lub „e” Wartość wykładnicza (naukowa) Wynik: zapis wykładniczy.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr dziesiętnych.

Domyślny specyfikator dokładności: 6.

Więcej informacji: Specyfikator formatu wykładniczego ("E").
1052.032912756 ("E", en-US)
-> 1.052033E+003

1052.032912756 ("e", fr-FR)
-> 1052033e+003

-1052.032912756 ("e2", en-US)
-> -1.05e+003

-1052.032912756 ("E2", fr-FR)
-> -1,05E+003
„F” lub „f” Wartość stałoprzecinkowa Wynik: cyfry całkowite i dziesiętne z opcjonalnym znakiem minus.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.NumberDecimalDigits.

Więcej informacji: Specyfikator formatu Fixed-Point ("F").
1234.567 ("F", en-US)
-> 1234.57

1234.567 ("F", de-DE)
-> 1234,57

1234 ("F1", en-US)
-> 1234.0

1234 ("F1", de-DE)
-> 1234,0

-1234.56 ("F4", en-US)
-> -1234.5600

-1234.56 ("F4", de-DE)
-> -1234,5600
„G” lub „g” Ogólne Wynik: Bardziej kompaktowanie notacji o stałym punkcie lub notacji naukowej.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: liczba cyfr znaczących.

Domyślny specyfikator dokładności: zależy od typu liczbowego.

Więcej informacji: Specyfikator formatu ogólnego ("G").
-123.456 ("G", en-US)
-> -123.456

-123.456 ("G", sv-SE)
-> -123,456

123.4546 ("G4", en-US)
-> 123.5

123.4546 ("G4", sv-SE)
-> 123,5

-1.234567890e-25 ("G", en-US)
-> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE)
-> -1,23456789E-25
„N” lub „n” Liczba Wynik: cyfry całkowite i dziesiętne, separatory grup i separator dziesiętny z opcjonalnym znaku minus.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: wymagana liczba miejsc dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.NumberDecimalDigits.

Więcej informacji: Specyfikator formatu liczbowego ("N").
1234.567 ("N", en-US)
-> 1,234,57

1234.567 ("N", ru-RU)
-> 1 234 57

1234 ("N1", en-US)
-> 1,234.0

1234 ("N1", ru-RU)
-> 1 234,0

-1234.56 ("N3", en-US)
> - -1,234,560

-1234.56 ("N3", ru-RU)
-> -1 234,560
„P” lub „p” Procent Wynik: liczba pomnożona przez 100 i wyświetlana z symbolem procentu.

Obsługiwany przez: wszystkie typy liczbowe.

Specyfikator dokładności: wymagana liczba miejsc dziesiętnych.

Domyślny specyfikator dokładności: zdefiniowany przez NumberFormatInfo.PercentDecimalDigits.

Więcej informacji: Specyfikator formatu Procent ("P").
1 ("P", en-US)
-> 100,00 %

1 ("P", fr-FR)
-> 100,00 %

-0.39678 ("P1", en-US)
-> -39,7 %

-0.39678 ("P1", fr-FR)
> - -39,7 %
„R” lub „r” Wartość dwustronna Wynik: ciąg, który można dwustronnie konwertować na identyczny numer.

Obsługiwane przez: Single, Doublei BigInteger.

Uwaga: zalecane tylko dla BigInteger typu. W przypadku Double typów użyj wartości "G17"; w przypadku Single typów użyj ciągu "G9".
Specyfikator dokładności: ignorowany.

Więcej informacji: Specyfikator formatu round-trip ("R").
123456789.12345678 ("R")
-> 123456789.12345678

-1234567890.12345678 ("R")
-> -1234567890.1234567
„X” lub „x” Wartość szesnastkowa Wynik: ciąg szesnastkowy.

Obsługiwane przez: tylko typy całkowite.

Specyfikator dokładności: liczba cyfr w ciągu wynikowym.

Więcej informacji: Specyfikator formatu szesnastkowego ("X").
255 ("X")
-> FF

-1 ("x")
-> ff

255 ("x4")
-> 00ff

-1 ("X4")
-> 00FF
Jakikolwiek inny pojedynczy znak Nieznany specyfikator Wynik: zgłasza błąd FormatException w czasie wykonywania.

Używanie standardowych ciągów formatu liczbowego

Uwaga

Przykłady języka C# w tym artykule są uruchamiane w Try.NET wbudowanym modułem uruchamiającym kod i placem zabaw. Wybierz przycisk Uruchom , aby uruchomić przykład w oknie interaktywnym. Po wykonaniu kodu można go zmodyfikować i uruchomić zmodyfikowany kod, wybierając ponownie pozycję Uruchom . Zmodyfikowany kod jest uruchamiany w oknie interaktywnym lub w przypadku niepowodzenia kompilacji okno interaktywne wyświetla wszystkie komunikaty o błędach kompilatora języka C#.

Standardowy ciąg formatu liczbowego może służyć do definiowania formatowania wartości liczbowej na jeden z następujących sposobów:

  • Można go przekazać do TryFormat metody lub przeciążenia ToString metody, która ma format parametr. Poniższy przykład formatuje wartość liczbową jako ciąg waluty w bieżącej kulturze (w tym przypadku kultura en-US).

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))
    ' Displays $123.46
    
  • Można go podać jako formatString argument w elemencie formatu używanym z takimi metodami jak String.Format, Console.WriteLinei StringBuilder.AppendFormat. Aby uzyskać więcej informacji, zobacz Formatowanie złożone. W poniższym przykładzie element formatu jest używany do wstawienia wartości waluty w ciągu.

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    decimal value = 123.456m;
    Console.WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    Dim value As Decimal = 123.456d
    Console.WriteLine("Your account balance is {0:C2}.", value)
    ' Displays "Your account balance is $123.46."
    

    Opcjonalnie możesz podać alignment argument, aby określić szerokość pola liczbowego i określić, czy jego wartość jest wyrównana w prawo, czy w lewo. Poniższy przykład wyrównuje wartość waluty w polu 28 znaków i wyrównuje wartość waluty w polu 14-znakowym.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                                static_cast<Decimal>(18794.16) };
    Console::WriteLine("   Beginning Balance           Ending Balance");
    Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    decimal[] amounts = { 16305.32m, 18794.16m };
    Console.WriteLine("   Beginning Balance           Ending Balance");
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16
    
    Dim amounts() As Decimal = {16305.32d, 18794.16d}
    Console.WriteLine("   Beginning Balance           Ending Balance")
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
    ' Displays:
    '        Beginning Balance           Ending Balance
    '        $16,305.32                      $18,794.16      
    
  • Można go podać jako formatString argument w elemencie wyrażenia interpolowanego ciągu interpolowanego. Aby uzyskać więcej informacji, zobacz artykuł Interpolacja ciągów w dokumentacji języka C# lub artykuł Ciągi interpolowane w dokumentacji języka Visual Basic.

Poniższe sekcje zawierają szczegółowe informacje o poszczególnych ciągach standardowego formatu liczb.

Specyfikator formatu waluty (C)

Specyfikator formatu C (currency) konwertuje liczbę na ciąg przedstawiający kwotę w walucie. Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych w wynikowym ciągu. Jeśli specyfikator dokładności zostanie pominięty, domyślna precyzja jest definiowana przez NumberFormatInfo.CurrencyDecimalDigits właściwość .

Jeśli wartość do sformatowania ma więcej miejsc dziesiętnych niż określona lub domyślna liczba miejsc dziesiętnych, wartość ułamkowa zostanie zaokrąglona w wynikowym ciągu. Jeśli wartość na prawo od określonej liczby miejsc dziesiętnych wynosi 5 lub więcej, ostatnia cyfra w ciągu wynikowym jest zaokrąglana w kierunku od zera.

Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie zwracanego ciągu.

Właściwość NumberFormatInfo Opis
CurrencyPositivePattern Definiuje położenie symbolu waluty dla wartości dodatnich.
CurrencyNegativePattern Definiuje położenie symbolu waluty dla wartości ujemnych i określa, czy znak ujemny jest reprezentowany przez nawiasy, czy NegativeSign właściwość.
NegativeSign Definiuje znak ujemny używany, jeśli CurrencyNegativePattern wskazuje, że nawiasy nie są używane.
CurrencySymbol Definiuje symbol waluty.
CurrencyDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych w wartości waluty. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.
CurrencyDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry dziesiętne.
CurrencyGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
CurrencyGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się w grupie.

Poniższy przykład formatuje Double wartość z specyfikatorem formatu waluty:

double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", 
                  CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3",
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Specyfikator formatu dziesiętnego (D)

Specyfikator formatu D (decimal) konwertuje liczbę na ciąg cyfr dziesiętnych (0–9), poprzedzony znakiem minus, jeśli liczba jest ujemna. Ten format jest obsługiwany tylko w przypadku typów całkowitych.

Specyfikator dokładności określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności. Jeśli nie zostanie określony specyfikator dokładności, wartością domyślną jest wartość minimalna wymagana do przedstawienia wartości całkowitej bez zer wiodących.

Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. Jak pokazano w poniższej tabeli, jedna właściwość ma wpływ na formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.

Poniższy przykład formatuje Int32 wartość z specyfikatorem formatu dziesiętnego.

int value; 

value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345
int value;

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345
Dim value As Integer

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Specyfikator formatu wykładniczego (E)

Specyfikator formatu wykładniczego („E”) konwertuje liczbę na ciąg w postaci „-d,ddd...E + ddd” lub „-d,ddd...e+ddd”, gdzie każda litera „d” wskazuje cyfrę (0–9). Ciąg rozpoczyna się od znaku minus, jeśli liczba jest ujemna. Zawsze dokładnie jedna cyfra poprzedza punkt dziesiętny.

Specyfikator dokładności określa żądaną liczbę cyfr po punkcie dziesiętnym. Jeśli specyfikator dokładności zostanie pominięty, domyślnie będzie używanych sześć cyfr po punkcie dziesiętnym.

Wielkość liter specyfikatora formatu wskazuje, czy wykładnik potęgi ma być poprzedzany prefiksem „E”, czy „e”. Wykładnik zawsze składa się ze znaku plus lub minus i co najmniej trzech cyfr. W razie potrzeby wykładnik jest dopełniany zerami w celu spełnienia tego minimum.

Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie zwracanego ciągu.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna zarówno dla współczynnika, jak i wykładnika.
NumberDecimalSeparator Określa ciąg oddzielający cyfry całkowite od cyfr dziesiętnych we współczynniku.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.

Poniższy przykład formatuje Double wartość z specyfikatorem formatu wykładniczego:

double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004

Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004

Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004

Console::WriteLine(value.ToString("E", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Specyfikator formatu stałego punktu (F)

Specyfikator formatu o stałym punkcie ("F") konwertuje liczbę na ciąg formularza "-ddd.dddd..." gdzie każdy znak "d" wskazuje cyfrę (0–9). Ciąg rozpoczyna się od znaku minus, jeśli liczba jest ujemna.

Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych. Jeśli specyfikator dokładności zostanie pominięty, bieżąca NumberFormatInfo.NumberDecimalDigits właściwość dostarcza precyzję liczbową.

Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono właściwości NumberFormatInfo obiektu, który kontroluje formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
NumberDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.

Poniższy przykład formatuje Double wartość i Int32 z specyfikatorem formatu stałego punktu:

int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F", 
                  CultureInfo::InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3", 
                  CultureInfo::InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19

Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));  
// Displays -1898300.2

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F",
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3",
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3",
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199                        

Specyfikator formatu ogólnego (G)

Specyfikator formatu ogólnego ("G") konwertuje liczbę na bardziej kompaktowaną notację o stałym punkcie lub notacji naukowej, w zależności od typu liczby i tego, czy specyfikator dokładności jest obecny. Specyfikator dokładności określa maksymalną liczbę cyfr znaczących, które mogą być wyświetlane w ciągu wynikowym. Jeżeli specyfikator dokładności zostanie pominięty lub będzie równy zero, typ liczby określa dokładność domyślną, tak jak opisano w poniższej tabeli.

Typ liczbowy Dokładność domyślna
Byte lub SByte 3 cyfry
Int16 lub UInt16 5 cyfr
Int32 lub UInt32 10 cyfr
Int64 19 cyfr
UInt64 20 cyfr
BigInteger Nieograniczona (taka sama jak "R")
Half 3 cyfry
Single 7 cyfr
Double 15 cyfr
Decimal 29 cyfr

Notacja stałoprzecinkowa jest używana, jeśli wykładnik, który byłby wynikiem wyrażenia liczby w notacji wykładniczej, jest większy niż -5 i mniejszy niż specyfikator dokładności. W przeciwnym wypadku jest używana notacja wykładnicza. Wynik zawiera punkt dziesiętny, jeśli jest to wymagane, a zera końcowe po punkcie dziesiętnym są pomijane. Jeśli specyfikator dokładności jest obecny i liczba cyfr znaczących w wyniku przekracza określoną dokładność, nadmiarowe cyfry końcowe są usuwane przez zaokrąglenie.

Jeśli jednak liczba jest Decimal liczbą i specyfikator dokładności zostanie pominięty, notacja o stałym punkcie jest zawsze używana, a końcowe zera są zachowywane.

Jeśli jest używana notacja wykładnicza, wykładnik w wyniku otrzymuje prefiks „E”, jeśli specyfikatorem formatu jest „G”, lub „e”, jeśli specyfikatorem formatu jest „g”. Wykładnik zawiera co najmniej dwie cyfry. Różni się to od formatu notacji wykładniczej tworzonej przez specyfikator formatu wykładniczego, który obejmuje co najmniej trzy cyfry wykładnika.

W przypadku użycia z wartością Double specyfikator formatu "G17" gwarantuje, że oryginalna Double wartość została pomyślnie zaokrąglony. Dzieje się tak, ponieważ Double jest to liczba zmiennoprzecinkowa zgodna ze standardem IEEE 754-2008 o podwójnej precyzji (binary64), która daje do 17 znaczących cyfr dokładności. W .NET Framework zalecamy użycie go zamiast specyfikatora formatu "R", ponieważ w niektórych przypadkach "R" nie można pomyślnie zaokrąglić dwuprzecinkowych wartości zmiennoprzecinkowych o podwójnej precyzji.

W przypadku użycia z wartością Single specyfikator formatu "G9" gwarantuje, że oryginalna Single wartość została pomyślnie zaokrąglony. Wynika to z faktu Single , że jest to liczba zmiennoprzecinkowa zgodna ze standardem IEEE 754-2008 z jedną precyzją (binary32), która daje do dziewięciu znaczących cyfr precyzji. Ze względów wydajności zalecamy użycie go zamiast specyfikatora formatu "R".

Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.

Poniższy przykład formatuje zasortowane wartości zmiennoprzecinkowe z ogólnym specyfikatorem formatu:

double number;

number = 12345.6789;      
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays  12345.6789
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console::WriteLine(number.ToString("G7", CultureInfo::InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 2.3E-06       
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 0.0023

number = 1234;
Console::WriteLine(number.ToString("G2", CultureInfo::InvariantCulture));
// Displays 1.2E+03

number = Math::PI;
Console::WriteLine(number.ToString("G5", CultureInfo::InvariantCulture));
// Displays 3.1416    
double number;

number = 12345.6789;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06
Console.WriteLine(number.ToString("G",
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416
Dim number As Double

number = 12345.6789
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789

Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416    

Specyfikator formatu liczbowego (N)

Specyfikator formatu liczbowego („N”) konwertuje liczbę na ciąg w postaci „-d ddd ddd,ddd…”, gdzie „-” oznacza w razie potrzeby liczbę ujemną, „d” oznacza cyfrę (0–9), „ ” oznacza separator grupy, a „,” oznacza symbol punktu dziesiętnego. Specyfikator dokładności określa żądaną liczbę cyfr po punkcie dziesiętnym. Jeśli specyfikator dokładności zostanie pominięty, liczba miejsc dziesiętnych jest definiowana przez bieżącą NumberFormatInfo.NumberDecimalDigits właściwość.

Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.
NumberNegativePattern Definiuje format wartości ujemnych i określa, czy znak ujemny jest reprezentowany przez nawiasy, czy NegativeSign właściwość.
NumberGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się pomiędzy separatorami grup.
NumberGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry dziesiętne.
NumberDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.

Poniższy przykład formatuje zasortowane wartości zmiennoprzecinkowe z specyfikatorem formatu liczb:

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0 
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1",
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0 

Specyfikator formatu procentowego (P)

Specyfikator formatu procentowego („P”) mnoży liczbę przez 100 i konwertuje ją na ciąg, który przedstawia wartość procentową. Specyfikator dokładności określa żądaną liczbę miejsc dziesiętnych. Jeśli specyfikator dokładności zostanie pominięty, zostanie użyta domyślna precyzja liczbowa dostarczona przez bieżącą PercentDecimalDigits właściwość.

W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie zwracanego ciągu.

Właściwość NumberFormatInfo Opis
PercentPositivePattern Definiuje położenie symbolu procentu dla wartości dodatnich.
PercentNegativePattern Definiuje położenie symbol procentu i symbolu wartości ujemnej dla wartości ujemnych.
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.
PercentSymbol Definiuje symbol procentu.
PercentDecimalDigits Definiuje domyślną liczbę cyfr dziesiętnych w wartości procentowej. Tę wartość można zastąpić przy użyciu specyfikatora dokładności.
PercentDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite i cyfry dziesiętne.
PercentGroupSeparator Definiuje ciąg oddzielający grupy liczb całkowitych.
PercentGroupSizes Definiuje liczbę cyfr liczby całkowitej, które pojawiają się w grupie.

Poniższy przykład formatuje wartości zmiennoprzecinkowe z specyfikatorem formatu procentu:

double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P", 
                  CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %
double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P",
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %
Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Specyfikator formatu rundy (R)

Specyfikator formatu round-trip ("R") próbuje upewnić się, że wartość liczbowa, która jest konwertowana na ciąg, jest analizowana z powrotem do tej samej wartości liczbowej. Ten format jest obsługiwany tylko dla Halftypów , Single, Doublei BigInteger .

W .NET Framework i w wersjach .NET Core starszych niż 3.0 specyfikator formatu "R" nie może pomyślnie zaokrąglić Double wartości w niektórych przypadkach. Zarówno w przypadku wartości, jak Double i Single specyfikator formatu "R" oferuje stosunkowo niską wydajność. Zamiast tego zalecamy użycie specyfikatora formatu "G17" dla Double wartości i specyfikatora formatu "G9" , aby pomyślnie zaokrąglić Single wartości.

BigInteger Gdy wartość jest sformatowana przy użyciu tego specyfikatora, jego reprezentacja ciągu zawiera wszystkie cyfry znaczące w BigInteger wartości.

Można dodawać specyfikator dokładności, ale jest on ignorowany. W przypadku korzystania z tego specyfikatora konwersje dwustronne mają pierwszeństwo przed dokładnością. Ciąg wyniku ma wpływ na informacje o formatowaniu bieżącego NumberFormatInfo obiektu. W poniższej tabeli wymieniono NumberFormatInfo właściwości kontrolujące formatowanie ciągu wynikowego.

Właściwość NumberFormatInfo Opis
NegativeSign Definiuje ciąg, który wskazuje, że liczba jest ujemna.
NumberDecimalSeparator Definiuje ciąg oddzielający cyfry całkowite od cyfr dziesiętnych.
PositiveSign Określa ciąg, który wskazuje, że wykładnik jest dodatni.

Poniższy przykład formatuje BigInteger wartość z specyfikatorem formatu zaokrąglonego.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}
// The example displays the following output:
//      85070591730234615847396907784232501249
Imports System.Numerics

Module Example
    Public Sub Main()
        Dim value = BigInteger.Pow(Int64.MaxValue, 2)
        Console.WriteLine(value.ToString("R"))
    End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249  

Ważne

W niektórych przypadkach wartości sformatowane przy użyciu standardowego ciągu formatu liczbowego "R" nie są pomyślnie zaokrąglane w Double przypadku skompilowania przy użyciu /platform:x64 przełączników lub /platform:anycpu i uruchamiania w systemach 64-bitowych. Aby uzyskać więcej informacji, zobacz następujący akapit.

Aby obejść problem wartości Double sformatowanych przy użyciu standardowego ciągu formatu liczbowego "R" nie powiodło się, jeśli skompilowane przy użyciu /platform:x64 przełączników lub /platform:anycpu i działają w systemach 64-bitowych, można sformatować Double wartości przy użyciu standardowego ciągu formatu liczbowego "G17". W poniższym przykładzie użyto ciągu formatu "R" z wartością Double , która nie działa pomyślnie, a także używa ciągu formatu "G17", aby pomyślnie zaokrąglić oryginalną wartość:

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True
Imports System.Globalization

Module Example
    Public Sub Main()
        Console.WriteLine("Attempting to round-trip a Double with 'R':")
        Dim initialValue As Double = 0.6822871999174
        Dim valueString As String = initialValue.ToString("R",
                                                 CultureInfo.InvariantCulture)
        Dim roundTripped As Double = Double.Parse(valueString,
                                                  CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped, initialValue.Equals(roundTripped))
        Console.WriteLine()

        Console.WriteLine("Attempting to round-trip a Double with 'G17':")
        Dim valueString17 As String = initialValue.ToString("G17",
                                                   CultureInfo.InvariantCulture)
        Dim roundTripped17 As Double = double.Parse(valueString17,
                                              CultureInfo.InvariantCulture)
        Console.WriteLine("{0:R} = {1:R}: {2}",
                          initialValue, roundTripped17, initialValue.Equals(roundTripped17))
    End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       0.6822871999174 = 0.68228719991740006: False
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Specyfikator formatu szesnastkowego (X)

Specyfikator formatu szesnastkowego („X”) konwertuje liczbę na ciąg cyfr szesnastkowych. Wielkość liter specyfikatora formatu wskazuje, czy w przypadku cyfr szesnastkowych, które są większe niż 9, należy używać wielkich, czy małych liter. Na przykład użycie specyfikatora „X” umożliwia uzyskanie cyfr „ABCDEF”, a specyfikatora „x” — cyfr „abcdef”. Ten format jest obsługiwany tylko w przypadku typów całkowitych.

Specyfikator dokładności określa minimalną liczbę miejsc dziesiętnych w ciągu wynikowym. Jeśli to konieczne, liczba jest dopełniana zerami po lewej stronie w celu uzyskania liczby cyfr określonej przez specyfikator dokładności.

Ciąg wynikowy nie ma wpływu na informacje o formatowaniu bieżącego NumberFormatInfo obiektu.

Poniższy przykład formatuje Int32 wartości z specyfikatorem formatu szesnastkowego.

int value; 

value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15
int value;

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15
Dim value As Integer

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Uwagi

Ta sekcja zawiera dodatkowe informacje na temat używania standardowych ciągów formatu liczbowego.

ustawienia Panel sterowania

Ustawienia w elemencie Opcje regionalne i językowe w Panel sterowania wpływają na ciąg wynikowy wygenerowany przez operację formatowania. Te ustawienia służą do inicjowania NumberFormatInfo obiektu skojarzonego z bieżącą kulturą, która udostępnia wartości używane do zarządzania formatowaniem. Na komputerach, na których są używane różne ustawienia, są generowane różne ciągi wynikowe.

Ponadto jeśli CultureInfo(String) konstruktor jest używany do tworzenia wystąpienia nowego CultureInfo obiektu, który reprezentuje tę samą kulturę co bieżąca kultura systemowa, wszelkie dostosowania ustanowione przez element Opcje regionalne i językowe w Panel sterowania zostaną zastosowane do nowego CultureInfo obiektu. Możesz użyć konstruktora CultureInfo(String, Boolean) , aby utworzyć CultureInfo obiekt, który nie odzwierciedla dostosowań systemu.

Właściwości NumberFormatInfo

Formatowanie ma wpływ na właściwości bieżącego obiektu, które jest udostępniane niejawnie przez bieżącą NumberFormatInfo kulturę lub jawnie przez IFormatProvider parametr metody, która wywołuje formatowanie. NumberFormatInfo Określ obiekt lub CultureInfo dla tego parametru.

Uwaga

Aby uzyskać informacje na temat dostosowywania wzorców lub ciągów używanych w formatowaniu wartości liczbowych, zobacz NumberFormatInfo temat klasy.

Typy liczbowe całkowite i zmiennoprzecinkowe

Niektóre opisy specyfikatorów standardowego formatu liczb odnoszą się do całkowitych lub zmiennoprzecinkowych typów liczbowych. Typy liczbowe całkowite to Byte, , SByteUInt16Int16Int64UInt32Int32, , UInt64i .BigInteger Typy liczbowe zmiennoprzecinkowe to Decimal, Half, Singlei Double.

Niedokończoności zmiennoprzecinkowe i NaN

Niezależnie od ciągu formatu, jeśli wartość Halftypu , Singlelub Double zmiennoprzecinkowa jest dodatnią nieskończonością, nieskończonością ujemną lub nie liczbą (NaN), sformatowany ciąg jest wartością odpowiedniego PositiveInfinitySymbolobiektu , NegativeInfinitySymbollub NaNSymbol właściwości określonej przez aktualnie odpowiedni NumberFormatInfo obiekt.

Przykładowy kod

W poniższym przykładzie całkowita i zmiennoprzecinkowa wartość liczbowa jest formatowana przy użyciu kultury en-US i wszystkich specyfikatorów standardowego formatu liczb. W tym przykładzie użyto dwóch określonych typów liczbowych (Double i ), ale w przypadku innych typów podstawowych liczbowych (Byte, SByte, UInt16Int32BigIntegerUInt64DecimalInt64Int16UInt32, , Halfi ).SingleInt32

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}",
        floating.ToString("C", ci));           // Displays "C: $10,761.94"
Console.WriteLine("E: {0}",
        floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}",
        floating.ToString("F04", ci));         // Displays "F: 10761.9376"
Console.WriteLine("G: {0}",
        floating.ToString("G", ci));           // Displays "G: 10761.937554"
Console.WriteLine("N: {0}",
        floating.ToString("N03", ci));         // Displays "N: 10,761.938"
Console.WriteLine("P: {0}",
        (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}",
        floating.ToString("R", ci));           // Displays "R: 10761.937554"
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}",
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}",
        integral.ToString("D6", ci));          // Displays "D: 008395"
Console.WriteLine("E: {0}",
        integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}",
        integral.ToString("F01", ci));         // Displays "F: 8395.0"
Console.WriteLine("G: {0}",
        integral.ToString("G", ci));           // Displays "G: 8395"
Console.WriteLine("N: {0}",
        integral.ToString("N01", ci));         // Displays "N: 8,395.0"
Console.WriteLine("P: {0}",
        (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}",
        integral.ToString("X", ci));           // Displays "X: 0x20CB"
Console.WriteLine();
Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
    Public Sub Main()
        ' Display string representations of numbers for en-us culture
        Dim ci As New CultureInfo("en-us")

        ' Output floating point values
        Dim floating As Double = 10761.937554
        Console.WriteLine("C: {0}", _
                floating.ToString("C", ci))           ' Displays "C: $10,761.94"
        Console.WriteLine("E: {0}", _
                floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
        Console.WriteLine("F: {0}", _
                floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
        Console.WriteLine("G: {0}", _
                floating.ToString("G", ci))           ' Displays "G: 10761.937554"
        Console.WriteLine("N: {0}", _
                floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
        Console.WriteLine("P: {0}", _
                (floating / 10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
        Console.WriteLine("R: {0}", _
                floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
        Console.WriteLine()

        ' Output integral values
        Dim integral As Integer = 8395
        Console.WriteLine("C: {0}", _
                integral.ToString("C", ci))           ' Displays "C: $8,395.00"
        Console.WriteLine("D: {0}", _
                integral.ToString("D6"))              ' Displays "D: 008395" 
        Console.WriteLine("E: {0}", _
                integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
        Console.WriteLine("F: {0}", _
                integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
        Console.WriteLine("G: {0}", _
                integral.ToString("G", ci))           ' Displays "G: 8395"
        Console.WriteLine("N: {0}", _
                integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
        Console.WriteLine("P: {0}", _
                (integral / 10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
        Console.WriteLine("X: 0x{0}", _
                integral.ToString("X", ci))           ' Displays "X: 0x20CB"
        Console.WriteLine()
    End Sub
End Module

Zobacz też