Speichern und Anzeigen von Binärwerten in C#

Binäre Literale in C# speichern

[0:00 - 1:50] Die erste Frage, die Tim anspricht, ist einfach: Wie setzt man eine Binärzahl in eine C#-Variable? Die Antwort ist das Präfix 0b, das dem Compiler anweist, die Ziffern als Basis 2 statt als standardmäßige Basis 10 zu interpretieren.

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

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

Ohne das Präfix würde 1001 als eintausendeins interpretiert. Mit 0b wird es als vier binäre Ziffern behandelt, die den Dezimalwert 9 darstellen. Führende Nullen sind optional. Das Schreiben von 0b00001001 ist identisch mit 0b1001, aber die längere Form kann die Bit-Positionen leichter lesbar machen, wenn Sie mit spezifischen Bitbreiten arbeiten.

Der Variablentyp ist ein standardmäßiger int. Sie können auch uint (unvorzeichneter Integer) verwenden, wenn Sie keine negativen Werte benötigen, oder long für 64-Bit-Speicher. Die binäre Literal-Syntax funktioniert mit jedem der Ganzzahltypen.

Anzeige von Zahlen im Binärformat

[1:50 - 3:48] Ein binärer Wert zu speichern ist eine Sache. Ihn als Binärzahl auf dem Bildschirm zu sehen, ist eine andere. Wenn Sie einen int mit Console.WriteLine drucken, gibt C# die Basis-10-Darstellung aus. Für 0b1001 bedeutet das, dass Sie 9 sehen, nicht 1001.

Um die Zeichenfolgen-Darstellung im Binärformat zu erhalten, verwenden Sie Convert.ToString() mit einem Basis-Parameter:

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

Das zweite Argument von Convert.ToString() gibt die Ausgabe-Basis an. Unterstütze Werte sind 2 (binär), 8 (oktal), 10 (dezimal) und 16 (hexadezimal). Tim demonstriert Basis 2, aber dieselbe Methode handhabt alle vier.

Polstern mit führenden Nullen

[3:48 - 5:24] Die rohe Ausgabe von Convert.ToString(binaryValue, 2) lässt führende Nullen aus. Bei 0b1001 ist das Ergebnis der String "1001", nicht "00001001". Wenn Sie mit Bytes (8 Bits), 16-Bit-Werten oder 32-Bit-Registern arbeiten, sorgt die vollständige Breite mit führenden Nullen dafür, dass die Bit-Positionen sofort klar sind.

Die Lösung ist 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') stellt sicher, dass die Ausgabe mindestens 8 Zeichen lang ist und füllt fehlende Positionen auf der linken Seite mit dem Zeichen '0' aus. Tim merkt an, dass das zweite Argument ein char (einfache Anführungszeichen) und kein String ist. Es ist das Zeichen Null, nicht die Zahl Null, weil PadLeft eine Zeichenfolge aus einzelnen Zeichen erstellt.

Für eine 16-Bit-Darstellung ändern Sie 8 in 16. Für ein vollständiges 32-Bit-Integer verwenden Sie 32. Die Polsterbreite sollte der Bitbreite entsprechen, über die Sie nachdenken.

Irgendeinen Integer in Binär konvertieren

[5:24 - 7:28] Tim macht einen Punkt, den man leicht übersehen kann: Sie müssen einen Wert nicht als binäres Literal speichern, um seine binäre Darstellung zu sehen. Jeder Ganzzahl kann mit derselben Convert.ToString()-Methode in Binärausgabe konvertiert werden:

// 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

Das 0b-Präfix ist für den Fall, dass Sie bereits einen binären Wert haben und ihn in binärer Form eingeben möchten. Für normale Ganzzahlen übernimmt Convert.ToString() die Konvertierung. Beide Pfade liefern dasselbe Ergebnis für denselben zugrunde liegenden Wert.

Wie C# Integer im Speicher speichert

[7:28 - 9:20] Tim schließt mit einem Detail ab, wie C# Integer intern speichert. Ein int in C# ist ein Alias für System.Int32, ein 32-Bit vorzeichenbehafteter Integer. Das bedeutet, dass jedes int 32 Bits im Speicher belegt, unabhängig davon, wie klein der Wert ist. Das Speichern von 0b1001 (die Zahl 9) verwendet dieselben 32 Bits wie das Speichern von 0b01111111111111111111111111111111 (über zwei Milliarden).

// 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);

Dies verbindet sich mit der Frage, warum die Wahl der richtigen Typgröße entscheidend ist. Ein long (Int64) verwendet 64 Bits, wodurch sich die Speichernutzung verdoppelt. Für die meisten Anwendungen deckt ein int (32 Bits) den benötigten Bereich ab. Aber wenn Sie in speicherbeschränkten Umgebungen arbeiten oder Millionen von Werten verarbeiten, wird der Unterschied zwischen Byte (8 Bits), Short (16 Bits), int (32 Bits) und long (64 Bits) bedeutend.

Abschließend: Das vollständige Muster

[9:07 - 9:15] Das vollständige Muster für den Umgang mit Binär in C# ist prägnant. Speichern Sie Werte mit dem 0b-Präfix, wenn Sie binäre Eingaben haben. Darstellen Sie sie mit Convert.ToString(value, 2) für rohe Ausgabe. Fügen Sie .PadLeft(width, '0') hinzu, wenn Sie eine Festbreitenformatierung benötigen. Und denken Sie daran, dass die zugrunde liegende Speicherung immer ein standardmäßiger Ganzzahltyp ist, wobei die Bitbreite davon abhängt, ob Sie Byte, Short, int oder long wählen.

Abschluss

[9:15 - 9:20] Zusammengefasst: Binärliterale verwenden das Präfix 0b, Convert.ToString(value, 2) erzeugt die binäre Zeichenfolge, und PadLeft() fügt führende Nullen für die Festbreitenanzeige hinzu. Der Wert wird unter der Haube in einem regulären Integer-Typ gespeichert, und ein int belegt immer 32 Bits, unabhängig von der Größe der Zahl.

Diese Bausteine tauchen in den nächsten Lektionen der Serie auf, wo die binären Werte für bitweise Operationen richtig formatiert werden müssen.

Beispiel-Tipp: Beim Debuggen von bitweisen Operationen polstern Sie Ihre Binärausgabe auf die volle Breite Ihres Typs (8 für Byte, 16 für Short, 32 für int). Alle Bitpositionen auf einmal zu sehen, macht Shift- und Masken-Operationen viel einfacher nachvollziehbar. Eine Hilfsmethode wie string ToBinary(int val) => Convert.ToString(val, 2).PadLeft(32, '0'); spart wiederholte Eingaben.

Sehen Sie das vollständige Video auf seinem YouTube-Kanal an und gewinnen Sie mehr Einblicke in das Verständnis von Binär in C#.