Int64.ToString Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

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

String

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

Implementações

ToString(IFormatProvider)

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:

Para obter mais informações sobre especificadores de formato numérico, consulte cadeias de caracteres de formato numérico padrão e cadeias de caracteres de formato numérico personalizado.
Para obter mais informações sobre formatação, consulte Tipos de Formatação.

Confira também

Parse(String)
String
tipos de formatação no .NET

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

String

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:

Para obter mais informações sobre especificadores de formato numérico, consulte cadeias de caracteres de formato numérico padrão e cadeias de caracteres de formato numérico personalizado.
Para obter mais informações sobre formatação, consulte Tipos de Formatação.

Confira também

Parse(String)
String
tipos de formatação no .NET

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

String

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

Exceções

FormatException

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:

Para obter mais informações sobre especificadores de formato numérico, cadeias de caracteres de formato numérico padrão e cadeias de caracteres de formato numérico personalizado.
Para obter mais informações sobre formatação, consulte Tipos de Formatação.

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

Confira também

Parse(String)
String
tipos de formatação no .NET
cadeias de caracteres de formato numérico padrão
cadeias de caracteres de formato numérico personalizado
Como adicionar um número com zeros à esquerda

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

String

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

Implementações

ToString(String, IFormatProvider)

Exceções

FormatException

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

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:

Para obter mais informações sobre especificadores de formato numérico, consulte cadeias de caracteres de formato numérico padrão e cadeias de caracteres de formato numérico personalizado.
Para obter mais informações sobre formatação, consulte Tipos de Formatação.

Confira também

Parse(String)
tipos de formatação no .NET
cadeias de caracteres de formato numérico padrão
cadeias de caracteres de formato numérico personalizado
Como adicionar um número com zeros à esquerda
Exemplo de : Utilitário de Formatação do WinForms do .NET Core (C#)
Exemplo de : Utilitário de Formatação winforms do .NET Core (Visual Basic)

Aplica-se a

Compartilhar via

Int64.ToString Método

Definição

Sobrecargas

ToString(IFormatProvider)

Parâmetros

Retornos

Implementações

Exemplos

Comentários

Confira também

Aplica-se a

ToString()

Retornos

Exemplos

Comentários

Confira também

Aplica-se a

ToString(String)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

ToString(String, IFormatProvider)

Parâmetros

Retornos

Implementações

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Comentários

Recursos adicionais