Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Estructura Byte

 

Publicado: octubre de 2016

Representa un entero de 8 bits sin signo.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

NombreDescripción
System_CAPS_pubmethodCompareTo(Byte)

Compara esta instancia con un entero de 8 bits sin signo y devuelve una indicación de los valores relativos.

System_CAPS_pubmethodCompareTo(Object)

Compara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos.

System_CAPS_pubmethodEquals(Byte)

Devuelve un valor que indica si esta instancia y un objeto Byte especificado representan el mismo valor.

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.(Invalida ValueType.Equals(Object)).

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash de esta instancia.(Invalida ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodGetTypeCode()

Devuelve el TypeCode para el tipo de valor Byte.

System_CAPS_pubmethodSystem_CAPS_staticParse(String)

Convierte la representación en forma de cadena de un número en su Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, IFormatProvider)

Convierte la representación de la cadena de un número en un formato específico de la referencia cultural indicada en su equivalente de Byte.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles)

Convierte la representación de cadena de un número con un estilo especificado en su Byte equivalente.

System_CAPS_pubmethodSystem_CAPS_staticParse(String, NumberStyles, IFormatProvider)

Convierte la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su equivalente de Byte.

System_CAPS_pubmethodToString()

Convierte el valor del objeto Byte actual en su representación de cadena equivalente.(Invalida ValueType.ToString()).

System_CAPS_pubmethodToString(IFormatProvider)

Convierte el valor numérico del objeto Byte actual en su representación de cadena equivalente usando la información de formato específica de la referencia cultural especificada.

System_CAPS_pubmethodToString(String)

Convierte el valor del objeto Byte actual en su representación de cadena equivalente usando el formato especificado.

System_CAPS_pubmethodToString(String, IFormatProvider)

Convierte el valor del objeto Byte actual en la representación de cadena equivalente usando el formato y la información de formato específica de la referencia cultural especificados.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, Byte)

Intenta convertir la representación de cadena de un número en si equivalente de Byte y devuelve un valor que indica si la conversión tuvo éxito.

System_CAPS_pubmethodSystem_CAPS_staticTryParse(String, NumberStyles, IFormatProvider, Byte)

Convierte la representación de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su equivalente de Byte. Un valor devuelto indica si la conversión se realizó correctamente o si se produjeron errores.

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticMaxValue

Representa el mayor valor posible de un Byte. Este campo es constante.

System_CAPS_pubfieldSystem_CAPS_staticMinValue

Representa el menor valor posible de un Byte. Este campo es constante.

NombreDescripción
System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. No se admite esta conversión. Cualquier intento de usar este método produce una excepción InvalidCastException.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Esta API admite la infraestructura producto y no está diseñada para usarse directamente desde el código. Para una descripción de este miembro, vea IConvertible.ToUInt64.

Bytees un tipo de valor inmutable que representa los enteros sin signo con valores comprendidos entre 0 (lo que se representa mediante el Byte.MinValue constante) y 255 (lo que se representa mediante el Byte.MaxValue constante). .NET Framework también incluye un tipo de valor entero de 8 bits con signo, SByte, que representa los valores comprendidos entre -128 y 127.

Puede crear instancias de un Byte valor de varias maneras:

  • Puede declarar un Byte variable y asignarle un valor literal entero que está dentro del intervalo de la Byte tipo de datos. En el ejemplo siguiente se declara dos Byte variables y les asigna valores de esta manera.

    byte value1 = 64;
    byte value2 = 255;
    
  • Puede asignar un valor numérico de byte no a un byte. Se trata de una conversión de restricción, por lo que requiere un operador de conversión en C# y un método de conversión de Visual Basic si OptionStrict se encuentra en. Si el valor de byte no es un Single, Double, o Decimal valor que incluye un componente de fracción, el control de su parte fraccionaria depende del compilador realizar la conversión. En el ejemplo siguiente se asigna varios valores numéricos a Byte variables.

    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
    
  • Puede llamar a un método de la Convert admite la clase para convertir cualquier tipo a un Byte valor. Esto es posible porque Byte es compatible con la IConvertible interfaz. En el ejemplo siguiente se muestra la conversión de una 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.      
    
  • Puede llamar a la Parse o TryParse método para convertir la representación de cadena de un Byte valor a un Byte. La cadena puede contener dígitos decimales o hexadecimales. En el ejemplo siguiente se muestra la operación de análisis mediante el uso de un decimal y una cadena 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
    

El Byte tipo es compatible con las operaciones matemáticas estándar, como suma, resta, división, multiplicación, resta, negación y negación unaria. Al igual que otros tipos integrales, el Byte tipo también es compatible con el bit a bit AND, OR, XOR, MAYÚS y operadores de desplazamiento a la derecha de apertura.

Puede usar los operadores numéricos estándar para comparar dos Byte valores o se puede llamar a la CompareTo o Equals método.

También puede llamar a los miembros de la Math clase para realizar una amplia variedad de operaciones numéricas, como obtener el valor absoluto de un número, calcular el cociente y el resto de la división entero, determinando el valor máximo o mínimo de dos números enteros, obtener el signo de un número y redondear un número.

El Byte tipo ofrece plena compatibilidad con cadenas de formato numérico estándar y personalizados. (Para obtener más información, consulte Aplicar formato a tipos en .NET Framework, Cadenas con formato numérico estándar, y Cadenas con formato numérico personalizado.) Sin embargo, normalmente, los valores de byte se representan como valores de un dígito a tres dígitos sin formato adicionales o como valores hexadecimales de dos dígitos.

Para dar formato a un Byte valor como una cadena entera sin ceros iniciales, puede llamar sin parámetros ToString() método. Al usar el especificador de formato "D", también puede incluir un número especificado de ceros a la izquierda en la representación de cadena. Al usar el especificador de formato "X", se puede representar un Byte valor como una cadena hexadecimal. En el ejemplo siguiente se da formato a los elementos de una matriz de Byte valores de estas tres maneras.

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      

También puede dar formato a un Byte valor como un valor binario, octal, decimal o hexadecimal cadena mediante una llamada a la ToString(Byte, Int32) método y proporcionar la base, según el parámetro del método segundo. En el ejemplo siguiente se llama a este método para mostrar el archivo binario, octal y las representaciones hexadecimales de una 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      

Además de trabajar con los bytes individuales como valores decimales, puede que desee realizar operaciones bit a bit con valores de byte o trabajar con matrices de bytes o con las representaciones binarias o hexadecimales de valores de byte. Por ejemplo, las sobrecargas de la BitConverter.GetBytes método puede convertir en una matriz de bytes, cada uno de los tipos de datos primitivos y la BigInteger.ToByteArray método convierte un BigInteger valor a una matriz de bytes.

Bytelos valores se representan en 8 bits por su magnitud, sin ningún bit de signo. Esto es importante tener en cuenta al realizar operaciones bit a bit en Byte valores o al trabajar con bits individuales. Para realizar la operación de comparación de los dos valores no decimales, un valor booleano o numérico, ambos valores deben usar la misma representación.

Cuando se realiza una operación con dos Byte valores, los valores comparten la misma representación, por lo que el resultado es preciso. Esto se muestra en el ejemplo siguiente, que simplifica el bit de orden más bajo un Byte valor para asegurarse de que es par.

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 otro lado, cuando se trabaja con bits con signo y sin signo, operaciones bit a bit son complicadas por el hecho de que el SByte valores usan la representación de signo y magnitud para valores positivos y representación del complemento de dos para los valores negativos. Para llevar a cabo una operación bit a bit significativa, los valores deben convertirse en dos representaciones equivalentes y se debe mantener información sobre el bit de signo. En el ejemplo siguiente se realiza esto para la máscara de bits 2 y 4 de una matriz de valores con y sin signo de 8 bits.

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 de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que aparecen modificar el estado de instancia realmente devuelven una nueva instancia inicializada con el nuevo valor. Como con cualquier otro tipo, leer y escribir en una variable compartida que contiene una instancia de este tipo deben protegerse mediante un bloqueo para garantizar la seguridad para subprocesos.

Volver al principio
Mostrar: