BigInteger.ToString Metodo

Definizione

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente.

Overload

ToString(String, IFormatProvider)

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura indicate.

ToString(String)

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente, usando il formato specificato.

ToString(IFormatProvider)

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente usando le informazioni di formattazione specifiche delle impostazioni cultura indicate.

ToString()

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente.

ToString(String, IFormatProvider)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura indicate.

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

Parametri

format
String

Stringa di formato numerico standard o personalizzato.

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

Restituisce

Rappresentazione di stringa del valore corrente di BigInteger, come specificato dai parametri format e provider.

Implementazioni

Eccezioni

format non è una stringa di formato valida.

Esempio

Nell'esempio seguente viene inizializzato un BigInteger valore e viene visualizzato nella console usando una stringa di formato standard e un NumberFormatInfo oggetto che definisce la tilde (~) come segno negativo.

// 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)

Commenti

Il ToString(String, IFormatProvider) metodo formatta un BigInteger valore in un formato specificato usando l'oggetto NumberFormatInfo di una cultura specificata. Se si vuole usare il formato round trip o le impostazioni cultura predefinite, usare gli altri overload del ToString metodo, come indicato di seguito:

Per usare il formato Per le impostazioni cultura Usare l'overload
Formato round trip ("R") Impostazioni cultura predefinite (corrente) ToString()
Formato round trip ("R") Impostazioni cultura specifiche ToString(IFormatProvider)
Formato specifico Impostazioni cultura predefinite (corrente) ToString(String)

Il format parametro può essere qualsiasi stringa numerica standard valida o qualsiasi combinazione di stringhe di formato numerico personalizzate. Se format è uguale a String.Empty o nullè , il valore restituito dell'oggetto corrente BigInteger viene formattato con l'identificatore di formato round trip ("R"). Se format è un altro valore, il metodo genera un FormatExceptionoggetto .

.NET offre un supporto di formattazione completo, descritto in modo più dettagliato negli argomenti di formattazione seguenti:

Il provider parametro è un'implementazione IFormatProvider . Il GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato della stringa restituita da questo metodo. Quando viene richiamato il metodo, chiama il ToString(String, IFormatProvider)provider metodo del GetFormat parametro e lo passa un Type oggetto che rappresenta il NumberFormatInfo tipo. Il GetFormat metodo restituisce quindi l'oggetto NumberFormatInfo che fornisce informazioni per la formattazione value del parametro, ad esempio il simbolo di segno negativo, il simbolo separatore di gruppo o il simbolo di punto decimale. Esistono tre modi per usare il provider parametro per fornire informazioni di formattazione al ToString(String, IFormatProvider) metodo:

  • È possibile passare un CultureInfo oggetto che rappresenta le impostazioni cultura che forniscono informazioni di formattazione. Il GetFormat metodo restituisce l'oggetto NumberFormatInfo che fornisce informazioni di formattazione numerica per tali impostazioni cultura.

  • È possibile passare l'oggetto effettivo NumberFormatInfo che fornisce informazioni di formattazione numerica. (L'implementazione di GetFormat è stata appena restituita).

  • È possibile passare un oggetto personalizzato che implementa IFormatProvider. Il GetFormat metodo crea un'istanza e restituisce l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, la formattazione della stringa restituita è basata sull'oggetto NumberFormatInfo delle impostazioni cultura correnti.

Vedi anche

Si applica a

ToString(String)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente, usando il formato specificato.

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

Parametri

format
String

Stringa di formato numerico standard o personalizzato.

Restituisce

Rappresentazione di stringa del valore BigInteger corrente nel formato specificato dal parametro format.

Eccezioni

format non è una stringa di formato valida.

Esempio

L'esempio seguente inizializza un BigInteger valore e lo visualizza usando ogni stringa di formato standard e alcune stringhe di formato personalizzate.

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)

Commenti

Il ToString(String) metodo formatta un valore in un formato specificato usando un NumberFormatInfoBigInteger oggetto che rappresenta le convenzioni delle impostazioni cultura correnti. Se si vuole usare il formato "R", o round trip, o specificare una cultura diversa, usare gli altri overload del ToString metodo, come indicato di seguito:

Per usare il formato Per le impostazioni cultura Usare l'overload
Formato round trip ("R") Impostazioni cultura predefinite (corrente) ToString()
Formato round trip ("R") Impostazioni cultura specifiche ToString(IFormatProvider)
Formato specifico Impostazioni cultura specifiche ToString(String, IFormatProvider)

Il format parametro può essere qualsiasi stringa numerica standard valida o qualsiasi combinazione di stringhe di formato numerico personalizzate. Se format è uguale a String.Empty o nullè , il valore restituito dell'oggetto corrente BigInteger viene formattato con l'identificatore di formato round trip ("R"). Se format è un altro valore, il metodo genera un FormatExceptionoggetto .

.NET offre un supporto di formattazione completo, descritto in modo più dettagliato negli argomenti di formattazione seguenti:

Il formato della stringa restituita è determinato dall'oggetto NumberFormatInfo per le impostazioni cultura correnti. A seconda del format parametro, questo oggetto controlla i simboli, ad esempio il segno negativo, il separatore di gruppo e il simbolo decimale della stringa di output. Per fornire informazioni di formattazione per le impostazioni cultura diverse dalle impostazioni cultura correnti, chiamare l'overload ToString(String, IFormatProvider) .

Vedi anche

Si applica a

ToString(IFormatProvider)

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente usando le informazioni di formattazione specifiche delle impostazioni cultura indicate.

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

Parametri

provider
IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

Restituisce

Rappresentazione di stringa del valore BigInteger corrente nel formato specificato dal parametro provider.

Esempio

Nell'esempio seguente viene creata un'istanza di un oggetto personalizzato NumberFormatInfo che definisce la tilde (~) come segno negativo. Il ToString(IFormatProvider) metodo usa quindi l'oggetto personalizzato NumberFormatInfo per visualizzare un valore negativo BigInteger .

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))

Commenti

Il ToString(IFormatProvider) metodo formatta un BigInteger valore nel formato "R" o round trip usando l'oggetto NumberFormatInfo di una cultura specificata. Se si vuole specificare un formato diverso o le impostazioni cultura correnti, usare gli altri overload del ToString metodo, come indicato di seguito:

Per usare il formato Per le impostazioni cultura Usare l'overload
Formato round trip ("R") Impostazioni cultura predefinite (corrente) ToString()
Formato specifico Impostazioni cultura predefinite (corrente) ToString(String)
Formato specifico Impostazioni cultura specifiche ToString(String, IFormatProvider)

Il provider parametro è un'implementazione IFormatProvider . Il GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato della stringa restituita da questo metodo. Se provider è null, il BigInteger valore viene formattato usando l'oggetto NumberFormatInfo delle impostazioni cultura correnti. L'unica proprietà dell'oggetto NumberFormatInfo che controlla la rappresentazione stringa del BigInteger valore usando l'identificatore di formato generale è NumberFormatInfo.NegativeSign, che definisce il carattere che rappresenta il segno negativo.

Il provider parametro può essere uno dei seguenti:

Si applica a

ToString()

Origine:
BigInteger.cs
Origine:
BigInteger.cs
Origine:
BigInteger.cs

Converte il valore numerico dell'oggetto BigInteger corrente nella rappresentazione di stringa equivalente.

public:
 override System::String ^ ToString();
public override string ToString ();
override this.ToString : unit -> string
Public Overrides Function ToString () As String

Restituisce

Rappresentazione di stringa del valore BigInteger corrente.

Esempio

Nell'esempio seguente viene visualizzato un BigInteger valore usando il metodo predefinito ToString() . Visualizza anche le rappresentazioni stringa del valore risultante dall'uso BigInteger di alcuni identificatori di formato standard. Gli esempi vengono visualizzati usando le convenzioni di formattazione delle impostazioni cultura en-US.

// 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

Commenti

Il ToString() metodo formatta un BigInteger valore nel formato "R", o round trip, delle impostazioni cultura correnti. Se si vuole specificare un formato o impostazioni cultura diverse, usare gli altri overload del ToString metodo, come indicato di seguito:

Per usare il formato Per le impostazioni cultura Usare l'overload
Formato round trip ("R") Impostazioni cultura specifiche ToString
Formato specifico Impostazioni cultura predefinite (corrente) ToString(String)
Formato specifico Impostazioni cultura specifiche ToString(String, IFormatProvider)

La rappresentazione stringa del BigInteger valore include un segno negativo se il relativo valore è negativo e una sequenza di cifre compreso tra 0 e 9 senza zero iniziali. Il segno negativo è definito dall'oggetto NumberFormatInfo per le impostazioni cultura correnti.

Vedi anche

Si applica a