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.

// 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.

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).

// 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.

Master C# with Deep Grasping Methodology!

Learn More