Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original

Byte (Estructura)

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>

El tipo Byte expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifCompareTo(Byte)Compara esta instancia con un entero de 8 bits sin signo y devuelve una indicación de los valores relativos.
Método públicoCompatible con XNA FrameworkCompareTo(Object)Compara esta instancia con un objeto especificado y devuelve una indicación de los valores relativos.
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifEquals(Byte)Devuelve un valor que indica si esta instancia y un objeto Byte especificado representan el mismo valor.
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifEquals(Object)Devuelve un valor que indica si la instancia equivale a un objeto especificado. (Invalida a ValueType.Equals(Object)).
Método protegidoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifGetHashCodeDevuelve el código hash de esta instancia. (Invalida a ValueType.GetHashCode()).
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoCompatible con XNA FrameworkGetTypeCodeDevuelve el TypeCode para el tipo de valor Byte.
Método protegidoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoMiembro estáticoCompatible con XNA FrameworkParse(String)Convierte la representación de cadena de un número en su Byte equivalente.
Método públicoMiembro estáticoCompatible con XNA FrameworkParse(String, NumberStyles)Convierte la representación en forma de cadena de un número con un estilo especificado en su Byte equivalente.
Método públicoMiembro estáticoyyb1w04y.PortableClassLibrary(es-es,VS.100).gifParse(String, IFormatProvider)Convierte la representación en forma de cadena de un número con el formato específico de la referencia cultural indicada en su Byte equivalente.
Método públicoMiembro estáticoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifParse(String, NumberStyles, IFormatProvider)Convierte la representación en forma de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su Byte equivalente.
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifToString()Convierte el valor del objeto Byte actual en su representación de cadena equivalente. (Invalida a ValueType.ToString()).
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifToString(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 indicada.
Método públicoCompatible con XNA FrameworkToString(String)Convierte el valor del objeto Byte actual en su representación de cadena equivalente utilizando el formato especificado.
Método públicoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifToString(String, IFormatProvider)Convierte el valor del objeto Byte actual en su representación de cadena equivalente usando el formato especificado y la información de formato específica de la referencia cultural indicada.
Método públicoMiembro estáticoTryParse(String, Byte)Intenta convertir la representación en forma de cadena de un número en su equivalente Byte y devuelve un valor que indica si la conversión tuvo éxito.
Método públicoMiembro estáticoyyb1w04y.PortableClassLibrary(es-es,VS.100).gifTryParse(String, NumberStyles, IFormatProvider, Byte)Convierte la representación en forma de cadena de un número con el estilo y el formato específico de la referencia cultural que se hayan especificado en su Byte equivalente. Un valor devuelto indica si la conversión tuvo éxito o no.
Arriba

  NombreDescripción
Campo públicoMiembro estáticoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifMaxValueRepresenta el mayor valor posible de un objeto Byte. Este campo es constante.
Campo públicoMiembro estáticoCompatible con XNA Frameworkyyb1w04y.PortableClassLibrary(es-es,VS.100).gifMinValueRepresenta el menor valor posible de Byte. Este campo es constante.
Arriba

  NombreDescripción
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToBooleanInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToBoolean.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToCharInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToChar.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDateTimeInfraestructura. No se admite esta conversión. Cualquier intento de utilizar este método produce una excepción InvalidCastException.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDecimalInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDecimal.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToDoubleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToDouble.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToInt64.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSByteInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSByte.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToSingleInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToSingle.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToTypeInfraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToType.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt16Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt16.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt32Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt32.
Implementación explícita de interfacesMétodo privadoCompatible con XNA FrameworkIConvertible.ToUInt64Infraestructura. Para obtener una descripción de este miembro, vea IConvertible.ToUInt64.
Arriba

Byte es un tipo de valor inmutable que representa los enteros sin signo con valores que van de 0 (que representa la constante Byte.MinValue) a 255 (que representa la constante Byte.MaxValue). .NET Framework también incluye un tipo de valor entero de 8 bits firmado, SByte, que representa valores que van de -128 a 127.

Crear instancias de un valor Byte

Puede crear instancias de un valor de Byte de varias formas:

  • Puede declarar una variable Byte y asignarle un valor entero literal que esté dentro del intervalo del tipo de datos Byte. El siguiente ejemplo declara dos variables Byte y les asigna valores de esta manera.

    
    byte value1 = 64;
    byte value2 = 255;
    
    
    
  • Puede asignar un valor numérico de no byte a un byte. Esta es una conversión narrowing; así que requiere un operador de conversión (en C#) y un método de conversión (en Visual Basic) si OptionStrict está activado. Si el valor de no byte es un valor Single, Double o Decimal que incluye un componente de fracción, el control de su parte fraccionaria depende del compilador que realiza la conversión. En el siguiente ejemplo se asignan varios valores numéricos a las variables Byte.

    
    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
    //       4      
    
    
    
  • Puede llamar a un método de la clase Convert para convertir cualquier tipo admitido en un valor Byte. Esto es posible porque Byte admite la interfaz IConvertible. En el siguiente ejemplo se muestra la conversión de una matriz de valores Int32 en valores Byte .

    
    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 los métodos Parse u TryParse para convertir la representación de un valor Byte en un Byte. La cadena puede contener dígitos decimales o hexadecimales. En el siguiente ejemplo se muestra la operación de análisis utilizando una cadena decimal y una 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
    
    
    

Realizar operaciones en valores Byte

El tipo Byte admite los operadores numéricos estándar como suma, resta, división, multiplicación, negación y negación unaria. Como los otros tipos integrales, el tipo Byte también admite el uso de los operadores de desplazamiento izquierdo y derecho AND, OR, XOR bit a bit.

Puede utilizar los operadores numéricos estándar para comparar dos valores Byte o puede llamar al método CompareTo o Equals.

Representar un byte como una cadena.

El tipo Byte proporciona la compatibilidad completa para las cadenas de formato numérico estándares y personalizadas. (Para obtener más información, vea Aplicar formato a tipos y Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado). Sin embargo, normalmente, los valores de bytes se representan como valores de uno a tres dígitos sin ningún formato adicional o como valores hexadecimales de dos dígitos.

Para dar formato a un valor Byte como una cadena entera sin ceros iniciales, puede llamar al método ToString() sin parámetros. Utilizando el especificador de formato "D", puede incluir también un número especificado de ceros iniciales en la representación de cadena. Utilizando el especificador de formato "X", puede representar el valor Byte como una cadena hexadecimal. En el siguiente ejemplo se da formato a los elementos de una matriz de valores Byte 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 valor Byte como un binario, octal, decimal o cadena hexadecimal llamando al método ToString(Byte, Int32) y proporcionando la base como el segundo parámetro del método. En el siguiente ejemplo se llama a este método para mostrar las representaciones binaria, octal y hexadecimal de una matriz de valores de bytes.


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      


Trabajar con valores Byte no decimales

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

Los valores Byte se representan en 8 bits por su magnitud, sin un bit de signo. Es importante tener esto presente al realizar las operaciones bit a bit en valores Byte o al trabajar con bits individuales. Para realizar una operación numérica, booleana o de comparación en dos valores no decimales cualesquiera, ambos valores deben utilizar la misma representación.

Cuando una operación se realiza en dos valores Byte, los valores comparten la misma representación, de modo que el resultado sea preciso. Esto se muestra en el siguiente ejemplo, que enmascara el bit del orden más bajo de un valor Byte para asegurarse de que es igual.


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, al trabajar con bits sin signo y bits firmados, las operaciones bit a bit se complican por el hecho de que los valores SByte usan la representación de signo y magnitud para los valores positivos y la representación complementaria de dos para los valores negativos. Para realizar una operación bit a bit significativa, los valores se deben convertir en dos representaciones equivalentes y se debe conservar la información sobre el bit de signo. El siguiente ejemplo hace esto para enmascarar los bits 2 y 4 de una matriz de valores de 8 bits con signo y sin signo.


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)


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Compatible con:

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros de este tipo son seguros para la ejecución de subprocesos. Los miembros que aparecen para modificar el estado de la instancia devuelven una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo deben protegerse mediante un bloqueo para garantizar la seguridad para subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft