Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

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'
Master C# with Deep Grasping Methodology!Learn More