C# sbyte - SyntBlaze

The sbyte keyword in C# is a built-in value type that serves as an alias for the .NET System.SByte structure. It represents an 8-bit (1-byte) signed integer, utilizing two’s complement binary representation to store both positive and negative whole numbers.

Technical Specifications

Memory Size: 8 bits (1 byte).
Sign Bit: The most significant bit (MSB) denotes the sign (0 for positive, 1 for negative).
Minimum Value: -128 (sbyte.MinValue).
Maximum Value: 127 (sbyte.MaxValue).
Default Value: 0.
CLS Compliance: sbyte is not Common Language Specification (CLS) compliant. The CLS-compliant alternative is short (System.Int16).

Syntax and Initialization

// Declaration and initialization
sbyte positiveValue = 120;
sbyte negativeValue = -100;

// Default value initialization (evaluates to 0)
sbyte defaultVariable = default;

// Accessing structural constants
sbyte min = sbyte.MinValue; // -128
sbyte max = sbyte.MaxValue; // 127

Type Conversions

Implicit Conversions An sbyte can be implicitly converted to any larger signed integral type or any floating-point type. These are widening conversions where the compiler guarantees no data loss or precision degradation: short, int, long, float, double, decimal.

sbyte originalValue = 42;
int widenedValue = originalValue; // Implicit conversion to 32-bit integer

Explicit Conversions Converting an sbyte to an unsigned type or an incompatible type requires an explicit cast. These are narrowing conversions or sign-boundary crossings that risk overflow, underflow, or data loss: byte, ushort, uint, ulong, char.

sbyte negativeValue = -42;

// Requires explicit cast. 
// Results in underflow/wrapping at the binary level because byte is unsigned.
byte unsignedValue = (byte)negativeValue; 

Literal Assignment

C# does not possess a dedicated literal suffix for the sbyte type. Integer literals are evaluated as int by the compiler. If an integer literal falls within the -128 to 127 range, the compiler allows implicit assignment to an sbyte variable. If the literal exceeds this range, it triggers a compile-time error.

sbyte valid = 100;       // Int literal implicitly converted during assignment
// sbyte invalid = 128;  // Compiler Error CS0031: Constant value '128' cannot be converted to a 'sbyte'

Tired of Poor C# Skills? Fix That With Deep Grasping!Learn More