BigInteger.ToString Método

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

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Devoluções

A representação da cadeia do valor atual BigInteger .

Exemplos

O exemplo seguinte apresenta um BigInteger valor usando o método padrão ToString() . Também mostra as representações das cadeias do BigInteger valor resultantes da utilização de alguns especificadores de formato padrão. Os exemplos são apresentados usando as convenções de formatação da 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

Observações

O ToString() método formata um BigInteger valor no formato "R", ou de ida e volta, da cultura atual. Se quiser especificar um formato ou cultura diferente, use as outras sobrecargas do ToString método, da seguinte forma:

Para usar o formato	Pela cultura	Usa a sobrecarga
Formato de ida e volta ("R")	Uma cultura específica	ToString
Um formato específico	Cultura padrão (atual)	ToString(String)
Um formato específico	Uma cultura específica	ToString(String, IFormatProvider)

A representação em cadeia do BigInteger valor inclui um sinal negativo se o seu valor for negativo, e uma sequência de dígitos de 0 a 9 sem zeros à esquerda. O sinal negativo é definido pelo NumberFormatInfo objeto da cultura atual.

Ver também

• Standard Numeric Format Strings (Cadeias de Formato Numérico Padrão)
• Cadeias de caracteres de formato numérico personalizado

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

public string ToString(IFormatProvider provider);

override this.ToString : IFormatProvider -> string

Public Function ToString (provider As IFormatProvider) As String

Parâmetros

Devoluções

A representação da cadeia do valor atual BigInteger no formato especificado pelo provider parâmetro.

Exemplos

O exemplo seguinte instancia um objeto personalizado NumberFormatInfo que define a tilde (~) como um sinal negativo. O ToString(IFormatProvider) método utiliza então o objeto personalizado NumberFormatInfo para mostrar um valor 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))

Observações

O ToString(IFormatProvider) método formata um BigInteger valor no formato "R", ou de ida e volta, usando o NumberFormatInfo objeto de uma cultura especificada. Se quiser especificar um formato diferente ou a cultura atual, use as outras sobrecargas do ToString método, da seguinte forma:

Para usar o formato	Pela cultura	Usa a sobrecarga
Formato de ida e volta ("R")	Cultura padrão (atual)	ToString()
Um formato específico	Cultura padrão (atual)	ToString(String)
Um formato específico	Uma cultura específica	ToString(String, IFormatProvider)

O provider parâmetro é uma IFormatProvider implementação. O seu GetFormat método devolve um NumberFormatInfo objeto que fornece informação específica da cultura sobre o formato da cadeia devolvida por este método. Se provider for , o BigInteger valor é formatado usando o NumberFormatInfo objeto nullda cultura atual. A única propriedade do NumberFormatInfo objeto que controla a representação em cadeia do BigInteger valor usando o especificador geral de formato é NumberFormatInfo.NegativeSign, que define o carácter que representa o sinal negativo.

O provider parâmetro pode ser um dos seguintes:

• Um CultureInfo objeto que representa a cultura que fornece informação de formatação.

• O NumberFormatInfo objeto que fornece a informação de formatação.

• Um objeto personalizado que implementa IFormatProvider. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece a informação de formatação.

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

public string ToString(string format);

override this.ToString : string -> string

Public Function ToString (format As String) As String

Parâmetros

Devoluções

A representação da cadeia do valor atual BigInteger no formato especificado pelo format parâmetro.

Exceções

Exemplos

O exemplo seguinte inicializa um BigInteger valor e mostra-o usando cada cadeia de formatos padrão e algumas cadeias de formato personalizadas.

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)

Observações

O ToString(String) método formata um BigInteger valor num formato especificado usando um NumberFormatInfo objeto que representa as convenções da cultura atual. Se quiser usar o "R", ou ida e volta, formatar ou especificar uma cultura diferente, use as outras sobrecargas do ToString método, da seguinte forma:

Para usar o formato	Pela cultura	Usa a sobrecarga
Formato de ida e volta ("R")	Cultura padrão (atual)	ToString()
Formato de ida e volta ("R")	Uma cultura específica	ToString(IFormatProvider)
Um formato específico	Uma cultura específica	ToString(String, IFormatProvider)

O format parâmetro pode ser qualquer cadeia numérica padrão válida, ou qualquer combinação de cadeias de formatos numéricos personalizados. Se format for igual a String.Empty ou for null, o valor de retorno do objeto atual BigInteger é formatado com o especificador de formato de ida e volta ("R"). Se format for qualquer outro valor, o método gera um FormatException.

O .NET oferece um suporte extenso de formatação, que é descrito com mais detalhe nos seguintes tópicos de formatação:

• Para mais informações sobre especificadores de formato numérico, consulte Cadeias de Formato Numérico Padrão e Cadeias de Formato Numérico Personalizado.

• Para mais informações sobre o suporte à formatação em .NET, consulte Formatting Types.

O formato da cadeia devolvida é determinado pelo NumberFormatInfo objeto para a cultura atual. Dependendo do format parâmetro, este objeto controla símbolos como o sinal negativo, o separador de grupo e o símbolo da vírgula decimal na cadeia de saída. Para fornecer informação de formatação para culturas diferentes da cultura atual, chame a ToString(String, IFormatProvider) sobrecarga.

Ver também

• Standard Numeric Format Strings (Cadeias de Formato Numérico Padrão)
• Cadeias de caracteres de formato numérico personalizado

public:
 virtual System::String ^ ToString(System::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

Parâmetros

Devoluções

A representação da cadeia do valor atual BigInteger conforme especificado pelos format parâmetros e.provider

Implementações

Exceções

Exemplos

O exemplo seguinte inicializa um BigInteger valor e mostra-o na consola usando uma cadeia de formato padrão e um NumberFormatInfo objeto que define a tilde (~) como sinal 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)

Observações

O ToString(String, IFormatProvider) método formata um BigInteger valor num formato especificado usando o NumberFormatInfo objeto de uma cultura especificada. Se quiser usar o formato de ida e volta ou as definições padrão de cultura, use as outras sobrecargas do ToString método, da seguinte forma:

Para usar o formato	Pela cultura	Usa a sobrecarga
Formato de ida e volta ("R")	Cultura padrão (atual)	ToString()
Formato de ida e volta ("R")	Uma cultura específica	ToString(IFormatProvider)
Um formato específico	Cultura padrão (atual)	ToString(String)

O format parâmetro pode ser qualquer cadeia numérica padrão válida, ou qualquer combinação de cadeias de formatos numéricos personalizados. Se format for igual a String.Empty ou for null, o valor de retorno do objeto atual BigInteger é formatado com o especificador de formato de ida e volta ("R"). Se format for qualquer outro valor, o método gera um FormatException.

O .NET oferece um suporte extenso de formatação, que é descrito com mais detalhe nos seguintes tópicos de formatação:

• Para mais informações sobre especificadores de formato numérico, consulte Cadeias de Formato Numérico Padrão e Cadeias de Formato Numérico Personalizado.

• Para mais informações sobre o suporte à formatação em .NET, consulte Formatting Types.

O provider parâmetro é uma IFormatProvider implementação. O seu GetFormat método devolve um NumberFormatInfo objeto que fornece informação específica da cultura sobre o formato da cadeia devolvida por este método. Quando o ToString(String, IFormatProvider) método é invocado, chama o provider método do GetFormat parâmetro e passa-lhe um Type objeto que representa o NumberFormatInfo tipo. O GetFormat método devolve então o NumberFormatInfo objeto que fornece informação para formatar o value parâmetro, como o símbolo do sinal negativo, o símbolo do separador de grupo ou o símbolo da vírgula decimal. Existem três formas de usar o provider parâmetro para fornecer informação de formatação ao ToString(String, IFormatProvider) método:

• Pode passar um CultureInfo objeto que representa a cultura que fornece a informação de formatação. O seu GetFormat método devolve o NumberFormatInfo objeto que fornece informação numérica de formatação para essa cultura.

• Pode passar o objeto real NumberFormatInfo que fornece a informação numérica de formatação. (A sua implementação de GetFormat simplesmente devolve-se a si própria.)

• Podes passar um objeto personalizado que implementa IFormatProvider. O seu GetFormat método instancia e devolve o NumberFormatInfo objeto que fornece a informação de formatação.

Se provider for null, a formatação da cadeia devolvida baseia-se no NumberFormatInfo objeto da cultura atual.

Ver também

• Standard Numeric Format Strings (Cadeias de Formato Numérico Padrão)
• Cadeias de caracteres de formato numérico personalizado