SByte.ToString Método

Definição

Espaço de Nomes:: System

Assemblagens:: mscorlib.dll, System.Runtime.dll

Assemblagens:: netstandard.dll, System.Runtime.dll

Assemblagem:: System.Runtime.dll

Assemblagem:: mscorlib.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

Converte o valor numérico desta instância para a sua representação equivalente em cadeias.

Sobrecargas

Name	Description
ToString(IFormatProvider)	Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando a informação de formato específica da cultura especificada.
ToString()	Converte o valor numérico desta instância para a sua representação equivalente em cadeias.
ToString(String)	Converte o valor numérico desta instância para a sua representação equivalente em cadeias, usando o formato especificado.
ToString(String, IFormatProvider)	Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando o formato especificado e a informação específica de formato da cultura.

ToString(IFormatProvider)

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando a informação de formato específica da cultura especificada.

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 objeto que fornece informação de formatação específica para cada cultura.

Devoluções

String

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

Implementações

ToString(IFormatProvider)

Exemplos

O exemplo seguinte define um objeto personalizado NumberFormatInfo e atribui o carácter "~" à sua NegativeSign propriedade. O exemplo usa então este objeto personalizado, bem como o NumberFormatInfo objeto da cultura invariante, para formatar uma série de SByte valores.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define a custom NumberFormatInfo object with "~" as its negative sign.
      NumberFormatInfo nfi = new NumberFormatInfo();
      nfi.NegativeSign = "~";
      
      // Initialize an array of SByte values.
      sbyte[] bytes = { -122, 17, 124 };

      // Display the formatted result using the custom provider.
      Console.WriteLine("Using the custom NumberFormatInfo object:");
      foreach (sbyte value in bytes)
         Console.WriteLine(value.ToString(nfi));

      Console.WriteLine();
          
      // Display the formatted result using the invariant culture.
      Console.WriteLine("Using the invariant culture:");
      foreach (sbyte value in bytes)
         Console.WriteLine(value.ToString(NumberFormatInfo.InvariantInfo));
   }
}
// The example displays the following output:
//       Using the custom NumberFormatInfo object:
//       ~122
//       17
//       124
//       
//       Using the invariant culture:
//       -122
//       17
//       124

open System.Globalization

// Define a custom NumberFormatInfo object with "~" as its negative sign.
let nfi = NumberFormatInfo(NegativeSign = "~")

// Initialize an array of SByte values.
let bytes = [| -122y; 17y; 124y |]

// Display the formatted result using the custom provider.
printfn "Using the custom NumberFormatInfo object:"
for value in bytes do
    printfn $"{value.ToString nfi}"

printfn ""
      
// Display the formatted result using the invariant culture.
printfn "Using the invariant culture:"
for value in bytes do
   printfn $"{value.ToString NumberFormatInfo.InvariantInfo}"
// The example displays the following output:
//       Using the custom NumberFormatInfo object:
//       ~122
//       17
//       124
//       
//       Using the invariant culture:
//       -122
//       17
//       124

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define a custom NumberFormatInfo object with "~" as its negative sign.
      Dim nfi As New NumberFormatInfo()
      nfi.NegativeSign = "~"
      
      ' Initialize an array of SByte values.
      Dim bytes() As SByte = { -122, 17, 124 }

      ' Display the formatted result using the custom provider.
      Console.WriteLine("Using the custom NumberFormatInfo object:")
      For Each value As SByte In bytes
         Console.WriteLine(value.ToString(nfi))
      Next
      Console.WriteLine()
          
      ' Display the formatted result using the invariant culture.
      Console.WriteLine("Using the invariant culture:")
      For Each value As SByte In bytes
         Console.WriteLine(value.ToString(NumberFormatInfo.InvariantInfo))
      Next   
   End Sub
End Module
' The example displays the following output:
'       Using the custom NumberFormatInfo object:
'       ~122
'       17
'       124
'       
'       Using the invariant culture:
'       -122
'       17
'       124

Observações

O ToString(IFormatProvider) método formata um SByte valor no formato padrão ("G", ou geral) 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 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 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 null valor é formatado usando o SByte objeto NumberFormatInfoda cultura atual. A única propriedade do NumberFormatInfo objeto que controla a representação em cadeia do SByte 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.

Ver também

Tipos de Formatação em .NET
Standard Numeric Format Strings (Cadeias de Formato Numérico Padrão)
Cadeias de caracteres de formato numérico personalizado

Aplica-se a

ToString()

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Converte o valor numérico desta instância para a sua representação equivalente em cadeias.

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

public override string ToString();

override this.ToString : unit -> string

Public Overrides Function ToString () As String

Devoluções

String

A representação da cadeia do valor desta instância, consistindo num sinal negativo se o valor for negativo, e numa sequência de dígitos de 0 a 9 sem zeros à esquerda.

Exemplos

O exemplo seguinte apresenta um SByte valor usando o método padrão ToString() . Apresenta também as representações das cadeias do SByte valor resultantes da utilização de vários especificadores de formato padrão. Os exemplos são apresentados usando as convenções de formatação da cultura en-US.

using System;

public class Example
{
   public static void Main()
   {
      sbyte value = -123;
      // Display value using default ToString method.
      Console.WriteLine(value.ToString());            // Displays -123
      // Display value using some standard format specifiers.
      Console.WriteLine(value.ToString("G"));         // Displays -123
      Console.WriteLine(value.ToString("C"));         // Displays ($-123.00)
      Console.WriteLine(value.ToString("D"));         // Displays -123
      Console.WriteLine(value.ToString("F"));         // Displays -123.00
      Console.WriteLine(value.ToString("N"));         // Displays -123.00
      Console.WriteLine(value.ToString("X"));         // Displays 85
   }
}

let value = -123y
// Display value using default ToString method.
printfn $"{value.ToString()}"               // Displays -123
// Display value using some standard format specifiers.
printfn $"""{value.ToString "G"}"""         // Displays -123
printfn $"""{value.ToString "C"}"""         // Displays ($-123.00)
printfn $"""{value.ToString "D"}"""         // Displays -123
printfn $"""{value.ToString "F"}"""         // Displays -123.00
printfn $"""{value.ToString "N"}"""         // Displays -123.00
printfn $"""{value.ToString "X"}"""         // Displays 85

Module Example
   Public Sub Main()
      Dim value As SByte = -123
      ' Display value using default ToString method.
      Console.WriteLine(value.ToString())            ' Displays -123
      ' Display value using some standard format specifiers.
      Console.WriteLine(value.ToString("G"))         ' Displays -123
      Console.WriteLine(value.ToString("C"))         ' Displays ($-123.00)
      Console.WriteLine(value.ToString("D"))         ' Displays -123
      Console.WriteLine(value.ToString("F"))         ' Displays -123.00
      Console.WriteLine(value.ToString("N"))         ' Displays -123.00
      Console.WriteLine(value.ToString("X"))         ' Displays 85
   End Sub
End Module

Observações

O ToString() método formata um SByte valor no formato padrão ("G", ou geral) 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 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 valor de retorno é formatado usando o especificador de formato numérico geral ("G"). A representação em cadeia do SByte valor inclui um sinal negativo se o seu valor for negativo, e uma sequência de dígitos que variam de 0 a 9 sem zeros à esquerda. O sinal negativo é definido pelo NumberFormatInfo objeto da cultura atual.

Para definir a formatação da representação da string do valor do byte assinado, chame o ToString(String) método.

Ver também

Tipos de Formatação em .NET
Standard Numeric Format Strings (Cadeias de Formato Numérico Padrão)
Cadeias de caracteres de formato numérico personalizado

Aplica-se a

ToString(String)

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Converte o valor numérico desta instância para a sua representação equivalente em cadeias, 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 formato numérico padrão ou personalizada.

Devoluções

String

A representação da cadeia do valor desta instância conforme especificado por format.

Exceções

FormatException

format é inválido.

Exemplos

O exemplo seguinte inicializa um array de SByte valores e apresenta-os usando cada cadeia de formatos padrão e algumas cadeias de formato personalizadas.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      sbyte[] values = { -124, 0, 118 };
      string[] specifiers = { "G", "C", "D3", "E2", "e3", "F", 
                              "N", "P", "X", "00.0", "#.0", 
                              "000;(0);**Zero**" };
      
      foreach (sbyte value in values)
      {
         foreach (string specifier in specifiers)
            Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier));
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       G: -124
//       C: ($124.00)
//       D3: -124
//       E2: -1.24E+002
//       e3: -1.240e+002
//       F: -124.00
//       N: -124.00
//       P: -12,400.00 %
//       X: 84
//       00.0: -124.0
//       #.0: -124.0
//       000;(0);**Zero**: (124)
//       
//       G: 0
//       C: $0.00
//       D3: 000
//       E2: 0.00E+000
//       e3: 0.000e+000
//       F: 0.00
//       N: 0.00
//       P: 0.00 %
//       X: 0
//       00.0: 00.0
//       #.0: .0
//       000;(0);**Zero**: **Zero**
//       
//       G: 118
//       C: $118.00
//       D3: 118
//       E2: 1.18E+002
//       e3: 1.180e+002
//       F: 118.00
//       N: 118.00
//       P: 11,800.00 %
//       X: 76
//       00.0: 118.0
//       #.0: 118.0
//       000;(0);**Zero**: 118

let values = [| -124y; 0y; 118y |]
let specifiers = 
    [| "G"; "C"; "D3"; "E2"; "e3"; "F" 
       "N"; "P"; "X"; "00.0"; "#.0" 
       "000(0)**Zero**" |]

for value in values do
    for specifier in specifiers do
        printfn $"{specifier}: {value.ToString specifier}"
    printfn ""
// The example displays the following output:
//       G: -124
//       C: ($124.00)
//       D3: -124
//       E2: -1.24E+002
//       e3: -1.240e+002
//       F: -124.00
//       N: -124.00
//       P: -12,400.00 %
//       X: 84
//       00.0: -124.0
//       #.0: -124.0
//       000(0)**Zero**: (124)
//       
//       G: 0
//       C: $0.00
//       D3: 000
//       E2: 0.00E+000
//       e3: 0.000e+000
//       F: 0.00
//       N: 0.00
//       P: 0.00 %
//       X: 0
//       00.0: 00.0
//       #.0: .0
//       000(0)**Zero**: **Zero**
//       
//       G: 118
//       C: $118.00
//       D3: 118
//       E2: 1.18E+002
//       e3: 1.180e+002
//       F: 118.00
//       N: 118.00
//       P: 11,800.00 %
//       X: 76
//       00.0: 118.0
//       #.0: 118.0
//       000(0)**Zero**: 118

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim values() As SByte = { -124, 0, 118 }
      Dim specifiers() As String = { "G", "C", "D3", "E2", "e3", "F", _
                                     "N", "P", "X", "00.0", "#.0", _
                                     "000;(0);**Zero**" }
      
      For Each value As SByte In values
         For Each specifier As String In specifiers
            Console.WriteLine("{0}: {1}", specifier, value.ToString(specifier))
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'       G: -124
'       C: ($124.00)
'       D3: -124
'       E2: -1.24E+002
'       e3: -1.240e+002
'       F: -124.00
'       N: -124.00
'       P: -12,400.00 %
'       X: 84
'       00.0: -124.0
'       #.0: -124.0
'       000;(0);**Zero**: (124)
'       
'       G: 0
'       C: $0.00
'       D3: 000
'       E2: 0.00E+000
'       e3: 0.000e+000
'       F: 0.00
'       N: 0.00
'       P: 0.00 %
'       X: 0
'       00.0: 00.0
'       #.0: .0
'       000;(0);**Zero**: **Zero**
'       
'       G: 118
'       C: $118.00
'       D3: 118
'       E2: 1.18E+002
'       e3: 1.180e+002
'       F: 118.00
'       N: 118.00
'       P: 11,800.00 %
'       X: 76
'       00.0: 118.0
'       #.0: 118.0
'       000;(0);**Zero**: 118

Observações

O ToString(String) método formata um SByte valor num formato especificado usando as convenções da cultura atual. Se quiser usar o formato padrão ("G", ou geral) 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 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 format parâmetro pode ser qualquer especificador válido de formato numérico padrão, ou qualquer combinação de especificadores de formato numérico personalizados. Se format for igual a String.Empty ou for null, o valor de retorno do objeto atual SByte é formatado com o especificador geral de formato ("G"). 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

Tipos de Formatação em .NET
Como: Preencher um número com zeros à esquerda
Standard Numeric Format Strings (Cadeias de Formato Numérico Padrão)
Cadeias de caracteres de formato numérico personalizado

Aplica-se a

ToString(String, IFormatProvider)

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Origem:: SByte.cs

Converte o valor numérico desta instância para a sua representação equivalente de cadeias usando o formato especificado e a informação específica de formato 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 formato numérico padrão ou personalizada.

provider: IFormatProvider

Um objeto que fornece informação de formatação específica para cada cultura.

Devoluções

String

A representação da cadeia do valor desta instância conforme especificado por format e provider.

Implementações

ToString(String, IFormatProvider)

Exceções

FormatException

format é inválido.

Exemplos

O exemplo seguinte apresenta tanto um valor positivo como um negativo SByte usando os especificadores de formato numérico padrão e vários objetos específicos CultureInfo .

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define cultures whose formatting conventions are to be used.
      CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"), 
                                 CultureInfo.CreateSpecificCulture("fr-FR"), 
                                 CultureInfo.CreateSpecificCulture("es-ES") };
      sbyte positiveNumber = 119;
      sbyte negativeNumber = -45;
      string[] specifiers = {"G", "C", "D4", "E2", "F", "N", "P", "X2"}; 
      
      foreach (string specifier in specifiers)
      {
         foreach (CultureInfo culture in cultures)
            Console.WriteLine("{0,2} 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:
//     G format using en-US culture:              119              -45
//     G format using fr-FR culture:              119              -45
//     G format using es-ES culture:              119              -45
//    
//     C format using en-US culture:          $119.00         ($45.00)
//     C format using fr-FR culture:         119,00 €         -45,00 €
//     C format using es-ES culture:         119,00 €         -45,00 €
//    
//    D4 format using en-US culture:             0119            -0045
//    D4 format using fr-FR culture:             0119            -0045
//    D4 format using es-ES culture:             0119            -0045
//    
//    E2 format using en-US culture:        1.19E+002       -4.50E+001
//    E2 format using fr-FR culture:        1,19E+002       -4,50E+001
//    E2 format using es-ES culture:        1,19E+002       -4,50E+001
//    
//     F format using en-US culture:           119.00           -45.00
//     F format using fr-FR culture:           119,00           -45,00
//     F format using es-ES culture:           119,00           -45,00
//    
//     N format using en-US culture:           119.00           -45.00
//     N format using fr-FR culture:           119,00           -45,00
//     N format using es-ES culture:           119,00           -45,00
//    
//     P format using en-US culture:      11,900.00 %      -4,500.00 %
//     P format using fr-FR culture:      11 900,00 %      -4 500,00 %
//     P format using es-ES culture:      11.900,00 %      -4.500,00 %
//    
//    X2 format using en-US culture:               77               D3
//    X2 format using fr-FR culture:               77               D3
//    X2 format using es-ES culture:               77               D3

open System.Globalization

// 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 = 119y
let negativeNumber = -45y
let specifiers = [| "G"; "C"; "D4"; "E2"; "F"; "N"; "P"; "X2" |]

for specifier in specifiers do
    for culture in cultures do
        printfn $"{specifier,2} format using {culture.Name} culture: {positiveNumber.ToString(specifier, culture), 16} {negativeNumber.ToString(specifier, culture), 16}"
    printfn ""
// The example displays the following output:
//     G format using en-US culture:              119              -45
//     G format using fr-FR culture:              119              -45
//     G format using es-ES culture:              119              -45
//    
//     C format using en-US culture:          $119.00         ($45.00)
//     C format using fr-FR culture:         119,00 €         -45,00 €
//     C format using es-ES culture:         119,00 €         -45,00 €
//    
//    D4 format using en-US culture:             0119            -0045
//    D4 format using fr-FR culture:             0119            -0045
//    D4 format using es-ES culture:             0119            -0045
//    
//    E2 format using en-US culture:        1.19E+002       -4.50E+001
//    E2 format using fr-FR culture:        1,19E+002       -4,50E+001
//    E2 format using es-ES culture:        1,19E+002       -4,50E+001
//    
//     F format using en-US culture:           119.00           -45.00
//     F format using fr-FR culture:           119,00           -45,00
//     F format using es-ES culture:           119,00           -45,00
//    
//     N format using en-US culture:           119.00           -45.00
//     N format using fr-FR culture:           119,00           -45,00
//     N format using es-ES culture:           119,00           -45,00
//    
//     P format using en-US culture:      11,900.00 %      -4,500.00 %
//     P format using fr-FR culture:      11 900,00 %      -4 500,00 %
//     P format using es-ES culture:      11.900,00 %      -4.500,00 %
//    
//    X2 format using en-US culture:               77               D3
//    X2 format using fr-FR culture:               77               D3
//    X2 format using es-ES culture:               77               D3

Imports System.Globalization

Module Example
   Public Sub Main()
      ' 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 SByte = 119
      Dim negativeNumber As SByte = -45
      Dim specifiers() As String = {"G", "C", "D4", "E2", "F", "N", "P", "X2"} 
      
      For Each specifier As String In specifiers
         For Each culture As CultureInfo In Cultures
            Console.WriteLine("{0,2} format using {1} culture: {2, 16} {3, 16}", _ 
                              specifier, culture.Name, _
                              positiveNumber.ToString(specifier, culture), _
                              negativeNumber.ToString(specifier, culture))

         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'     G format using en-US culture:              119              -45
'     G format using fr-FR culture:              119              -45
'     G format using es-ES culture:              119              -45
'    
'     C format using en-US culture:          $119.00         ($45.00)
'     C format using fr-FR culture:         119,00 €         -45,00 €
'     C format using es-ES culture:         119,00 €         -45,00 €
'    
'    D4 format using en-US culture:             0119            -0045
'    D4 format using fr-FR culture:             0119            -0045
'    D4 format using es-ES culture:             0119            -0045
'    
'    E2 format using en-US culture:        1.19E+002       -4.50E+001
'    E2 format using fr-FR culture:        1,19E+002       -4,50E+001
'    E2 format using es-ES culture:        1,19E+002       -4,50E+001
'    
'     F format using en-US culture:           119.00           -45.00
'     F format using fr-FR culture:           119,00           -45,00
'     F format using es-ES culture:           119,00           -45,00
'    
'     N format using en-US culture:           119.00           -45.00
'     N format using fr-FR culture:           119,00           -45,00
'     N format using es-ES culture:           119,00           -45,00
'    
'     P format using en-US culture:      11,900.00 %      -4,500.00 %
'     P format using fr-FR culture:      11 900,00 %      -4 500,00 %
'     P format using es-ES culture:      11.900,00 %      -4.500,00 %
'    
'    X2 format using en-US culture:               77               D3
'    X2 format using fr-FR culture:               77               D3
'    X2 format using es-ES culture:               77               D3

Observações

O ToString(String, IFormatProvider) método formata um SByte valor num formato especificado de uma cultura especificada. Se quiser usar definições de formato ou cultura por defeito, use as outras sobrecargas do ToString método, da seguinte forma:

Para usar o formato	Pela cultura	Usa 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 .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 IFormatProvider.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

Aplica-se a

Comentários

Esta página foi útil?