BigInteger.ToString Metod

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

public:
 override System::String ^ ToString();

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Returer

Strängrepresentationen av det aktuella BigInteger värdet.

Exempel

I följande exempel visas ett BigInteger värde med hjälp av standardmetoden ToString() . Den visar också strängrepresentationer av värdet BigInteger som resulterar från att använda vissa standardformatsspecificerare. Exemplen visas med formateringskonventionerna för en-US kultur.

// Initialize a BigInteger value.
BigInteger value = BigInteger.Add(UInt64.MaxValue, 1024);

// Display value using the default ToString method.
Console.WriteLine(value.ToString());
// Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"));
Console.WriteLine(value.ToString("C"));
Console.WriteLine(value.ToString("D"));
Console.WriteLine(value.ToString("F"));
Console.WriteLine(value.ToString("N"));
Console.WriteLine(value.ToString("X"));
// The example displays the following output on a system whose current
// culture is en-US:
//       18446744073709552639
//       18446744073709552639
//       $18,446,744,073,709,552,639.00
//       18446744073709552639
//       18446744073709552639.00
//       18,446,744,073,709,552,639.00
//       100000000000003FF

    // Initialize a BigInteger value.
    let value = BigInteger.Add(UInt64.MaxValue, 1024)

    // Display value using the default ToString method.
    printfn $"{value.ToString()}"
    // Display value using some standard format specifiers.
    printfn $"""{value.ToString("G")}"""
    printfn $"""{value.ToString("C")}"""
    printfn $"""{value.ToString("D")}"""
    printfn $"""{value.ToString("F")}"""
    printfn $"""{value.ToString("N")}"""
    printfn $"""{value.ToString("X")}"""
// The example displays the following output on a system whose current
// culture is en-US:
//       18446744073709552639
//       18446744073709552639
//       $18,446,744,073,709,552,639.00
//       18446744073709552639
//       18446744073709552639.00
//       18,446,744,073,709,552,639.00
//       100000000000003FF

' Initialize a BigInteger value.
Dim value As BigInteger = BigInteger.Add(UInt64.MaxValue, 1024)

' Display value using the default ToString method.
Console.WriteLine(value.ToString())        
' Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"))
Console.WriteLine(value.ToString("C"))
Console.WriteLine(value.ToString("D"))
Console.WriteLine(value.ToString("F"))
Console.WriteLine(value.ToString("N"))
Console.WriteLine(value.ToString("X"))       
' The example displays the following output on a system whose current 
' culture is en-US:
'       18446744073709552639
'       18446744073709552639
'       $18,446,744,073,709,552,639.00
'       18446744073709552639
'       18446744073709552639.00
'       18,446,744,073,709,552,639.00
'       100000000000003FF

Kommentarer

Metoden ToString() formaterar ett BigInteger värde i formatet "R" eller tur och retur för den aktuella kulturen. Om du vill ange ett annat format eller en annan kultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Rundresa ("R") format	En specifik kultur	ToString
Ett specifikt format	Standardkultur (aktuell)	ToString(String)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Strängrepresentationen BigInteger av värdet innehåller ett negativt tecken om dess värde är negativt och en sekvens med siffror mellan 0 och 9 utan inledande nollor. Det negativa tecknet definieras av NumberFormatInfo objektet för den aktuella kulturen.

Se även

• Standardsträngar med numeriskt format
• Anpassade numeriska formatsträngar

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

public:
 System::String ^ ToString(IFormatProvider ^ provider);

public string ToString(IFormatProvider provider);

public string ToString(IFormatProvider? provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

Parametrar

Returer

Strängrepresentationen av det aktuella BigInteger värdet i det format som anges av parametern provider .

Exempel

I följande exempel instansieras ett anpassat NumberFormatInfo objekt som definierar tilde (~) som ett negativt tecken. Metoden ToString(IFormatProvider) använder sedan det anpassade NumberFormatInfo objektet för att visa ett negativt BigInteger värde.

BigInteger number = 9867857831128;
number = BigInteger.Pow(number, 3) * BigInteger.MinusOne;

NumberFormatInfo bigIntegerProvider = new NumberFormatInfo();
bigIntegerProvider.NegativeSign = "~";

Console.WriteLine(number.ToString(bigIntegerProvider));

let number = bigint 9867857831128L
let number = BigInteger.Pow(number, 3) * BigInteger.MinusOne

let bigIntegerProvider = NumberFormatInfo()
bigIntegerProvider.NegativeSign <- "~"

printfn $"{number.ToString(bigIntegerProvider)}"

Dim number As BigInteger = 9867857831128
number = BigInteger.Pow(number, 3) * BigInteger.MinusOne

Dim bigIntegerProvider As New NumberFormatInfo()
bigIntegerProvider.NegativeSign = "~"      

Console.WriteLine(number.ToString(bigIntegerProvider))

Kommentarer

Metoden ToString(IFormatProvider) formaterar ett BigInteger värde i formatet "R" eller tur och retur med hjälp av objektet för NumberFormatInfo en angiven kultur. Om du vill ange ett annat format eller den aktuella kulturen använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Rundresa ("R") format	Standardkultur (aktuell)	ToString()
Ett specifikt format	Standardkultur (aktuell)	ToString(String)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Parametern provider är en IFormatProvider implementering. Metoden GetFormat returnerar ett NumberFormatInfo objekt som innehåller kulturspecifik information om formatet på strängen som returneras av den här metoden. Om provider är nullBigInteger formateras värdet med hjälp NumberFormatInfo av objektet för den aktuella kulturen. Den enda egenskapen för NumberFormatInfo objektet som styr strängrepresentationen BigInteger av värdet med hjälp av den allmänna formatspecificeraren är NumberFormatInfo.NegativeSign, som definierar det tecken som representerar det negativa tecknet.

Parametern provider kan vara något av följande:

• Ett CultureInfo objekt som representerar kulturen som tillhandahåller formateringsinformation.

• Objektet NumberFormatInfo som tillhandahåller formateringsinformation.

• Ett anpassat objekt som implementerar IFormatProvider. Dess GetFormat metod returnerar det NumberFormatInfo objekt som tillhandahåller formateringsinformation.

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

public:
 System::String ^ ToString(System::String ^ format);

public string ToString(string format);

public string ToString(string? format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parametrar

Returer

Strängrepresentationen av det aktuella BigInteger värdet i det format som anges av parametern format .

Undantag

Exempel

I följande exempel initieras ett BigInteger värde och det visas med hjälp av varje standardformatsträng och vissa anpassade formatsträngar.

BigInteger value = BigInteger.Parse("-903145792771643190182");
string[] specifiers = { "C", "D", "D25", "E", "E4", "e8", "F0",
                        "G", "N0", "P", "R", "X", "0,0.000",
                        "#,#.00#;(#,#.00#)" };

foreach (string specifier in specifiers)
   Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));

// The example displays the following output:
//       C: ($903,145,792,771,643,190,182.00)
//       D: -903145792771643190182
//       D25: -0000903145792771643190182
//       E: -9.031457E+020
//       E4: -9.0314E+020
//       e8: -9.03145792e+020
//       F0: -903145792771643190182
//       G: -903145792771643190182
//       N0: -903,145,792,771,643,190,182
//       P: -90,314,579,277,164,319,018,200.00 %
//       R: -903145792771643190182
//       X: CF0A55968BB1A7545A
//       0,0.000: -903,145,792,771,643,190,182.000
//       #,#.00#;(#,#.00#): (903,145,792,771,643,190,182.00)

    // Define a BigInteger value.
    let value = BigInteger.Parse "-903145792771643190182"

    let specifiers =
        [| "C"
           "D"
           "D25"
           "E"
           "E4"
           "e8"
           "F0"
           "G"
           "N0"
           "P"
           "R"
           "X"
           "0,0.000"
           "#,#.00#;(#,#.00#)" |]

    for specifier in specifiers do
        printfn $"{specifier}: {value.ToString specifier}"
// The example displays the following output:
//       C: ($903,145,792,771,643,190,182.00)
//       D: -903145792771643190182
//       D25: -0000903145792771643190182
//       E: -9.031457E+020
//       E4: -9.0314E+020
//       e8: -9.03145792e+020
//       F0: -903145792771643190182
//       G: -903145792771643190182
//       N0: -903,145,792,771,643,190,182
//       P: -90,314,579,277,164,319,018,200.00 %
//       R: -903145792771643190182
//       X: CF0A55968BB1A7545A
//       0,0.000: -903,145,792,771,643,190,182.000
//       #,#.00#;(#,#.00#): (903,145,792,771,643,190,182.00)

Dim value As BigInteger = BigInteger.Parse("-903145792771643190182")
Dim specifiers() As String = { "C", "D", "D25", "E", "E4", "e8", "F0", 
                               "G", "N0", "P", "R", "X", "0,0.000", 
                               "#,#.00#;(#,#.00#)" }

For Each specifier As String In specifiers
   Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
Next   
' The example displays the following output:
'       C: ($903,145,792,771,643,190,182.00)
'       D: -903145792771643190182
'       D25: -0000903145792771643190182
'       E: -9.031457E+020
'       E4: -9.0314E+020
'       e8: -9.03145792e+020
'       F0: -903145792771643190182
'       G: -903145792771643190182
'       N0: -903,145,792,771,643,190,182
'       P: -90,314,579,277,164,319,018,200.00 %
'       R: -903145792771643190182
'       X: CF0A55968BB1A7545A
'       0,0.000: -903,145,792,771,643,190,182.000
'       #,#.00#;(#,#.00#): (903,145,792,771,643,190,182.00)

Kommentarer

Metoden ToString(String) formaterar ett BigInteger värde i ett angivet format med hjälp av ett NumberFormatInfo objekt som representerar den aktuella kulturens konventioner. Om du vill använda "R" eller rundresa, formatera eller ange en annan kultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Rundresa ("R") format	Standardkultur (aktuell)	ToString()
Rundresa ("R") format	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	En specifik kultur	ToString(String, IFormatProvider)

Parametern format kan vara valfri giltig numerisk standardsträng eller valfri kombination av anpassade numeriska formatsträngar. Om format är lika String.Empty med eller är nullformateras returvärdet för det aktuella BigInteger objektet med formatspecificeraren ("R"). Om format är något annat värde genererar metoden en FormatException.

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

• Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.

• Mer information om stöd för formatering i .NET finns i Formateringstyper.

Formatet för den returnerade strängen NumberFormatInfo bestäms av objektet för den aktuella kulturen. Beroende på parametern format styr det här objektet symboler som det negativa tecknet, gruppavgränsaren och decimaltecknet i utdatasträngen. Om du vill ange formateringsinformation för andra kulturer än den aktuella kulturen anropar du överlagringen ToString(String, IFormatProvider) .

Se även

• Standardsträngar med numeriskt format
• Anpassade numeriska formatsträngar

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

Källa:

BigInteger.cs

public:
 virtual System::String ^ ToString(System::String ^ format, IFormatProvider ^ provider);

public string ToString(string format, IFormatProvider provider);

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

override this.ToString : string * IFormatProvider -> string

Public Function ToString (format As String, provider As IFormatProvider) As String

Parametrar

Returer

Strängrepresentationen av det aktuella BigInteger värdet enligt parametrarna format och provider .

Implementeringar

Undantag

Exempel

I följande exempel initieras ett BigInteger värde och visas för konsolen med hjälp av en standardformatsträng och ett NumberFormatInfo objekt som definierar tilde (~) som ett negativt tecken.

// Redefine the negative sign as the tilde for the invariant culture.
NumberFormatInfo bigIntegerFormatter = new NumberFormatInfo();
bigIntegerFormatter.NegativeSign = "~";

BigInteger value = BigInteger.Parse("-903145792771643190182");
string[] specifiers = { "C", "D", "D25", "E", "E4", "e8", "F0",
                        "G", "N0", "P", "R", "X", "0,0.000",
                        "#,#.00#;(#,#.00#)" };

foreach (string specifier in specifiers)
   Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier,
                     bigIntegerFormatter));

// The example displays the following output:
//    C: (☼903,145,792,771,643,190,182.00)
//    D: ~903145792771643190182
//    D25: ~0000903145792771643190182
//    E: ~9.031457E+020
//    E4: ~9.0314E+020
//    e8: ~9.03145792e+020
//    F0: ~903145792771643190182
//    G: ~903145792771643190182
//    N0: ~903,145,792,771,643,190,182
//    P: ~90,314,579,277,164,319,018,200.00 %
//    R: ~903145792771643190182
//    X: CF0A55968BB1A7545A
//    0,0.000: ~903,145,792,771,643,190,182.000
//    #,#.00#;(#,#.00#): (903,145,792,771,643,190,182.00)

    // Redefine the negative sign as the tilde for the invariant culture.
    let bigIntegerFormatter = NumberFormatInfo()
    bigIntegerFormatter.NegativeSign <- "~"

    let value = BigInteger.Parse "-903145792771643190182"

    let specifiers =
        [| "C"
           "D"
           "D25"
           "E"
           "E4"
           "e8"
           "F0"
           "G"
           "N0"
           "P"
           "R"
           "X"
           "0,0.000"
           "#,#.00#;(#,#.00#)" |]

    for specifier in specifiers do
        printfn $"{specifier}: {value.ToString(specifier, bigIntegerFormatter)}"

// The example displays the following output:
//    C: (☼903,145,792,771,643,190,182.00)
//    D: ~903145792771643190182
//    D25: ~0000903145792771643190182
//    E: ~9.031457E+020
//    E4: ~9.0314E+020
//    e8: ~9.03145792e+020
//    F0: ~903145792771643190182
//    G: ~903145792771643190182
//    N0: ~903,145,792,771,643,190,182
//    P: ~90,314,579,277,164,319,018,200.00 %
//    R: ~903145792771643190182
//    X: CF0A55968BB1A7545A
//    0,0.000: ~903,145,792,771,643,190,182.000
//    #,#.00#;(#,#.00#): (903,145,792,771,643,190,182.00)

' Redefine the negative sign as the tilde for the invariant culture.
Dim bigIntegerFormatter As New NumberFormatInfo()
bigIntegerFormatter.NegativeSign = "~"

Dim value As BigInteger = BigInteger.Parse("-903145792771643190182")
Dim specifiers() As String = { "C", "D", "D25", "E", "E4", "e8", "F0", 
                               "G", "N0", "P", "R", "X", "0,0.000", 
                               "#,#.00#;(#,#.00#)" }

For Each specifier As String In specifiers
   Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier, 
                     bigIntegerformatter))
Next   
' The example displays the following output:
'    C: (☼903,145,792,771,643,190,182.00)
'    D: ~903145792771643190182
'    D25: ~0000903145792771643190182
'    E: ~9.031457E+020
'    E4: ~9.0314E+020
'    e8: ~9.03145792e+020
'    F0: ~903145792771643190182
'    G: ~903145792771643190182
'    N0: ~903,145,792,771,643,190,182
'    P: ~90,314,579,277,164,319,018,200.00 %
'    R: ~903145792771643190182
'    X: CF0A55968BB1A7545A
'    0,0.000: ~903,145,792,771,643,190,182.000
'    #,#.00#;(#,#.00#): (903,145,792,771,643,190,182.00)

Kommentarer

Metoden ToString(String, IFormatProvider) formaterar ett BigInteger värde i ett angivet format med hjälp av objektet för NumberFormatInfo en angiven kultur. Om du vill använda inställningarna för tur och retur-format eller standardkultur använder du de andra överlagringarna av ToString metoden enligt följande:

Så här använder du format	För kultur	Använd överlagringen
Rundresa ("R") format	Standardkultur (aktuell)	ToString()
Rundresa ("R") format	En specifik kultur	ToString(IFormatProvider)
Ett specifikt format	Standardkultur (aktuell)	ToString(String)

Parametern format kan vara valfri giltig numerisk standardsträng eller valfri kombination av anpassade numeriska formatsträngar. Om format är lika String.Empty med eller är nullformateras returvärdet för det aktuella BigInteger objektet med formatspecificeraren ("R"). Om format är något annat värde genererar metoden en FormatException.

.NET ger omfattande formateringsstöd, vilket beskrivs mer detaljerat i följande formateringsämnen:

• Mer information om numeriska formatspecificerare finns i Standard numeriska formatsträngar och anpassade numeriska formatsträngar.

• Mer information om stöd för formatering i .NET finns i Formateringstyper.

Parametern provider är en IFormatProvider implementering. Metoden GetFormat returnerar ett NumberFormatInfo objekt som innehåller kulturspecifik information om formatet på strängen som returneras av den här metoden. ToString(String, IFormatProvider) När metoden anropas anropas provider parameterns GetFormat metod och skickar den ett Type objekt som representerar NumberFormatInfo typen. Metoden GetFormat returnerar sedan det NumberFormatInfo objekt som innehåller information för att formatera parametern value , till exempel symbolen för negativa tecken, gruppavgränsarsymbolen eller decimaltecknet. Det finns tre sätt att använda parametern provider för att ange formateringsinformation till ToString(String, IFormatProvider) metoden:

• Du kan skicka ett CultureInfo objekt som representerar kulturen som tillhandahåller formateringsinformation. Dess GetFormat metod returnerar det NumberFormatInfo objekt som innehåller numerisk formateringsinformation för den kulturen.

• Du kan skicka det faktiska NumberFormatInfo objektet som innehåller numerisk formateringsinformation. (Dess implementering av GetFormat just returnerar sig själv.)

• Du kan skicka ett anpassat objekt som implementerar IFormatProvider. Metoden GetFormat instansierar och returnerar objektet NumberFormatInfo som tillhandahåller formateringsinformation.

Om provider är nullbaseras formateringen för den returnerade strängen på objektet för NumberFormatInfo den aktuella kulturen.

Se även

• Standardsträngar med numeriskt format
• Anpassade numeriska formatsträngar