Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

Estrutura Byte

 
System_CAPS_noteObservação

The .NET API Reference documentation has a new home. Visit the .NET API Browser on docs.microsoft.com to see the new experience.

Representa um inteiro sem sinal de 8 bits.

Namespace:   System
Assembly:  mscorlib (em mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public struct Byte : IComparable, IFormattable, IConvertible, 
	IComparable<byte>, IEquatable<byte>

NomeDescrição
System_CAPS_pubmethodCompareTo(Byte)

Compara essa instância com um inteiro sem sinal de 8 bits especificado e retorna uma indicação dos valores relativos.

System_CAPS_pubmethodCompareTo(Object)

Compara essa instância com um objeto especificado e retorna uma indicação dos valores relativos.

System_CAPS_pubmethodEquals(Byte)

Retorna um valor que indica se essa instância e um objeto Byte especificado representam o mesmo valor.

System_CAPS_pubmethodEquals(Object)

Retorna um valor que indica se essa instância é igual a um objeto especificado.(Substitui o ValueType.Equals(Object).)

System_CAPS_pubmethodGetHashCode()

Retorna o código hash para essa instância.(Substitui o ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtém o Type da instância atual.(Herdado de Object.)

System_CAPS_pubmethodGetTypeCode()

Retorna o TypeCode para tipo de valor Byte.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Converte a representação da cadeia de caracteres de um número no Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato específico da cultura especificado em seu equivalente de Byte.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu Byte equivalente.

System_CAPS_pubmethodToString()

Converte o valor do atual objeto Byte na representação de cadeia de caracteres equivalente.(Substitui o ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Converte o valor numérico do objeto Byte atual em sua representação de cadeia de caracteres equivalente usando as informações de formatação específicas da cultura especificada.

System_CAPS_pubmethodToString(String)

Converte o valor do objeto Byte atual em sua representação de cadeia de caracteres equivalente usando o formato especificado.

System_CAPS_pubmethodToString(String, IFormatProvider)

Converte o valor do objeto Byte atual na representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formatação específicas da cultura.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Byte)

Tenta converter a representação de cadeia de caracteres de seu equivalente de Byte e retorna um valor que indica se a conversão foi bem-sucedida.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Byte)

Converte a representação de cadeia de caracteres de um número com um estilo especificado e um formato específico à cultura para seu Byte equivalente. Um valor de retorno indica se a conversão foi bem-sucedida ou falhou.

NomeDescrição
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Representa o maior valor possível de um Byte. Este campo é constante.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Representa o menor valor possível de um Byte. Este campo é constante.

NomeDescrição
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Esta conversão não é suportada. A tentativa de usar esse método lança um InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API dá suporte à infraestrutura produto e não se destina a ser usada diretamente do seu código. Para obter uma descrição desse membro, consulte IConvertible.ToUInt64.

Byteé um tipo de valor imutável que representa inteiros sem sinal com valores que variam de 0 (que é representado pelo Byte.MinValue constante) a 255 (que é representado pelo Byte.MaxValue constante). O .NET Framework também inclui um tipo de valor inteiro assinado de 8 bits, SByte, que representa valores que variam de -128 a 127.

Você pode instanciar uma Byte valor de várias maneiras:

  • Você pode declarar uma Byte variável e atribuir a ela um valor literal de inteiro que está dentro do intervalo da Byte tipo de dados. O exemplo a seguir declara duas Byte variáveis e atribui os valores dessa maneira.

    byte value1 = 64;
    byte value2 = 255;
    
  • Você pode atribuir um valor de byte não numérico de um byte. Isso é uma conversão de restrição, isso requer um operador de conversão em c# e um método de conversão no Visual Basic se OptionStrict está em. Se o valor de byte não é um Single, Double, ou Decimal valor que inclui um componente fracionário, a manipulação de sua parte fracionária depende do compilador a conversão. O exemplo a seguir atribui vários valores numéricos para Byte variáveis.

    int int1 = 128;
    try {
       byte value1 = (byte) int1;
       Console.WriteLine(value1);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of a byte.", int1);
    }
    
    double dbl2 = 3.997;
    try {
       byte value2 = (byte) dbl2;
       Console.WriteLine(value2);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of a byte.", dbl2);
    }
    // The example displays the following output:
    //       128
    //       3
    
  • Você pode chamar um método do Convert suporte de classe para converter qualquer tipo para um Byte valor. Isso é possível porque Byte oferece suporte a IConvertible interface. O exemplo a seguir ilustra a conversão de uma matriz de Int32 valores Byte valores.

    int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
    byte result;
    foreach (int number in numbers)
    {
       try {
          result = Convert.ToByte(number);
          Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", 
                            number.GetType().Name, number, 
                            result.GetType().Name, result);
       }                     
       catch (OverflowException) {
          Console.WriteLine("The {0} value {1} is outside the range of the Byte type.", 
                            number.GetType().Name, number);
       }
    }
    // The example displays the following output:
    //       The Int32 value -2147483648 is outside the range of the Byte type.
    //       The Int32 value -1 is outside the range of the Byte type.
    //       Converted the Int32 value 0 to the Byte value 0.
    //       Converted the Int32 value 121 to the Byte value 121.
    //       The Int32 value 340 is outside the range of the Byte type.
    //       The Int32 value 2147483647 is outside the range of the Byte type.      
    
  • Você pode chamar o Parse ou TryParse método para converter a representação de cadeia de caracteres de um Byte valor para um Byte. A cadeia de caracteres pode conter dígitos decimais ou hexadecimais. O exemplo a seguir ilustra a operação de análise por meio de um decimal e uma cadeia de caracteres hexadecimal.

    string string1 = "244";
    try {
       byte byte1 = Byte.Parse(string1);
       Console.WriteLine(byte1);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string1);
    }
    catch (FormatException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string1);
    }
    
    string string2 = "F9";
    try {
       byte byte2 = Byte.Parse(string2, 
                               System.Globalization.NumberStyles.HexNumber);
       Console.WriteLine(byte2);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string2);
    }
    catch (FormatException) {
       Console.WriteLine("'{0}' is out of range of a byte.", string2);
    }
    // The example displays the following output:
    //       244
    //       249
    

O Byte tipo oferece suporte a operações matemáticas padrão, como adição, subtração, divisão, multiplicação, subtração, negação e negação unário. Como os outros tipos integrais de Byte tipo também suporta o bit a bit AND, OR, XOR, esquerdo shift e operadores de deslocamento para a direita.

Você pode usar os operadores numéricos padrão para comparar dois Byte valores, ou você pode chamar o CompareTo ou Equals método.

Também é possível chamar os membros da classe Math para realizar uma ampla variedade de operações numéricas, inclusive obter o valor absoluto de um número, calcular o quociente e o restante da divisão integral, determinando o valor máximo ou mínimo de dois inteiros, obter o sinal de um número e arredondar um número.

O Byte tipo fornece suporte completo para cadeias de caracteres de formato numérico padrão e personalizados. (Para obter mais informações, consulte Formatando tipos no .NET Framework, Cadeias de caracteres de formato numérico padrão, e Cadeias de caracteres de formato numérico personalizado.) No entanto, geralmente, valores de byte são representados como valores de um dígito de três dígitos sem qualquer formatação adicionais ou como valores de dois dígitos hexadecimais.

Para formatar um Byte valor como uma cadeia de caracteres integral com sem zeros à esquerda, você pode chamar o sem parâmetros ToString() método. Usando o especificador de formato "D", você também pode incluir um número especificado de zeros à esquerda na representação de cadeia de caracteres. Usando o especificador de formato "X", você pode representar um Byte valor como uma cadeia de caracteres hexadecimal. O exemplo a seguir formata os elementos em uma matriz de Byte valores dessas três maneiras.

byte[] numbers = { 0, 16, 104, 213 };
foreach (byte number in numbers) {
   // Display value using default formatting.
   Console.Write("{0,-3}  -->   ", number.ToString());
   // Display value with 3 digits and leading zeros.
   Console.Write(number.ToString("D3") + "   ");
   // Display value with hexadecimal.
   Console.Write(number.ToString("X2") + "   ");
   // Display value with four hexadecimal digits.
   Console.WriteLine(number.ToString("X4"));
}   
// The example displays the following output:
//       0    -->   000   00   0000
//       16   -->   016   10   0010
//       104  -->   104   68   0068
//       213  -->   213   D5   00D5      

Você também pode formatar uma Byte valor como um binário, octal, cadeia de caracteres decimal ou hexadecimal chamando o ToString(Byte, Int32) método e fornecer a base do segundo parâmetro do método. O exemplo a seguir chama esse método para exibir o binário, octal e representações hexadecimais de uma matriz de valores de byte.

byte[] numbers ={ 0, 16, 104, 213 };
Console.WriteLine("{0}   {1,8}   {2,5}   {3,5}",
                  "Value", "Binary", "Octal", "Hex");
foreach (byte number in numbers) {
   Console.WriteLine("{0,5}   {1,8}   {2,5}   {3,5}",
                     number, Convert.ToString(number, 2),
                     Convert.ToString(number, 8),
                     Convert.ToString(number, 16));
}      
// The example displays the following output:
//       Value     Binary   Octal     Hex
//           0          0       0       0
//          16      10000      20      10
//         104    1101000     150      68
//         213   11010101     325      d5      

Além de trabalhar com bytes individuais como valores decimais, você talvez queira executar operações bit a bit com valores de byte ou trabalhar com matrizes de bytes ou com as representações binárias ou hexadecimais de valores de byte. Por exemplo, sobrecargas do BitConverter.GetBytes método pode converter cada um dos tipos de dados primitivos em uma matriz de bytes e o BigInteger.ToByteArray método converte um BigInteger valor para uma matriz de bytes.

Bytevalores são representados em 8 bits por sua magnitude somente, sem um bit de sinal. Isso é importante ter em mente ao executar operações bit a bit em Byte valores ou quando você trabalha com bits individuais. Para executar um numérico, booleano ou operação de comparação em quaisquer dois valores decimais não, os dois valores devem usar a mesma representação.

Quando uma operação é executada em dois Byte valores, os valores compartilham a mesma representação, portanto, o resultado é preciso. Isso é ilustrado no exemplo a seguir, que oculta o bit de ordem inferior de uma Byte valor para garantir que ele mesmo.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] values = { Convert.ToString(12, 16), 
                          Convert.ToString(123, 16), 
                          Convert.ToString(245, 16) };

      byte mask = 0xFE;
      foreach (string value in values) {
         Byte byteValue = Byte.Parse(value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} And {1} = {2}", byteValue, mask,  
                           byteValue & mask);
      }
   }
}
// The example displays the following output:
//       12 And 254 = 12
//       123 And 254 = 122
//       245 And 254 = 244

Por outro lado, quando você trabalha com bits sem sinal e assinados, operações bit a bit são complicadas pelo fato de que o SByte valores usam a representação de entrada e magnitude dos valores positivos e dois complemento representação dos valores negativos. Para executar uma operação bit a bit significativa, os valores devem ser convertidos para duas representações equivalentes, e informações sobre o bit de sinal devem ser preservadas. O exemplo a seguir faz isso para a máscara de bits, 2 e 4 de uma matriz de valores de 8 bits assinados e não assinados.

using System;
using System.Collections.Generic;
using System.Globalization;

public struct ByteString
{
   public string Value;
   public int Sign;
}

public class Example
{
   public static void Main()
   {
      ByteString[] values = CreateArray(-15, 123, 245);

      byte mask = 0x14;        // Mask all bits but 2 and 4.

      foreach (ByteString strValue in values) {
         byte byteValue = Byte.Parse(strValue.Value, NumberStyles.AllowHexSpecifier);
         Console.WriteLine("{0} ({1}) And {2} ({3}) = {4} ({5})", 
                           strValue.Sign * byteValue, 
                           Convert.ToString(byteValue, 2), 
                           mask, Convert.ToString(mask, 2), 
                           (strValue.Sign & Math.Sign(mask)) * (byteValue & mask), 
                           Convert.ToString(byteValue & mask, 2));
      }
   }

   private static ByteString[] CreateArray(params int[] values)
   {
      List<ByteString> byteStrings = new List<ByteString>();

      foreach (object value in values) {
         ByteString temp = new ByteString();
         int sign = Math.Sign((int) value);
         temp.Sign = sign;

         // Change two's complement to magnitude-only representation.
         temp.Value = Convert.ToString(((int) value) * sign, 16);

         byteStrings.Add(temp);
      }
      return byteStrings.ToArray();
   }
}
// The example displays the following output:
//       -15 (1111) And 20 (10100) = 4 (100)
//       123 (1111011) And 20 (10100) = 16 (10000)
//       245 (11110101) And 20 (10100) = 20 (10100)

Plataforma Universal do Windows
Disponível desde 8
.NET Framework
Disponível desde 1.1
Biblioteca de Classes Portátil
Com suporte no: plataformas portáteis do .NET
Silverlight
Disponível desde 2.0
Windows Phone Silverlight
Disponível desde 7.0
Windows Phone
Disponível desde 8.1

Todos os membros desse tipo são thread-safe. Os membros que aparentam modificar efetivamente o estado retornam uma nova instância inicializada com o novo valor. Assim como acontece com qualquer outro tipo, a leitura e a gravação em uma variável compartilhada que contém uma instância desse tipo devem ser protegidas por um bloqueio para garantir thread-safe.

Retornar ao início
Mostrar: