C# byte - SyntBlaze

The byte keyword in C# represents an 8-bit unsigned integer. It is an alias for the .NET System.Byte structure and is used to store positive numeric values ranging from 0 to 255. As a value type, it is allocated directly on the stack (or inline within an object) and has a default value of 0.

Technical Specifications

.NET Type: System.Byte
Memory Size: 8 bits (1 byte)
Minimum Value: 0 (byte.MinValue)
Maximum Value: 255 (byte.MaxValue)
Sign: Unsigned (cannot represent negative numbers)

Declaration and Initialization

You can initialize a byte using standard decimal literals, hexadecimal literals, or binary literals.

byte decimalByte = 200;
byte hexByte = 0xC8;        // Hexadecimal equivalent of 200
byte binaryByte = 0b11001000; // Binary equivalent of 200

byte min = byte.MinValue;   // 0
byte max = byte.MaxValue;   // 255

Type Conversions

Because byte is the smallest unsigned integer type in C#, its conversion rules are strictly defined to prevent unintended data loss. Implicit Conversions A byte can be implicitly converted to any larger numeric type or any floating-point type: short, ushort, int, uint, long, ulong, float, double, or decimal.

byte b = 128;
int i = b;       // Implicit conversion to 32-bit signed integer
double d = b;    // Implicit conversion to 64-bit floating point

Explicit Conversions Converting from a larger integer type, a floating-point type, or a signed type (like sbyte) to a byte requires an explicit cast.

int largeInt = 200;
byte b1 = (byte)largeInt; // Explicit cast required

sbyte signedByte = 50;
byte b2 = (byte)signedByte; // Explicit cast required due to sign difference

Overflow Behavior

When a mathematical operation causes a byte to exceed its maximum value (255) or drop below its minimum value (0), the behavior depends on the compiler’s overflow checking context.

byte b = 255;

unchecked
{
    b++; // Silently wraps around to 0
}

checked
{
    // b++; // Throws System.OverflowException at runtime
}

Bitwise Operations and Numeric Promotion

When performing arithmetic or bitwise operations (~, &, |, ^, <<, >>) on byte operands, C# implicitly promotes the operands to int (32-bit) before evaluating the expression. The result of the operation is an int, which must be explicitly cast back to a byte if you intend to store it in a byte variable.

byte b1 = 0b_1010_0000;
byte b2 = 0b_0000_1111;

// b1 | b2 evaluates to an Int32. Explicit cast is mandatory.
byte result = (byte)(b1 | b2); 

// Bitwise complement also results in an Int32
byte complement = (byte)(~b1); 