Byte.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 do objeto atual Byte para a sua representação equivalente em cadeias.

Sobrecargas

Name	Description
ToString()	Converte o valor do objeto atual Byte para a sua representação equivalente em cadeias.
ToString(IFormatProvider)	Converte o valor numérico do objeto atual Byte para a sua representação equivalente em cadeia usando a informação de formatação específica para cultura.
ToString(String)	Converte o valor do objeto atual Byte para a sua representação equivalente de cadeias usando o formato especificado.
ToString(String, IFormatProvider)	Converte o valor do objeto atual Byte para a sua representação equivalente de cadeias usando o formato especificado e a informação de formatação específica da cultura.

ToString()

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte o valor do objeto atual Byte 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 deste objeto, que consiste numa sequência de dígitos que variam de 0 a 9, sem zeros à esquerda.

Exemplos

O exemplo seguinte apresenta um array de valores de bytes. Note-se que o ToString() método não é chamado explicitamente no exemplo. Em vez disso, é chamada implicitamente, devido à utilização da funcionalidade de formatação composta , o exemplo de F# usa interpolação de strings.

byte[] bytes = {0, 1, 14, 168, 255};
foreach (byte byteValue in bytes)
   Console.WriteLine(byteValue);
// The example displays the following output to the console if the current
// culture is en-US:
//       0
//       1
//       14
//       168
//       255

let bytes = [| 0; 1; 14; 168; 255 |]
for byteValue in bytes do
    printfn $"{byteValue}"

// The example displays the following output to the console if the current
// culture is en-US:
//       0
//       1
//       14
//       168
//       255

Dim bytes() As Byte = {0, 1, 14, 168, 255}
For Each byteValue As Byte In Bytes
   Console.WriteLine(byteValue)
Next   
' The example displays the following output to the console if the current
' culture is en-US:
'       0
'       1
'       14
'       168
'       255

Observações

O valor de retorno é formatado com o especificador de formato numérico geral ("G") e o NumberFormatInfo objeto para a cultura atual do thread. Para definir a formatação da Byte representação da cadeia do valor, chama o ToString método. Para definir tanto os especificadores de formato como a cultura usados para criar a representação de cadeias de um Byte valor, chama o ToString método.

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 formatação, consulte Tipos de Formatação.

Para informações sobre a cultura atual do tópico, veja Thread.CurrentCulture.

Aplica-se a

ToString(IFormatProvider)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte o valor numérico do objeto atual Byte para a sua representação equivalente em cadeia usando a informação de formatação específica para cultura.

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 string do valor deste objeto no formato especificado pelo provider parâmetro.

Implementações

ToString(IFormatProvider)

Exemplos

O exemplo seguinte itera um array de valores de bytes e apresenta cada um deles à consola, chamando o ToString(IFormatProvider) método com diferentes fornecedores de formato.

byte[] bytes = {0, 1, 14, 168, 255};
CultureInfo[] providers = {new CultureInfo("en-us"),
                           new CultureInfo("fr-fr"),
                           new CultureInfo("de-de"),
                           new CultureInfo("es-es")};
foreach (byte byteValue in bytes)
{
   foreach (CultureInfo provider in providers)
      Console.Write("{0,3} ({1})      ",
                    byteValue.ToString(provider), provider.Name);

   Console.WriteLine();
}
// The example displays the following output to the console:
//      0 (en-US)        0 (fr-FR)        0 (de-DE)        0 (es-ES)
//      1 (en-US)        1 (fr-FR)        1 (de-DE)        1 (es-ES)
//     14 (en-US)       14 (fr-FR)       14 (de-DE)       14 (es-ES)
//    168 (en-US)      168 (fr-FR)      168 (de-DE)      168 (es-ES)
//    255 (en-US)      255 (fr-FR)      255 (de-DE)      255 (es-ES)

let bytes = [| 0; 1; 14; 168; 255 |]
let providers = 
    [ CultureInfo "en-us"
      CultureInfo "fr-fr"
      CultureInfo "de-de"
      CultureInfo "es-es" ]

for byteValue in bytes do
    for provider in providers do
        printf $"{byteValue.ToString provider,3} ({provider.Name})      " 

    printfn ""

// The example displays the following output to the console:
//      0 (en-US)        0 (fr-FR)        0 (de-DE)        0 (es-ES)
//      1 (en-US)        1 (fr-FR)        1 (de-DE)        1 (es-ES)
//     14 (en-US)       14 (fr-FR)       14 (de-DE)       14 (es-ES)
//    168 (en-US)      168 (fr-FR)      168 (de-DE)      168 (es-ES)
//    255 (en-US)      255 (fr-FR)      255 (de-DE)      255 (es-ES)

Dim bytes() As Byte = {0, 1, 14, 168, 255}
Dim providers() As CultureInfo = {New CultureInfo("en-us"), _
                                  New CultureInfo("fr-fr"), _
                                  New CultureInfo("de-de"), _
                                  New CultureInfo("es-es")}
For Each byteValue As Byte In bytes
   For Each provider As CultureInfo In providers
      Console.Write("{0,3} ({1})      ", byteValue.ToString(provider), provider.Name)
   Next
   Console.WriteLine()                                        
Next
' The example displays the following output to the console:
'      0 (en-US)        0 (fr-FR)        0 (de-DE)        0 (es-ES)
'      1 (en-US)        1 (fr-FR)        1 (de-DE)        1 (es-ES)
'     14 (en-US)       14 (fr-FR)       14 (de-DE)       14 (es-ES)
'    168 (en-US)      168 (fr-FR)      168 (de-DE)      168 (es-ES)
'    255 (en-US)      255 (fr-FR)      255 (de-DE)      255 (es-ES)

Observações

O valor de retorno é formatado com o especificador de formato numérico geral ("G").

O provider parâmetro é um objeto que implementa a IFormatProvider interface. O seu GetFormat método devolve um NumberFormatInfo objeto que fornece informação específica da cultura sobre o formato da cadeia que é devolvida por este método. O objeto que implementa IFormatProvider pode ser qualquer um dos seguintes:

Um CultureInfo objeto que representa a cultura cujas regras de formatação devem ser usadas.
Um NumberFormatInfo objeto que contenha informação numérica específica de formatação para esse valor.
Um objeto personalizado que implementa IFormatProvider.

Se provider for ou um null objeto não puder ser obtido a partir de NumberFormatInfo, o valor de retorno é formatado usando o provider objeto para a cultura corrente NumberFormatInfo de threads. Para informações sobre a cultura atual do tópico, veja Thread.CurrentCulture.

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 formatação, consulte Tipos de Formatação.

Ver também

Aplica-se a

ToString(String)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte o valor do objeto atual Byte para a sua representação equivalente de 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.

Devoluções

String

A representação da string do objeto atual Byte , formatada conforme especificado pelo format parâmetro.

Exceções

FormatException

format inclui um especificador sem suporte. Os especificadores de formato suportados estão listados na secção de Observações.

Exemplos

O exemplo seguinte inicializa um Byte valor e mostra-o na consola usando cada uma das strings de formato padrão suportadas e uma string de formato personalizada. O exemplo é gerido com en-US como cultura atual.

string[] formats = {"C3", "D4", "e1", "E2", "F1", "G", "N1",
                    "P0", "X4", "0000.0000"};
byte number = 240;
foreach (string format in formats)
   Console.WriteLine("'{0}' format specifier: {1}",
                     format, number.ToString(format));

// The example displays the following output to the console if the
// current culture is en-us:
//       'C3' format specifier: $240.000
//       'D4' format specifier: 0240
//       'e1' format specifier: 2.4e+002
//       'E2' format specifier: 2.40E+002
//       'F1' format specifier: 240.0
//       'G' format specifier: 240
//       'N1' format specifier: 240.0
//       'P0' format specifier: 24,000 %
//       'X4' format specifier: 00F0
//       '0000.0000' format specifier: 0240.0000

let formats = 
    [ "C3"; "D4"; "e1"; "E2"; "F1"; "G"; "N1"
      "P0"; "X4"; "0000.0000" ]
let number = 240uy
for format in formats do
    printfn $"'{format}' format specifier: {number.ToString format}"

// The example displays the following output to the console if the
// current culture is en-us:
//       'C3' format specifier: $240.000
//       'D4' format specifier: 0240
//       'e1' format specifier: 2.4e+002
//       'E2' format specifier: 2.40E+002
//       'F1' format specifier: 240.0
//       'G' format specifier: 240
//       'N1' format specifier: 240.0
//       'P0' format specifier: 24,000 %
//       'X4' format specifier: 00F0
//       '0000.0000' format specifier: 0240.0000

Dim formats() As String = {"C3", "D4", "e1", "E2", "F1", "G", _
                           "N1", "P0", "X4", "0000.0000"}
Dim number As Byte = 240
For Each format As String In formats
   Console.WriteLine("'{0}' format specifier: {1}", _
                     format, number.ToString(format))
Next  
' The example displays the following output to the console if the
' current culture is en-us:
'       'C3' format specifier: $240.000
'       'D4' format specifier: 0240
'       'e1' format specifier: 2.4e+002
'       'E2' format specifier: 2.40E+002
'       'F1' format specifier: 240.0       
'       'G' format specifier: 240
'       'N1' format specifier: 240.0
'       'P0' format specifier: 24,000 %
'       'X4' format specifier: 00F0
'       '0000.0000' format specifier: 0240.0000

Observações

O format parâmetro pode ser uma cadeia de formato padrão ou numérica personalizada. Todas as cadeias de formato numérico padrão, exceto "R" (ou "r"), são suportadas, assim como todos os caracteres numéricos personalizados. Se format for null ou uma cadeia vazia (""), o valor de retorno é formatado com o especificador de formato numérico geral ("G").

O valor de retorno desta função é formatado usando o NumberFormatInfo objeto para a cultura atual do thread. Para informações sobre a cultura atual do tópico, veja Thread.CurrentCulture. Para fornecer informação de formatação para culturas diferentes da cultura atual, ligue para o Byte.ToString(String, IFormatProvider) método.

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 formatação, consulte Tipos de Formatação.

Ver também

Como: Preencher um número com zeros à esquerda

Aplica-se a

ToString(String, IFormatProvider)

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Origem:: Byte.cs

Converte o valor do objeto atual Byte para a sua representação equivalente de cadeias usando o formato especificado e a informação de formatação específica 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 objeto atualByte, formatada conforme especificado pelos format parâmetros e.provider

Implementações

ToString(String, IFormatProvider)

Exceções

FormatException

format inclui um especificador sem suporte. Os especificadores de formato suportados estão listados na secção de Observações.

Exemplos

O exemplo seguinte utiliza a string padrão do formato "N" e quatro objetos diferentes CultureInfo para mostrar a representação da string de um valor de byte para a consola.

byte byteValue = 250;
CultureInfo[] providers = {new CultureInfo("en-us"),
                           new CultureInfo("fr-fr"),
                           new CultureInfo("es-es"),
                           new CultureInfo("de-de")};

foreach (CultureInfo provider in providers)
   Console.WriteLine("{0} ({1})",
                     byteValue.ToString("N2", provider), provider.Name);
// The example displays the following output to the console:
//       250.00 (en-US)
//       250,00 (fr-FR)
//       250,00 (es-ES)
//       250,00 (de-DE)

let byteValue = 250uy
let providers = 
    [ CultureInfo "en-us"
      CultureInfo "fr-fr"
      CultureInfo "es-es"
      CultureInfo "de-de" ]

for provider in providers do
    printfn $"""{byteValue.ToString("N2", provider)} ({provider.Name})"""

// The example displays the following output to the console:
//       250.00 (en-US)
//       250,00 (fr-FR)
//       250,00 (es-ES)
//       250,00 (de-DE)

Dim byteValue As Byte = 250
Dim providers() As CultureInfo = {New CultureInfo("en-us"), _
                                  New CultureInfo("fr-fr"), _
                                  New CultureInfo("es-es"), _
                                  New CultureInfo("de-de")} 
For Each provider As CultureInfo In providers 
   Console.WriteLine("{0} ({1})", _
                     byteValue.ToString("N2", provider), provider.Name)
Next   
' The example displays the following output to the console:
'       250.00 (en-US)
'       250,00 (fr-FR)
'       250,00 (es-ES)
'       250,00 (de-DE)

Observações

O ToString(String, IFormatProvider) método formata um Byte valor num formato especificado de uma cultura especificada. Para formatar um número usando o formato padrão ("G") da cultura atual, chame o ToString() método. Para formatar um número usando um formato especificado da cultura atual, chame o ToString(String) método.

O format parâmetro pode ser uma cadeia de formato padrão ou numérica personalizada. Todas as cadeias de formato numérico padrão, exceto "R" (ou "r"), são suportadas, assim como todos os caracteres numéricos personalizados. Se format for null ou uma cadeia vazia (""), o valor de retorno deste método é formatado com o especificador de formato numérico geral ("G").

Um CultureInfo objeto que representa a cultura cujas regras de formatação devem ser usadas.
Um NumberFormatInfo objeto que contenha informação numérica específica de formatação para esse valor.
Um objeto personalizado que implementa IFormatProvider.

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 formatação, consulte Tipos de Formatação.

Ver também

Aplica-se a

Comentários

Esta página foi útil?