> ## 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.
# C# sbyte
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
```csharp theme={"dark"}
// 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`.
```csharp theme={"dark"}
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`.
```csharp theme={"dark"}
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.
```csharp theme={"dark"}
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
