Convertir Int a Byte en C#

En C#, la conversión adecuada depende de lo que necesite almacenar. Un byte contiene un único valor sin signo entre 0 y 255. Un byte[] contiene los bytes que codifican un valor mayor. Use Convert.ToByte si el resultado debe ser un solo byte; use BitConverter.GetBytes o un flujo si necesita la representación binaria de un int. Para un archivo o un formato de red, elija también explícitamente el orden de bytes requerido.

Elegir entre byte y byte[]

Un int es un número de 32 bits con signo, mientras que un byte es un único número de 8 bits sin signo. Por tanto, la conversión de int a byte solo se realiza correctamente si el valor está entre 0 y 255. En cambio, un byte[] puede conservar los cuatro bytes de un int; el orden de esos bytes determina cómo otro sistema reconstruye el número.

Elija la conversión escalar para un valor que sepa que cabe en un byte, como un contador pequeño o un valor de canal. Elija un array para la serialización, los protocolos binarios o las API que requieren bytes. Convertir un número a su texto decimal y codificar ese texto es una operación distinta: almacena caracteres como 1, 2 y 3, no la representación binaria del entero 123.

Convertir un valor a byte con Convert.ToByte

Convert.ToByte devuelve un único byte escalar. La sobrecarga que recibe una cadena analiza un número decimal expresado como texto, mientras que las sobrecargas numéricas convierten los tipos numéricos admitidos. Si tiene una variable entera, compruebe que su valor esté entre 0 y 255 antes de convertirla. Una conversión explícita en contexto unchecked puede descartar los bits superiores en vez de indicar un desbordamiento.

Ejecute este ejemplo:

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

using System;

class Program
{
    static void Main()
    {
        string text = "42";
        byte fromText = Convert.ToByte(text);
        byte fromNumber = Convert.ToByte(90);
        Console.WriteLine($"{fromText}, {fromNumber}");
    }
}

42, 90

Para una entrada de tipo cadena, una cadena nula se convierte en 0. El texto que no representa un número provoca FormatException, mientras que un valor analizado fuera del intervalo de 0 a 255 provoca OverflowException.

El siguiente ejemplo maneja ambos errores e imprime el tipo de cada excepción capturada, de modo que los dos casos se distingan. FormatException se debe al texto no numérico; OverflowException, a un valor analizado superior a 255.

Ejecute este ejemplo que maneja los errores:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { "twelve", "300" };

        foreach (string input in inputs)
        {
            try
            {
                byte value = Convert.ToByte(input);
                Console.WriteLine($"{input} -> {value}");
            }
            catch (FormatException)
            {
                Console.WriteLine($"{input} -> FormatException");
            }
            catch (OverflowException)
            {
                Console.WriteLine($"{input} -> OverflowException");
            }
        }
    }
}

La sobrecarga que recibe una cadena y una base, Convert.ToByte(value, fromBase), también devuelve un solo byte. Admite las bases 2, 8, 10 y 16; no admite todas las bases entre 2 y 36. Por ejemplo, Convert.ToByte("FF", 16) analiza un valor hexadecimal. Los dígitos no válidos o un valor que no cabe en el intervalo de byte provocan un error de conversión; una base fuera del conjunto admitido provoca ArgumentException. No describa esta sobrecarga como una conversión de un entero a un array de bytes.

Convertir un int en byte[] con BitConverter.GetBytes

BitConverter.GetBytes(int) devuelve cuatro bytes que contienen la representación binaria del entero. El orden de esos bytes depende de la máquina actual; puede consultarlo con BitConverter.IsLittleEndian. El ejemplo completo siguiente imprime los bytes como números decimales e indica el orden de bytes nativo de la máquina.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

using System;

class Program
{
    static void Main()
    {
        int value = 123456789;
        byte[] bytes = BitConverter.GetBytes(value);
        Console.WriteLine(string.Join(" ", bytes));
        Console.WriteLine(BitConverter.IsLittleEndian ? "Little-endian" : "Big-endian");
    }
}

Este método resulta práctico cuando el código receptor usa la misma convención de orden de bytes. Si los bytes se almacenan o se envían a otro sistema, acuerde el formato en lugar de suponer que ambas máquinas usan el mismo orden.

Escribir un int en byte[] con BinaryWriter y MemoryStream

Cuando el código ya escribe una secuencia de valores en un flujo, BinaryWriter puede escribir el int y MemoryStream.ToArray() puede devolver los bytes acumulados. BinaryWriter escribe sus valores numéricos primitivos en orden little-endian. Deseche el escritor antes de leer el contenido del flujo para asegurarse de que haya terminado de procesar los datos almacenados en búfer; al desechar el escritor también se desecha el flujo, pero ToArray() sigue disponible después.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

using System;
using System.IO;

class Program
{
    static void Main()
    {
        int value = 987654321;
        byte[] bytes;

        using (MemoryStream stream = new MemoryStream())
        {
            using (BinaryWriter writer = new BinaryWriter(stream))
            {
                writer.Write(value);
            }

            bytes = stream.ToArray();
        }

        Console.WriteLine(string.Join(" ", bytes));
    }
}

Esto resulta útil al serializar varios campos en orden. El array resultante contiene todo el contenido del flujo, no solo el último entero escrito. Si un protocolo especifica otro orden de bytes, use explícitamente el que exige ese protocolo.

Controlar el orden de bytes al convertir un int en byte[]

La endianidad determina si aparece primero el byte menos significativo o el más significativo. BitConverter.GetBytes sigue el orden nativo de la máquina, así que invierta una copia solo cuando ese orden difiera del formato que necesite. El ejemplo siguiente crea representaciones little-endian y big-endian del mismo valor, con independencia del orden nativo de la máquina.

El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.

using System;

class Program
{
    static void Main()
    {
        int value = 567890123;
        byte[] native = BitConverter.GetBytes(value);
        byte[] littleEndian = (byte[])native.Clone();
        byte[] bigEndian = (byte[])native.Clone();

        if (!BitConverter.IsLittleEndian)
        {
            Array.Reverse(littleEndian);
        }

        if (BitConverter.IsLittleEndian)
        {
            Array.Reverse(bigEndian);
        }

        Console.WriteLine("Little-endian: " + string.Join(" ", littleEndian));
        Console.WriteLine("Big-endian: " + string.Join(" ", bigEndian));
    }
}

Especifique el orden requerido en el límite donde se escriben o se leen los bytes. Invertir un array local es adecuado para representar un entero de ancho fijo, pero no define un formato de serialización completo: el formato también debe especificar los anchos, el uso de signo y el orden de los campos.