Double.ToString Metoda

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.

Przeciążenia

ToString()	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.
ToString(IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanych danych formatowania specyficznych dla kultury.
ToString(String)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.
ToString(String, IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.

ToString()

Źródło:

Double.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu.

public override string ToString ();

Zwraca

String

Ciąg reprezentujący wartość tego wystąpienia.

Przykłady

W poniższym przykładzie użyto metody domyślnej Double.ToString() , aby wyświetlić reprezentacje ciągów Double liczby wartości.

double number;

number = 1.6E20;
// Displays 1.6E+20.
Console.WriteLine(number.ToString());

number = 1.6E2;
// Displays 160.
Console.WriteLine(number.ToString());

number = -3.541;
// Displays -3.541.
Console.WriteLine(number.ToString());

number = -1502345222199E-07;
// Displays -150234.5222199.
Console.WriteLine(number.ToString());

number = -15023452221990199574E-09;
// Displays -15023452221.9902.
Console.WriteLine(number.ToString());

number = .60344;
// Displays 0.60344.
Console.WriteLine(number.ToString());

number = .000000001;
// Displays 1E-09.
Console.WriteLine(number.ToString());

Poniższy przykład ilustruje użycie metody ToString.

bool done = false;
string inp;
do {
   Console.Write("Enter a real number: ");
   inp = Console.ReadLine();
   try {
      d = Double.Parse(inp);
      Console.WriteLine("You entered {0}.", d.ToString());
      done = true;
   }
   catch (FormatException) {
      Console.WriteLine("You did not enter a number.");
   }
   catch (ArgumentNullException) {
      Console.WriteLine("You did not supply any input.");
   }
   catch (OverflowException) {
       Console.WriteLine("The value you entered, {0}, is out of range.", inp);
   }
} while (!done);

Uwagi

Metoda ToString() formatuje Double wartość w domyślnym formacie ("G" lub ogólnym) bieżącej kultury. Jeśli chcesz określić inny format, precyzję lub kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu	Dla kultury	Używanie przeciążenia
Domyślny format ("G")	Określona kultura	ToString(IFormatProvider)
Określony format lub precyzja	Domyślna (bieżąca) kultura	ToString(String)
Określony format lub precyzja	Określona kultura	ToString(String, IFormatProvider)

Zwracana wartość może być PositiveInfinitySymbol, , NaNSymbolNegativeInfinitySymbollub ciągiem formularza:

[znak]cyfry całkowite[.[ fractional-digits]][E[sign]exponential-digits]

Elementy opcjonalne są obramowane nawiasami kwadratowymi ([ i ]). Elementy, które zawierają „cyfry”, składają się z serii cyfr od 0 do 9. Obsługiwane są elementy wymienione w poniższej tabeli.

Element	Opis
sign	Znak ujemny lub symbol znaku dodatniego.
cyfry-całkowite	Ciąg cyfr określający część całkowitą liczby. Cyfry całkowite mogą być nieobecne w przypadku cyfr ułamkowych.
'.'	Symbol dziesiętny specyficzny dla kultury.
cyfry-ułamkowe	Ciąg cyfr określający część ułamkową liczby.
"E"	Wielka litera "E", wskazująca notację wykładniczą (naukową).
cyfry-wykładnicze	Ciąg cyfr określające wykładnik potęgi.

Niektóre przykłady wartości zwracanej to "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123" i "-Infinity".

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została opisana bardziej szczegółowo w następujących tematach formatowania:

• Aby uzyskać więcej informacji na temat specyfikatorów formatu liczbowego, zobacz Standardowe ciągi formatu liczbowego i Niestandardowe ciągi formatu liczbowego.

• Aby uzyskać więcej informacji na temat formatowania, zobacz Typy formatowania.

Zobacz też

• Parse(String)
• String
• Typy formatowania na platformie .NET

ToString(IFormatProvider)

Źródło:

Double.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanych danych formatowania specyficznych dla kultury.

public string ToString (IFormatProvider? provider);

Parametry

provider

IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

String

Reprezentacja ciągu wartości tego wystąpienia określona przez providerparametr .

Implementuje

ToString(IFormatProvider)

Przykłady

W poniższym przykładzie przedstawiono reprezentację ciągu dwóch Double wartości przy użyciu CultureInfo obiektów reprezentujących kilka różnych kultur.

double value;

value = -16325.62015;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));

value = 16034.125E21;
// Display value using the invariant culture.
Console.WriteLine(value.ToString(CultureInfo.InvariantCulture));
// Display value using the en-GB culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("en-GB")));
// Display value using the de-DE culture.
Console.WriteLine(value.ToString(CultureInfo.CreateSpecificCulture("de-DE")));
// This example displays the following output to the console:
//       -16325.62015
//       -16325.62015
//       -16325,62015
//       1.6034125E+25
//       1.6034125E+25
//       1,6034125E+25

W poniższym przykładzie pokazano użycie parametru ToString, które przyjmuje parametr String i IFormatProvider jako parametry.

public class Temperature : IFormattable {
    // IFormattable.ToString implementation.
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

Uwagi

Metoda ToString(IFormatProvider) formatuje Double wartość w domyślnym formacie ("G" lub ogólnym) określonej kultury. Jeśli chcesz określić inny format lub kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu	Dla kultury	Używanie przeciążenia
Domyślny format ("G")	Wartość domyślna (bieżąca)	ToString()
Określony format lub precyzja	Domyślna (bieżąca) kultura	ToString(String)
Określony format lub precyzja	Określona kultura	ToString(String, IFormatProvider)

Zwracana wartość może być PositiveInfinitySymbol, , NaNSymbolNegativeInfinitySymbollub ciągiem formularza:

[znak]cyfry całkowite[.[ fractional-digits]][E[sign]exponential-digits]

Elementy opcjonalne są obramowane nawiasami kwadratowymi ([ i ]). Elementy, które zawierają „cyfry”, składają się z serii cyfr od 0 do 9. Obsługiwane są elementy wymienione w poniższej tabeli.

Element	Opis
sign	Znak ujemny lub symbol znaku dodatniego.
cyfry-całkowite	Ciąg cyfr określający część całkowitą liczby. Cyfry całkowite mogą być nieobecne w przypadku cyfr ułamkowych.
'.'	Symbol dziesiętny specyficzny dla kultury.
cyfry-ułamkowe	Ciąg cyfr określający część ułamkową liczby.
"E"	Wielka litera "E", wskazująca notację wykładniczą (naukową).
cyfry-wykładnicze	Ciąg cyfr określające wykładnik potęgi.

Niektóre przykłady wartości zwracanej to "100", "-123,456,789", "123.45E+6", "500", "3.1416", "600", "-0.123" i "-Infinity".

To wystąpienie jest sformatowana za pomocą ogólnego specyfikatora formatu liczbowego („G”).

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została opisana bardziej szczegółowo w następujących tematach formatowania:

• Aby uzyskać więcej informacji na temat specyfikatorów formatu liczbowego, zobacz Standardowe ciągi formatu liczbowego i Niestandardowe ciągi formatu liczbowego.

• Aby uzyskać więcej informacji na temat formatowania, zobacz Typy formatowania.

Parametr provider jest implementacją IFormatProvider , której GetFormat metoda zwraca NumberFormatInfo obiekt. provider Zazwyczaj jest obiektem CultureInfo lub obiektemNumberFormatInfo. Parametr provider dostarcza informacje specyficzne dla kultury używane w formatowaniu. Jeśli provider jest to null, wartość zwracana jest sformatowana przy użyciu NumberFormatInfo obiektu dla bieżącej kultury.

Zobacz też

• Parse(String)
• String
• Typy formatowania na platformie .NET

ToString(String)

Źródło:

Double.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu.

public string ToString (string? format);

Parametry

format

String

Ciąg formatu liczbowego.

Zwraca

String

Reprezentacja ciągu wartości tego wystąpienia określona przez formatparametr .

Wyjątki

FormatException

Nazwa format jest niepoprawna.

Przykłady

Poniższy przykład definiuje wartość liczbową i formatuje ją jako wartość waluty przy użyciu standardowego ciągu formatu liczbowego "C" i jako wartości liczbowej do trzech miejsc dziesiętnych przy użyciu standardowego ciągu formatu liczbowego "N". Ciągi wyników są formatowane przy użyciu konwencji kultury en-US. Aby uzyskać więcej informacji na temat ciągów formatu liczbowego, zobacz Standardowe ciągi formatu liczbowego i Niestandardowe ciągi formatu liczbowego.

using System;

public class Example
{
   public static void Main()
   {
      float number = 1764.3789m;

      // Format as a currency value.
      Console.WriteLine(number.ToString("C"));

      // Format as a numeric value with 3 decimal places.
      Console.WriteLine(number.ToString("N3"));
   }
}
// The example displays the following output:
//       $1,764.38
//       1,764.379

W poniższym przykładzie przedstawiono kilka Double wartości korzystających z obsługiwanych standardowych specyfikatorów formatu liczbowego wraz z trzema niestandardowymi ciągami formatu liczbowego. Jeden z tych ciągów formatu niestandardowego ilustruje sposób wypełniania Single wartości z zerami wiodącymi. Ponadto w przykładzie użyto specyfikatorów dokładności z każdym specyfikatorem formatu standardowego z wyjątkiem "R". Wartości specyfikatorów dokładności wahają się od 0 do 3. Aby przekonwertować wartości liczbowe na ciągi, w przykładzie użyto konwencji formatowania kultury en-US.

double[] numbers= {1054.32179, -195489100.8377, 1.0437E21,
                   -1.0573e-05};
string[] specifiers = { "C", "E", "e", "F", "G", "N", "P",
                        "R", "#,000.000", "0.###E-000",
                        "000,000,000,000.00###" };
foreach (double number in numbers)
{
   Console.WriteLine("Formatting of {0}:", number);
   foreach (string specifier in specifiers) {
      Console.WriteLine("   {0,-22} {1}",
                        specifier + ":", number.ToString(specifier));
      // Add precision specifiers from 0 to 3.
      if (specifier.Length == 1 & ! specifier.Equals("R")) {
         for (int precision = 0; precision <= 3; precision++) {
            string pSpecifier = String.Format("{0}{1}", specifier, precision);
            Console.WriteLine("   {0,-22} {1}",
                              pSpecifier + ":", number.ToString(pSpecifier));
         }
         Console.WriteLine();
      }
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//       Formatting of 1054.32179:
//          C:                     $1,054.32
//          C0:                    $1,054
//          C1:                    $1,054.3
//          C2:                    $1,054.32
//          C3:                    $1,054.322
//
//          E:                     1.054322E+003
//          E0:                    1E+003
//          E1:                    1.1E+003
//          E2:                    1.05E+003
//          E3:                    1.054E+003
//
//          e:                     1.054322e+003
//          e0:                    1e+003
//          e1:                    1.1e+003
//          e2:                    1.05e+003
//          e3:                    1.054e+003
//
//          F:                     1054.32
//          F0:                    1054
//          F1:                    1054.3
//          F2:                    1054.32
//          F3:                    1054.322
//
//          G:                     1054.32179
//          G0:                    1054.32179
//          G1:                    1E+03
//          G2:                    1.1E+03
//          G3:                    1.05E+03
//
//          N:                     1,054.32
//          N0:                    1,054
//          N1:                    1,054.3
//          N2:                    1,054.32
//          N3:                    1,054.322
//
//          P:                     105,432.18 %
//          P0:                    105,432 %
//          P1:                    105,432.2 %
//          P2:                    105,432.18 %
//          P3:                    105,432.179 %
//
//          R:                     1054.32179
//          #,000.000:             1,054.322
//          0.###E-000:            1.054E003
//          000,000,000,000.00###: 000,000,001,054.32179
//
//       Formatting of -195489100.8377:
//          C:                     ($195,489,100.84)
//          C0:                    ($195,489,101)
//          C1:                    ($195,489,100.8)
//          C2:                    ($195,489,100.84)
//          C3:                    ($195,489,100.838)
//
//          E:                     -1.954891E+008
//          E0:                    -2E+008
//          E1:                    -2.0E+008
//          E2:                    -1.95E+008
//          E3:                    -1.955E+008
//
//          e:                     -1.954891e+008
//          e0:                    -2e+008
//          e1:                    -2.0e+008
//          e2:                    -1.95e+008
//          e3:                    -1.955e+008
//
//          F:                     -195489100.84
//          F0:                    -195489101
//          F1:                    -195489100.8
//          F2:                    -195489100.84
//          F3:                    -195489100.838
//
//          G:                     -195489100.8377
//          G0:                    -195489100.8377
//          G1:                    -2E+08
//          G2:                    -2E+08
//          G3:                    -1.95E+08
//
//          N:                     -195,489,100.84
//          N0:                    -195,489,101
//          N1:                    -195,489,100.8
//          N2:                    -195,489,100.84
//          N3:                    -195,489,100.838
//
//          P:                     -19,548,910,083.77 %
//          P0:                    -19,548,910,084 %
//          P1:                    -19,548,910,083.8 %
//          P2:                    -19,548,910,083.77 %
//          P3:                    -19,548,910,083.770 %
//
//          R:                     -195489100.8377
//          #,000.000:             -195,489,100.838
//          0.###E-000:            -1.955E008
//          000,000,000,000.00###: -000,195,489,100.8377
//
//       Formatting of 1.0437E+21:
//          C:                     $1,043,700,000,000,000,000,000.00
//          C0:                    $1,043,700,000,000,000,000,000
//          C1:                    $1,043,700,000,000,000,000,000.0
//          C2:                    $1,043,700,000,000,000,000,000.00
//          C3:                    $1,043,700,000,000,000,000,000.000
//
//          E:                     1.043700E+021
//          E0:                    1E+021
//          E1:                    1.0E+021
//          E2:                    1.04E+021
//          E3:                    1.044E+021
//
//          e:                     1.043700e+021
//          e0:                    1e+021
//          e1:                    1.0e+021
//          e2:                    1.04e+021
//          e3:                    1.044e+021
//
//          F:                     1043700000000000000000.00
//          F0:                    1043700000000000000000
//          F1:                    1043700000000000000000.0
//          F2:                    1043700000000000000000.00
//          F3:                    1043700000000000000000.000
//
//          G:                     1.0437E+21
//          G0:                    1.0437E+21
//          G1:                    1E+21
//          G2:                    1E+21
//          G3:                    1.04E+21
//
//          N:                     1,043,700,000,000,000,000,000.00
//          N0:                    1,043,700,000,000,000,000,000
//          N1:                    1,043,700,000,000,000,000,000.0
//          N2:                    1,043,700,000,000,000,000,000.00
//          N3:                    1,043,700,000,000,000,000,000.000
//
//          P:                     104,370,000,000,000,000,000,000.00 %
//          P0:                    104,370,000,000,000,000,000,000 %
//          P1:                    104,370,000,000,000,000,000,000.0 %
//          P2:                    104,370,000,000,000,000,000,000.00 %
//          P3:                    104,370,000,000,000,000,000,000.000 %
//
//          R:                     1.0437E+21
//          #,000.000:             1,043,700,000,000,000,000,000.000
//          0.###E-000:            1.044E021
//          000,000,000,000.00###: 1,043,700,000,000,000,000,000.00
//
//       Formatting of -1.0573E-05:
//          C:                     $0.00
//          C0:                    $0
//          C1:                    $0.0
//          C2:                    $0.00
//          C3:                    $0.000
//
//          E:                     -1.057300E-005
//          E0:                    -1E-005
//          E1:                    -1.1E-005
//          E2:                    -1.06E-005
//          E3:                    -1.057E-005
//
//          e:                     -1.057300e-005
//          e0:                    -1e-005
//          e1:                    -1.1e-005
//          e2:                    -1.06e-005
//          e3:                    -1.057e-005
//
//          F:                     0.00
//          F0:                    0
//          F1:                    0.0
//          F2:                    0.00
//          F3:                    0.000
//
//          G:                     -1.0573E-05
//          G0:                    -1.0573E-05
//          G1:                    -1E-05
//          G2:                    -1.1E-05
//          G3:                    -1.06E-05
//
//          N:                     0.00
//          N0:                    0
//          N1:                    0.0
//          N2:                    0.00
//          N3:                    0.000
//
//          P:                     0.00 %
//          P0:                    0 %
//          P1:                    0.0 %
//          P2:                    0.00 %
//          P3:                    -0.001 %
//
//          R:                     -1.0573E-05
//          #,000.000:             000.000
//          0.###E-000:            -1.057E-005
//          000,000,000,000.00###: -000,000,000,000.00001

Uwagi

Metoda ToString(String) formatuje Double wartość w określonym formacie przy użyciu konwencji bieżącej kultury. Jeśli chcesz określić inny format lub kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu	Dla kultury	Używanie przeciążenia
Domyślny format ("G")	Domyślna (bieżąca) kultura	ToString()
Domyślny format ("G")	Określona kultura	ToString(IFormatProvider)
Określony format lub precyzja	Określona kultura	ToString(String, IFormatProvider)

Wartość zwracana może być PositiveInfinitySymbol, , NaNSymbolNegativeInfinitySymbollub ciąg reprezentujący liczbę, zgodnie z wartością format.

Parametr format może być dowolnym prawidłowym standardowym specyfikatorem formatu liczbowego z wyjątkiem D i X, a także dowolnej kombinacji niestandardowych specyfikatorów formatu liczbowego. Jeśli format jest lub null pusty ciąg, zwracana wartość jest sformatowana za pomocą ogólnego specyfikatora formatu liczbowego ("G").

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została opisana bardziej szczegółowo w następujących tematach formatowania:

• Aby uzyskać więcej informacji na temat specyfikatorów formatu liczbowego, zobacz Standardowe ciągi formatu liczbowego i Niestandardowe ciągi formatu liczbowego.

• Aby uzyskać więcej informacji na temat formatowania, zobacz Typy formatowania.

Domyślnie zwracana wartość zawiera tylko 15 cyfr dokładności, chociaż maksymalnie 17 cyfr jest utrzymywanych wewnętrznie. Jeśli wartość tego wystąpienia ma więcej niż 15 cyfr, ToString zwraca PositiveInfinitySymbol wartość lub NegativeInfinitySymbol zamiast oczekiwanej liczby. Jeśli potrzebujesz większej precyzji, określ format specyfikację formatu "G17", która zawsze zwraca 17 cyfr dokładności lub "R", która zwraca 15 cyfr, jeśli liczba może być reprezentowana z tej dokładności lub 17 cyfr, jeśli liczba może być reprezentowana tylko z maksymalną dokładnością.

Uwagi dotyczące wywoływania

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 obejść ten problem, 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 powiodła się, a także używa ciągu formatu "G17", aby pomyślnie zaokrąglić oryginalną wartość.

using System;

public class Example
{
   static void Main(string[] args)
   {
      Console.WriteLine("Attempting to round-trip a Double with 'R':");
      double initialValue = 0.6822871999174;
      string valueString = initialValue.ToString("R");
      double roundTripped = double.Parse(valueString);
      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");
      double roundTripped17 = double.Parse(valueString17);
      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

Zobacz też

• Parse(String)
• Typy formatowania na platformie .NET
• Standardowe ciągi formatów liczbowych
• Niestandardowe ciągi formatu liczbowego
• Instrukcje: Uzupełnianie liczby zerami wiodącymi

ToString(String, IFormatProvider)

Źródło:

Double.cs

Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.

public string ToString (string? format, IFormatProvider? provider);

Parametry

format

String

Ciąg formatu liczbowego.

provider

IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

String

Ciąg reprezentacja wartości tego wystąpienia określona przez format i provider.

Implementuje

ToString(String, IFormatProvider)

Przykłady

Poniższy przykład przedstawia Double wartość przy użyciu każdego z obsługiwanych standardowych specyfikatorów formatu liczbowego dla kilku różnych kultur.

double value = 16325.62901;
string specifier;
CultureInfo culture;

// Use standard numeric format specifiers.
specifier = "G";
culture = CultureInfo.CreateSpecificCulture("eu-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,62901
Console.WriteLine(value.ToString(specifier, CultureInfo.InvariantCulture));
// Displays:    16325.62901

specifier = "C";
culture = CultureInfo.CreateSpecificCulture("en-US");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    $16,325.63
culture = CultureInfo.CreateSpecificCulture("en-GB");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    £16,325.63

specifier = "E04";
culture = CultureInfo.CreateSpecificCulture("sv-SE");
Console.WriteLine(value.ToString(specifier, culture));
// Displays: 1,6326E+004
 culture = CultureInfo.CreateSpecificCulture("en-NZ");
 Console.WriteLine(value.ToString(specifier, culture));
// Displays:    1.6326E+004

specifier = "F";
culture = CultureInfo.CreateSpecificCulture("fr-FR");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325,63
culture = CultureInfo.CreateSpecificCulture("en-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16325.63

specifier = "N";
culture = CultureInfo.CreateSpecificCulture("es-ES");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16.325,63
culture = CultureInfo.CreateSpecificCulture("fr-CA");
Console.WriteLine(value.ToString(specifier, culture));
// Displays:    16 325,63

specifier = "P";
culture = CultureInfo.InvariantCulture;
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.26 %
culture = CultureInfo.CreateSpecificCulture("ar-EG");
Console.WriteLine((value/10000).ToString(specifier, culture));
// Displays:    163.256 %

W poniższym przykładzie pokazano użycie parametru ToString, które przyjmuje parametr String i IFormatProvider jako parametry.

public class Temperature : IFormattable {
    // IFormattable.ToString implementation.
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

Uwagi

Metoda ToString(String, IFormatProvider) formatuje Double wartość w określonym formacie określonej kultury. Jeśli chcesz określić inny format lub kulturę, użyj innych przeciążeń ToString metody w następujący sposób:

Aby użyć formatu	Dla kultury	Używanie przeciążenia
Domyślny format ("G")	Domyślna (bieżąca) kultura	ToString()
Domyślny format ("G")	Określona kultura	ToString(IFormatProvider)
Określony format lub precyzja	Domyślna (bieżąca) kultura	ToString(String)

Wartość zwracana może być PositiveInfinitySymbol, , NaNSymbolNegativeInfinitySymbollub ciąg reprezentujący liczbę, zgodnie z wartością format.

Parametr format może być dowolnym prawidłowym standardowym specyfikatorem formatu liczbowego z wyjątkiem D i X, a także dowolnej kombinacji niestandardowych specyfikatorów formatu liczbowego. Jeśli format jest lub null pusty ciąg, wartość zwracana dla tego wystąpienia jest sformatowana za pomocą ogólnego specyfikatora formatu liczbowego ("G").

Platforma .NET zapewnia rozbudowaną obsługę formatowania, która została opisana bardziej szczegółowo w następujących tematach formatowania:

• Aby uzyskać więcej informacji na temat specyfikatorów formatu liczbowego, zobacz Standardowe ciągi formatu liczbowego i Niestandardowe ciągi formatu liczbowego.

• Aby uzyskać więcej informacji na temat formatowania, zobacz Typy formatowania.

Parametr provider jest implementacją IFormatProvider , której GetFormat metoda zwraca NumberFormatInfo obiekt. provider Zazwyczaj jest obiektem CultureInfo lub obiektemNumberFormatInfo. Parametr provider dostarcza informacje specyficzne dla kultury używane w formatowaniu. Jeśli provider jest to null, wartość zwracana jest sformatowana przy użyciu NumberFormatInfo obiektu dla bieżącej kultury.

Domyślnie zwracana wartość zawiera tylko 15 cyfr dokładności, chociaż maksymalnie 17 cyfr jest utrzymywanych wewnętrznie. Jeśli wartość tego wystąpienia ma więcej niż 15 cyfr, ToString zwraca PositiveInfinitySymbol wartość lub NegativeInfinitySymbol zamiast oczekiwanej liczby. Jeśli potrzebujesz większej precyzji, określ format specyfikację formatu "G17", która zawsze zwraca 17 cyfr dokładności lub "R", która zwraca 15 cyfr, jeśli liczba może być reprezentowana z tej dokładności lub 17 cyfr, jeśli liczba może być reprezentowana tylko z maksymalną dokładnością.

Uwagi dotyczące wywoływania

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 obejść ten problem, 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 powiodła się, a także używa ciągu formatu "G17", aby pomyślnie zaokrąglić oryginalną wartość.

using System;
using System.Globalization;

public class Example
{
   static void Main(string[] args)
   {
      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
   }
}

Zobacz też

• Parse(String)
• Typy formatowania na platformie .NET
• Standardowe ciągi formatów liczbowych
• Niestandardowe ciągi formatu liczbowego
• Instrukcje: Uzupełnianie liczby zerami wiodącymi
• Przykład: .NET Core WinForms Formatting Utility (C#)
• Przykład: .NET Core WinForms Formatting Utility (Visual Basic)