> ## 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# long
The `long` keyword in C# is a built-in value type that serves as an alias for the .NET `System.Int64` structure. It represents a 64-bit (8-byte) signed integer, utilizing two's complement representation to store numerical data.
## Technical Specifications
* **Underlying Type:** `System.Int64`
* **Memory Size:** 64 bits (8 bytes)
* **Sign Bit:** The most significant bit (MSB) denotes the sign (0 for positive, 1 for negative).
* **Minimum Value:** `-9,223,372,036,854,775,808` (`long.MinValue`)
* **Maximum Value:** `9,223,372,036,854,775,807` (`long.MaxValue`)
* **Default Value:** `0L`
## Syntax and Literals
By default, the C# compiler treats numeric literals as `int` if the value falls within the 32-bit signed integer range. To explicitly instruct the compiler to treat a literal as a `long`, append the `L` or `l` suffix. The uppercase `L` is standard convention to prevent visual confusion with the digit `1`.
```csharp theme={"dark"}
// Standard declaration and initialization
long a = 100000;
// Explicit literal typing using the 'L' suffix
long b = 9223372036854775807L;
// Hexadecimal literal
long c = 0x7FFFFFFFFFFFFFFFL;
// Binary literal (C# 7.0+) with digit separators
long binLiteral = 0b_0111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111L;
```
## Type Conversions
Because `long` is a 64-bit type, it participates in specific implicit and explicit conversion rules within the C# type system.
### Implicit Conversions
C# allows implicit conversions to `long` from any integral type with a smaller bit-width or an unsigned 32-bit type. A `long` can also be implicitly converted to floating-point types (`float`, `double`) and the `decimal` type. Conversion to floating-point types may result in a loss of precision, whereas conversion to `decimal` retains full precision.
```csharp theme={"dark"}
int intValue = 2147483647;
long implicitLong = intValue; // Implicit conversion from int to long
// Implicit conversion to floating-point types
float fValue = implicitLong; // Compiles, but may lose precision
double doubleValue = implicitLong; // Compiles, but may lose precision
// Implicit conversion to the decimal type
decimal decimalValue = implicitLong; // Compiles, no precision lost
```
### Explicit Conversions (Casting)
Conversions from types that exceed the maximum value of `long` (like `ulong`), or from floating-point and `decimal` types (which truncate the fractional part), require an explicit cast.
```csharp theme={"dark"}
ulong unsignedLong = 9223372036854775808ul;
long castedLong = (long)unsignedLong; // Explicit cast required
double fractionalDouble = 1234.56;
long truncatedLong = (long)fractionalDouble; // Evaluates to 1234
```
## Memory Layout
In memory, a `long` is stored as a contiguous 64-bit block. The size of the type can be evaluated at compile-time using the `sizeof` operator, which yields a constant value and does not require an `unsafe` context for built-in types.
```csharp theme={"dark"}
int size = sizeof(long); // Evaluates to 8
```
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
