Almacenamiento y Visualización de Valores Binarios en C#

Almacenando Literales Binarios en C

[0:00 - 1:50] La primera pregunta que Tim aborda es sencilla: ¿cómo pones un número binario en una variable de C#? La respuesta es el prefijo 0b, que le dice al compilador que interprete los dígitos como base 2 en lugar de la base 10 predeterminada.

// Store binary 1001 (which is 9 in decimal)
int binaryValue = 0b1001;

// Store binary 1001 (which is 9 in decimal)
int binaryValue = 0b1001;

Sin el prefijo, 1001 se interpretaría como mil uno. Con 0b, se trata como cuatro dígitos binarios que representan el valor decimal 9. Los ceros a la izquierda son opcionales. Escribir 0b00001001 es idéntico a 0b1001, pero la forma más larga puede hacer que las posiciones de los bits sean más fáciles de leer cuando estás trabajando con anchos de bit específicos.

El tipo de variable es un int estándar. También puedes usar uint (entero sin signo) si no necesitas valores negativos, o long para almacenamiento de 64 bits. La sintaxis literal binaria funciona con cualquiera de los tipos de números enteros.

Mostrando Números en Binario

[1:50 - 3:48] Almacenar un valor binario es una cosa. Verlo como binario en pantalla es otra. Cuando imprimes un int con Console.WriteLine, C# muestra la representación en base 10. Para 0b1001, eso significa que ves 9, no 1001.

Para obtener la representación de cadena binaria, use Convert.ToString() con un parámetro de base:

int binaryValue = 0b1001;

// Convert to binary string (base 2)
string representation = Convert.ToString(binaryValue, 2);

Console.WriteLine($"Base 10: {binaryValue}");      // Output: 9
Console.WriteLine($"Base 2: {representation}");     // Output: 1001

int binaryValue = 0b1001;

// Convert to binary string (base 2)
string representation = Convert.ToString(binaryValue, 2);

Console.WriteLine($"Base 10: {binaryValue}");      // Output: 9
Console.WriteLine($"Base 2: {representation}");     // Output: 1001

El segundo argumento para Convert.ToString() especifica la base de salida. Los valores admitidos son 2 (binario), 8 (octal), 10 (decimal), y 16 (hexadecimal). Tim demuestra la base 2, pero el mismo método maneja los cuatro.

Rellenando con Ceros a la Izquierda

[3:48 - 5:24] La salida en bruto de Convert.ToString(binaryValue, 2) omite ceros a la izquierda. Para 0b1001, el resultado es la cadena "1001", no "00001001". Cuando estás trabajando con bytes (8 bits), valores de 16 bits, o registros de 32 bits, ver el ancho completo con ceros a la izquierda hace que las posiciones de los bits sean inmediatamente claras.

La solución es PadLeft():

// Pad to 8 characters (one byte) with leading zeros
string padded = Convert.ToString(binaryValue, 2).PadLeft(8, '0');

Console.WriteLine(padded);  // Output: 00001001

// Pad to 8 characters (one byte) with leading zeros
string padded = Convert.ToString(binaryValue, 2).PadLeft(8, '0');

Console.WriteLine(padded);  // Output: 00001001

PadLeft(8, '0') asegura que la salida tenga al menos 8 caracteres de largo, rellenando cualquier posición faltante a la izquierda con el carácter '0'. Tim señala el detalle de que el segundo argumento es un char (comillas simples), no una cadena. Es el carácter cero, no el número cero, porque PadLeft construye una cadena a partir de caracteres individuales.

Para una representación de 16 bits, cambie 8 a 16. Para un entero completo de 32 bits, use 32. El ancho de relleno debe coincidir con el ancho de bits que estás razonando.

Convirtiendo Cualquier Entero a Binario

[5:24 - 7:28] Tim hace un punto que es fácil pasar por alto: no tienes que almacenar un valor como un literal binario para ver su representación binaria. Cualquier entero se puede convertir a salida binaria usando el mismo enfoque Convert.ToString():

// A regular base 10 integer
int decimalValue = 12;

// Convert to padded binary string
string binary = Convert.ToString(decimalValue, 2).PadLeft(8, '0');

Console.WriteLine($"Decimal: {decimalValue}");  // Output: 12
Console.WriteLine($"Binary: {binary}");          // Output: 00001100

// A regular base 10 integer
int decimalValue = 12;

// Convert to padded binary string
string binary = Convert.ToString(decimalValue, 2).PadLeft(8, '0');

Console.WriteLine($"Decimal: {decimalValue}");  // Output: 12
Console.WriteLine($"Binary: {binary}");          // Output: 00001100

El prefijo 0b es para cuando ya tienes un valor binario y deseas ingresarlo en forma binaria. Para enteros normales, Convert.ToString() maneja la conversión. Ambos caminos producen el mismo resultado para el mismo valor subyacente.

Cómo C# Almacena Enteros en Memoria

[7:28 - 9:20] Tim cierra con un detalle sobre cómo C# almacena enteros internamente. Un int en C# es un alias para System.Int32, un entero con signo de 32 bits. Eso significa que cada int ocupa 32 bits en memoria, independientemente de cuán pequeño sea el valor. Almacenar 0b1001 (el número 9) usa los mismos 32 bits que almacenar 0b01111111111111111111111111111111 (más de dos mil millones).

// What's actually stored in memory for binaryValue = 0b1001
// 00000000 00000000 00000000 00001001
string fullRepresentation = Convert.ToString(binaryValue, 2).PadLeft(32, '0');
Console.WriteLine(fullRepresentation);

// What's actually stored in memory for binaryValue = 0b1001
// 00000000 00000000 00000000 00001001
string fullRepresentation = Convert.ToString(binaryValue, 2).PadLeft(32, '0');
Console.WriteLine(fullRepresentation);

Esto se conecta con por qué elegir el tamaño de tipo correcto importa. Un long (Int64) usa 64 bits, duplicando el uso de memoria. Para la mayoría de las aplicaciones, int (32 bits) cubre el rango que necesitas. Pero si estás trabajando en entornos con limitaciones de memoria o procesando millones de valores, la diferencia entre byte (8 bits), short (16 bits), int (32 bits) y long (64 bits) se vuelve significativa.

Resumiendo: El Patrón Completo

[9:07 - 9:15] El patrón completo para trabajar con binarios en C# es conciso. Almacene valores usando el prefijo 0b cuando tengas una entrada binaria. Muéstrelos usando Convert.ToString(value, 2) para salida en bruto. Agregue .PadLeft(width, '0') cuando necesite un formato de ancho fijo. Y recuerda que el almacenamiento subyacente siempre es un tipo de entero estándar, con el ancho de bits determinado por si eliges byte, short, int o long.

Conclusión

[9:15 - 9:20] Resumiendo: los literales binarios usan el prefijo 0b, Convert.ToString(value, 2) produce la cadena binaria, y PadLeft() agrega ceros a la izquierda para una visualización de ancho fijo. El valor se almacena en un tipo de entero regular en el fondo, y un int siempre ocupa 32 bits independientemente de la magnitud del número.

Estos bloques de construcción aparecen en las próximas lecciones de la serie, donde los valores binarios deben estar formateados adecuadamente para operaciones bit a bit.

Consejo de Ejemplo: Al depurar operaciones bit a bit, rellena tu salida binaria al ancho completo de tu tipo (8 para byte, 16 para short, 32 para int). Ver todas las posiciones de bits a la vez hace que las operaciones de desplazamiento y máscara sean mucho más fáciles de rastrear. Un método auxiliar como string ToBinary(int val) => Convert.ToString(val, 2).PadLeft(32, '0'); ahorra escribir repetido.

Mira el video completo en su canal de YouTube y obtén más información sobre cómo entender binarios en C#.