Int64.ToString Método

Definição

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente.

Sobrecargas

ToString(IFormatProvider)

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando as informações de formato específicas da cultura especificadas.

ToString()

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente.

ToString(String)

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado.

ToString(String, IFormatProvider)

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura.

ToString(IFormatProvider)

Origem:
Int64.cs
Origem:
Int64.cs
Origem:
Int64.cs

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando as informações de formato específicas da cultura especificadas.

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

Parâmetros

provider
IFormatProvider

Um IFormatProvider que fornece informações de formatação específicas da cultura.

Retornos

A representação da cadeia de caracteres do valor dessa instância, conforme especificado por provider.

Implementações

Exemplos

O exemplo a seguir exibe a representação de cadeia de caracteres de um valor Int64 usando objetos CultureInfo que representam várias culturas diferentes.

long value = -16325901;
// 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:
//       -16325901
//       -16325901
//       -16325901
let value = -16325901L
// Display value using the invariant culture.
printfn $"{value.ToString CultureInfo.InvariantCulture}"
// Display value using the en-GB culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "en-GB" )}"""
// Display value using the de-DE culture.
printfn $"""{value.ToString(CultureInfo.CreateSpecificCulture "de-DE" )}"""
// This example displays the following output to the console:
//       -16325901
//       -16325901
//       -16325901
Dim value As Long = -16325801
' 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:
'       -16325901
'       -16325901
'       -16325901

Comentários

O método ToString(IFormatProvider) formata um valor Int64 no formato padrão ("G" ou geral) usando o objeto NumberFormatInfo de uma cultura especificada. Se você quiser especificar um formato diferente ou a cultura atual, use as outras sobrecargas do método ToString, da seguinte maneira:

Para usar o formato Para cultura Usar a sobrecarga
Formato padrão ("G") 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 parâmetro provider é um objeto que implementa a interface IFormatProvider. Seu método GetFormat retorna um objeto NumberFormatInfo que fornece informações específicas da cultura sobre o formato da cadeia de caracteres retornada por esse método. O objeto que implementa IFormatProvider pode ser qualquer um dos seguintes:

  • Um objeto CultureInfo que representa a cultura cujas regras de formatação devem ser usadas.

  • Um objeto NumberFormatInfo que contém informações de formatação numérica específicas para esse valor.

  • Um objeto personalizado que implementa IFormatProvider e cujo método GetFormat retorna um objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null ou um objeto NumberFormatInfo não puder ser obtido de provider, o valor retornado será formatado com o objeto NumberFormatInfo da cultura atual.

O .NET fornece amplo suporte à formatação, que é descrito com mais detalhes nos seguintes tópicos de formatação:

Confira também

Aplica-se a

ToString()

Origem:
Int64.cs
Origem:
Int64.cs
Origem:
Int64.cs

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente.

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

Retornos

A representação de cadeia de caracteres do valor dessa instância, que consiste em um sinal de menos se o valor for negativo, e uma sequência de dígitos variando de 0 a 9 sem zeros à esquerda.

Exemplos

O exemplo a seguir exibe um valor Int64 usando o método de ToString() padrão. Ele também exibe as representações de cadeia de caracteres do valor Int64 resultante do uso de vários especificadores de formato padrão. Os exemplos são exibidos usando as convenções de formatação da cultura en-US.

long value = -16325091;
// Display value using default ToString method.
Console.WriteLine(value.ToString());            // Displays -16325091
// Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"));         // Displays -16325091
Console.WriteLine(value.ToString("C"));         // Displays ($16,325,091.00)
Console.WriteLine(value.ToString("D"));         // Displays -16325091
Console.WriteLine(value.ToString("F"));         // Displays -16325091.00
Console.WriteLine(value.ToString("N"));         // Displays -16,325,091.00
Console.WriteLine(value.ToString("N0"));         // Displays -16,325,091
Console.WriteLine(value.ToString("X"));         // Displays FFFFFFFFFF06E61D
let value = -16325091L
// Display value using default ToString method.
printfn $"{value.ToString()}"            // Displays -16325091
// Display value using some standard format specifiers.
printfn $"""{value.ToString "G"}"""         // Displays -16325091
printfn $"""{value.ToString "C"}"""         // Displays ($16,325,091.00)
printfn $"""{value.ToString "D"}"""         // Displays -16325091
printfn $"""{value.ToString "F"}"""         // Displays -16325091.00
printfn $"""{value.ToString "N"}"""         // Displays -16,325,091.00
printfn $"""{value.ToString "N0"}"""        // Displays -16,325,091
printfn $"""{value.ToString "X"}"""         // Displays FFFFFFFFFF06E61D
Dim value As Long = -16325091
' Display value using default ToString method.
Console.WriteLine(value.ToString())            ' Displays -16325091
' Display value using some standard format specifiers.
Console.WriteLine(value.ToString("G"))         ' Displays -16325091
Console.WriteLine(value.ToString("C"))         ' Displays ($16,325,091.00)
Console.WriteLine(value.ToString("D"))         ' Displays -16325091
Console.WriteLine(value.ToString("F"))         ' Displays -16325091.00
Console.WriteLine(value.ToString("N"))         ' Displays -16,325091.00
Console.WriteLine(value.ToString("X"))         ' Displays FFFFFFFFFF06E61D

Comentários

O método ToString() formata um valor Int64 no formato padrão ("G" ou geral) usando o objeto NumberFormatInfo da cultura atual. Se você quiser especificar um formato ou cultura diferente, use as outras sobrecargas do método ToString da seguinte maneira:

Para usar o formato Para cultura Usar a sobrecarga
Formato padrão ("G") Uma cultura específica ToString(IFormatProvider)
Um formato específico Cultura padrão (atual) ToString(String)
Um formato específico Uma cultura específica ToString(String, IFormatProvider)

O .NET fornece amplo suporte à formatação, que é descrito com mais detalhes nos seguintes tópicos de formatação:

Confira também

Aplica-se a

ToString(String)

Origem:
Int64.cs
Origem:
Int64.cs
Origem:
Int64.cs

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado.

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

Parâmetros

format
String

Uma cadeia de caracteres de formato numérico.

Retornos

A representação da cadeia de caracteres do valor dessa instância, conforme especificado por format.

Exceções

format é inválido ou não tem suporte.

Exemplos

O exemplo a seguir exibe um valor Int64 usando cada um dos especificadores de formato numérico padrão com suporte, juntamente com duas cadeias de caracteres de formato numérico personalizado. Ao converter os valores numéricos em cadeias de caracteres, o exemplo usa as convenções de formatação da cultura en-US.

long value = -16325;
string specifier;

// Use standard numeric format specifier.
specifier = "G";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    G: -16325
specifier = "C";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    C: ($16,325.00)
specifier = "D8";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    D8: -00016325
specifier = "E4";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    E4: -1.6325E+004
specifier = "e3";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    e3: -1.633e+004
specifier = "F";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    F: -16325.00
specifier = "N";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    N: -16,325.00
specifier = "P";
Console.WriteLine("{0}: {1}", specifier, (value/100000.0).ToString(specifier));
// Displays:    P: -16.33 %
specifier = "X";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    X: FFFFFFFFFFFFC03B

// Use custom numeric format specifiers.
specifier = "0,0.000";
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
// Displays:    0,0.000: -16,325.000
specifier = "#,#.00#;(#,#.00#)";
Console.WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier));
// Displays:    #,#.00#;(#,#.00#): 16,325.00
let value = -16325L

// Use standard numeric format specifier.
let specifier = "G"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    G: -16325

let specifier = "C"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    C: ($16,325.00)

let specifier = "D8"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    D8: -00016325

let specifier = "E4"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    E4: -1.6325E+004

let specifier = "e3"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    e3: -1.633e+004

let specifier = "F"
printfn $"{specifier}: {value.ToString specifier}"
// Displays:    F: -16325.00

let specifier = "N"
printfn $"{specifier}: {value.ToString specifier }"
// Displays:    N: -16,325.00

let specifier = "P"
printfn $"{specifier}: {(float value / 100000.0).ToString specifier}"
// Displays:    P: -16.33 %

let specifier = "X"
printfn $"{specifier}: {value.ToString(specifier)}"
// Displays:    X: FFFFFFFFFFFFC03B

// Use custom numeric format specifiers.
let specifier = "0,0.000"
printfn $"{specifier}: {value.ToString(specifier)}"
// Displays:    0,0.000: -16,325.000

let specifier = "#,#.00#(#,#.00#)"
printfn $"{specifier}: {(value * -1L).ToString specifier}"
// Displays:    #,#.00#(#,#.00#): 16,325.00
Dim value As Long = -16325
Dim specifier As String

' Use standard numeric format specifier.
specifier = "G"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    G: -16325
specifier = "C"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    C: ($16,325.00)
specifier = "D8"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    D8: -00016325
specifier = "E4"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    E4: -1.6325E+004
specifier = "e3"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    e3: -1.633e+004
specifier = "F"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    F: -16325.00
specifier = "N"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    N: -16,325.00
specifier = "P"
Console.WriteLine("{0}: {1}", specifier, (value/100000).ToString(specifier))
' Displays:    P: -16.33 %
specifier = "X"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    X: FFFFFFFFFFFFC03B

' Use custom numeric format specifiers.
specifier = "0,0.000"
Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
' Displays:    0,0.000: -16,325.000
specifier = "#,#.00#;(#,#.00#)"
Console.WriteLine("{0}: {1}", specifier, (value*-1).ToString(specifier))
' Displays:    #,#.00#;(#,#.00#): 16,325.00

Comentários

O método ToString(String) formata um valor Int64 em um formato especificado usando um objeto NumberFormatInfo que representa as convenções da cultura atual. Se você quiser usar o formato padrão ("G" ou geral) ou especificar uma cultura diferente, use as outras sobrecargas do método ToString, da seguinte maneira:

Para usar o formato Para cultura Usar a sobrecarga
Formato padrão ("G") Cultura padrão (atual) ToString()
Formato padrão ("G") Uma cultura específica ToString(IFormatProvider)
Um formato específico Uma cultura específica ToString(String, IFormatProvider)

O parâmetro format pode ser qualquer especificador de formato numérico padrão válido, exceto "R", bem como qualquer combinação de especificadores de formato numérico personalizados. Se format for null ou uma cadeia de caracteres vazia (""), o valor retornado dessa instância será formatado com o especificador de formato numérico geral ("G").

O .NET fornece amplo suporte à formatação, que é descrito com mais detalhes nos seguintes tópicos de formatação:

O valor retornado dessa instância é formatado com o NumberFormatInfo para a cultura atual.

Confira também

Aplica-se a

ToString(String, IFormatProvider)

Origem:
Int64.cs
Origem:
Int64.cs
Origem:
Int64.cs

Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura.

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

Parâmetros

format
String

Uma cadeia de caracteres de formato numérico.

provider
IFormatProvider

Um objeto que fornece informações de formatação específicas da cultura sobre essa instância.

Retornos

A representação de cadeia de caracteres do valor dessa instância, conforme especificado por format e provider.

Implementações

Exceções

format é inválido ou não tem suporte.

Exemplos

O exemplo a seguir exibe um valor positivo e negativo usando cada um dos especificadores de formato numérico padrão com suporte para três culturas diferentes.

// Define cultures whose formatting conventions are to be used.
CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("en-US"),
                          CultureInfo.CreateSpecificCulture("fr-FR"),
                          CultureInfo.CreateSpecificCulture("es-ES") };
long positiveNumber = 1679;
long negativeNumber = -3045;
string[] specifiers = {"G", "C", "D8", "E2", "F", "N", "N0", "P", "X8"};

foreach (string specifier in specifiers)
{
   foreach (CultureInfo culture in cultures)
   {
      // Display values with "G" format specifier.
      Console.WriteLine("{0} format using {1} culture: {2, 16} {3, 16}",
                        specifier, culture.Name,
                        positiveNumber.ToString(specifier, culture),
                        negativeNumber.ToString(specifier, culture));
   }
   Console.WriteLine();
}
// The example displays the following output to the console:
//    G format using en-US culture:             1679            -3045
//    G format using fr-FR culture:             1679            -3045
//    G format using es-ES culture:             1679            -3045
//
//    C format using en-US culture:        $1,679.00      ($3,045.00)
//    C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//    C format using es-ES culture:       1.679,00 €      -3.045,00 €
//
//    D8 format using en-US culture:         00001679        -00003045
//    D8 format using fr-FR culture:         00001679        -00003045
//    D8 format using es-ES culture:         00001679        -00003045
//
//    E2 format using en-US culture:        1.68E+003       -3.05E+003
//    E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//    E2 format using es-ES culture:        1,68E+003       -3,05E+003
//
//    F format using en-US culture:          1679.00         -3045.00
//    F format using fr-FR culture:          1679,00         -3045,00
//    F format using es-ES culture:          1679,00         -3045,00
//
//    N format using en-US culture:         1,679.00        -3,045.00
//    N format using fr-FR culture:         1 679,00        -3 045,00
//    N format using es-ES culture:         1.679,00        -3.045,00
//
//    N0 format using en-US culture:         1,679           -3,045
//    N0 format using fr-FR culture:         1 679           -3 045
//    N0 format using es-ES culture:         1.679           -3.045
//
//    P format using en-US culture:      167,900.00%     -304,500.00%
//    P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//    P format using es-ES culture:     167.900,00 %    -304.500,00 %
//
//    X8 format using en-US culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using fr-FR culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using es-ES culture:         0000068F FFFFFFFFFFFFF41B
// Define cultures whose formatting conventions are to be used.
let cultures = 
    [| CultureInfo.CreateSpecificCulture "en-US"
       CultureInfo.CreateSpecificCulture "fr-FR"
       CultureInfo.CreateSpecificCulture "es-ES" |]

let positiveNumber = 1679L
let negativeNumber = -3045L
let specifiers = [| "G"; "C"; "D8"; "E2"; "F"; "N"; "N0"; "P"; "X8" |]

for specifier in specifiers do
    for culture in cultures do
        // Display values with "G" format specifier.
        printfn $"{specifier} format using {culture.Name} culture: {positiveNumber.ToString(specifier, culture), 16} {negativeNumber.ToString(specifier, culture), 16}"           
    printfn ""

// The example displays the following output to the console:
//    G format using en-US culture:             1679            -3045
//    G format using fr-FR culture:             1679            -3045
//    G format using es-ES culture:             1679            -3045
//
//    C format using en-US culture:        $1,679.00      ($3,045.00)
//    C format using fr-FR culture:       1 679,00 €      -3 045,00 €
//    C format using es-ES culture:       1.679,00 €      -3.045,00 €
//
//    D8 format using en-US culture:         00001679        -00003045
//    D8 format using fr-FR culture:         00001679        -00003045
//    D8 format using es-ES culture:         00001679        -00003045
//
//    E2 format using en-US culture:        1.68E+003       -3.05E+003
//    E2 format using fr-FR culture:        1,68E+003       -3,05E+003
//    E2 format using es-ES culture:        1,68E+003       -3,05E+003
//
//    F format using en-US culture:          1679.00         -3045.00
//    F format using fr-FR culture:          1679,00         -3045,00
//    F format using es-ES culture:          1679,00         -3045,00
//
//    N format using en-US culture:         1,679.00        -3,045.00
//    N format using fr-FR culture:         1 679,00        -3 045,00
//    N format using es-ES culture:         1.679,00        -3.045,00
//
//    N0 format using en-US culture:         1,679           -3,045
//    N0 format using fr-FR culture:         1 679           -3 045
//    N0 format using es-ES culture:         1.679           -3.045
//
//    P format using en-US culture:      167,900.00%     -304,500.00%
//    P format using fr-FR culture:     167 900,00 %    -304 500,00 %
//    P format using es-ES culture:     167.900,00 %    -304.500,00 %
//
//    X8 format using en-US culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using fr-FR culture:         0000068F FFFFFFFFFFFFF41B
//    X8 format using es-ES culture:         0000068F FFFFFFFFFFFFF41B
' Define cultures whose formatting conventions are to be used.
Dim cultures() As CultureInfo = {CultureInfo.CreateSpecificCulture("en-US"), _
                                 CultureInfo.CreateSpecificCulture("fr-FR"), _
                                 CultureInfo.CreateSpecificCulture("es-ES") }
Dim positiveNumber As Long = 1679
Dim negativeNumber As Long = -3045
Dim specifiers() As String = {"G", "C", "D8", "E2", "F", "N", "P", "X8"} 

For Each specifier As String In specifiers
   For Each culture As CultureInfo In Cultures
      ' Display values with "G" format specifier.
      Console.WriteLine("{0} format using {1} culture: {2, 16} {3, 16}", _ 
                        specifier, culture.Name, _
                        positiveNumber.ToString(specifier, culture), _
                        negativeNumber.ToString(specifier, culture))

   Next
   Console.WriteLine()
Next
' The example displays the following output to the console:
'
'    G format using en-US culture:             1679            -3045
'    G format using fr-FR culture:             1679            -3045
'    G format using es-ES culture:             1679            -3045
'
'    C format using en-US culture:        $1,679.00      ($3,045.00)
'    C format using fr-FR culture:       1 679,00 €      -3 045,00 €
'    C format using es-ES culture:       1.679,00 €      -3.045,00 €
'
'    D8 format using en-US culture:         00001679        -00003045
'    D8 format using fr-FR culture:         00001679        -00003045
'    D8 format using es-ES culture:         00001679        -00003045
'
'    E2 format using en-US culture:        1.68E+003       -3.05E+003
'    E2 format using fr-FR culture:        1,68E+003       -3,05E+003
'    E2 format using es-ES culture:        1,68E+003       -3,05E+003
'
'    F format using en-US culture:          1679.00         -3045.00
'    F format using fr-FR culture:          1679,00         -3045,00
'    F format using es-ES culture:          1679,00         -3045,00
'
'    N format using en-US culture:         1,679.00        -3,045.00
'    N format using fr-FR culture:         1 679,00        -3 045,00
'    N format using es-ES culture:         1.679,00        -3.045,00
'
'    P format using en-US culture:      167,900.00%     -304,500.00%
'    P format using fr-FR culture:     167 900,00 %    -304 500,00 %
'    P format using es-ES culture:     167.900,00 %    -304.500,00 %
'
'    X8 format using en-US culture:         0000068F FFFFFFFFFFFFF41B
'    X8 format using fr-FR culture:         0000068F FFFFFFFFFFFFF41B
'    X8 format using es-ES culture:         0000068F FFFFFFFFFFFFF41B

Comentários

O método ToString(String, IFormatProvider) formata um valor Int64 em um formato especificado usando o objeto NumberFormatInfo de uma cultura especificada. Se você quiser usar as configurações de formato ou cultura padrão, use as outras sobrecargas do método ToString da seguinte maneira:

Para usar o formato Para cultura Usar a sobrecarga
Formato padrão ("G") Cultura padrão (atual) ToString()
Formato padrão ("G") Uma cultura específica ToString(IFormatProvider)
Um formato específico Cultura padrão (atual) ToString(String)

O parâmetro format pode ser uma cadeia de caracteres de formato numérico padrão ou personalizada. Todas as cadeias de caracteres de formato numérico padrão que não sejam "R" (ou "r") têm suporte, assim como todos os caracteres de formato numérico personalizados. Se format for null ou uma cadeia de caracteres vazia (""), o valor retornado dessa instância será formatado com o especificador de formato numérico geral ("G").

O parâmetro provider é um objeto que implementa a interface IFormatProvider. Seu método GetFormat retorna um objeto NumberFormatInfo que fornece informações específicas da cultura sobre o formato da cadeia de caracteres retornada por esse método. O objeto que implementa IFormatProvider pode ser qualquer um dos seguintes:

  • Um objeto CultureInfo que representa a cultura cujas regras de formatação devem ser usadas.

  • Um objeto NumberFormatInfo que contém informações de formatação numérica específicas para esse valor.

  • Um objeto personalizado que implementa IFormatProvider e cujo método GetFormat retorna um objeto NumberFormatInfo que fornece informações de formatação.

Se provider for null ou um objeto NumberFormatInfo não puder ser obtido de provider, o valor retornado dessa instância será formatado com o NumberFormatInfo para a cultura atual.

O .NET fornece amplo suporte à formatação, que é descrito com mais detalhes nos seguintes tópicos de formatação:

Confira também

Aplica-se a