> ## 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# ulong
The `ulong` keyword in C# is an integral numeric value type that represents an unsigned 64-bit (8-byte) integer. It is an alias for the .NET `System.UInt64` struct. Because it is unsigned, it cannot store negative numbers, allocating all 64 bits to represent the magnitude of a positive value.
## Technical Specifications
* **.NET Type:** `System.UInt64`
* **Memory Size:** 8 bytes (64 bits)
* **Minimum Value:** `0` (`UInt64.MinValue`)
* **Maximum Value:** `18,446,744,073,709,551,615` ($2^{64} - 1$) (`UInt64.MaxValue`)
* **Default Value:** `0`
## Syntax and Literals
When assigning a literal value to a `ulong` variable, the compiler implicitly types integer literals as `int`, `uint`, `long`, or `ulong` depending on the size of the value. To explicitly force a literal to be evaluated as a `ulong`, you must append the `ul`, `uL`, `Ul`, `UL`, `lu`, `lU`, `Lu`, or `LU` suffix.
*Note: While the suffix is case-insensitive and order-independent, `UL` or `LU` is preferred over lowercase variants to prevent visual confusion between the lowercase `l` and the digit `1`.*
```csharp theme={"dark"}
// Standard declaration
ulong defaultVariable = 0;
// Explicit literal typing using the UL suffix
ulong maxLimit = 18446744073709551615UL;
// Explicit literal typing using the LU suffix
ulong reverseSuffixLimit = 18446744073709551615LU;
// Hexadecimal literal
ulong hexValue = 0xFFFFFFFFFFFFFFFFUL;
// Binary literal with digit separators
ulong binaryValue = 0b_1111_1111_0000_0000_1010_1010_1100_1100UL;
```
## Type Conversions
The `ulong` type adheres to strict type-safety rules regarding implicit and explicit conversions based on the target type's capacity and signedness.
### Implicit Conversions
A `ulong` can be implicitly converted to `UInt128`, `Int128` (introduced in C# 11), `float`, `double`, and `decimal` because their maximum bounds exceed the `ulong` maximum. However, converting to `float` or `double` may result in a loss of precision (least significant digits), though the magnitude is preserved.
```csharp theme={"dark"}
ulong baseValue = 9223372036854775808UL;
// Implicit conversions allowed
UInt128 uInt128Value = baseValue; // No precision loss (C# 11+)
Int128 int128Value = baseValue; // No precision loss (C# 11+)
float floatValue = baseValue; // Precision loss possible
double doubleValue = baseValue; // Precision loss possible
decimal decimalValue = baseValue; // No precision loss
```
### Explicit Conversions (Casting)
Because `ulong` occupies 64 bits and is unsigned, converting it to any signed integral type smaller than 128 bits (such as `sbyte`, `short`, `int`, and `long`) or any smaller unsigned integral type (such as `byte`, `ushort`, and `uint`) requires an explicit cast. If the `ulong` value exceeds the target type's maximum capacity, the conversion will result in a truncated value (in an unchecked context) or throw an `OverflowException` (in a checked context).
```csharp theme={"dark"}
// 5,000,000,000 exceeds uint.MaxValue and int.MaxValue, but fits in long
ulong largeValue = 5000000000UL;
// Explicit casts required
byte byteValue = (byte)largeValue; // Overflow guaranteed (truncates to lower 8 bits)
int intValue = (int)largeValue; // Overflow guaranteed (truncates to lower 32 bits)
long longValue = (long)largeValue; // Fits perfectly, no overflow occurs
// Checked context for safe casting
checked
{
// Throws System.OverflowException because largeValue > int.MaxValue
int safeIntValue = (int)largeValue;
}
```
## Memory and Execution Context
As a `struct`, `ulong` is a value type. When declared as a local variable, it is allocated directly on the thread's execution stack. When declared as a class field, it is allocated inline within the parent object's memory footprint on the managed heap. Operations on `ulong` are handled directly by the CPU's 64-bit arithmetic logic unit (ALU). On 32-bit architectures, 64-bit arithmetic is emulated using two 32-bit registers, which incurs a slight performance overhead compared to native 64-bit execution.
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
