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 decimal keyword in C# is an alias for the .NET System.Decimal struct. It is a 128-bit (16-byte) value type that provides high-precision, base-10 floating-point arithmetic. Unlike base-2 floating-point types (float and double), decimal accurately represents base-10 fractions, eliminating the binary rounding errors inherent in IEEE 754 standard floating-point representations.

​
Technical Specifications

  • Size: 16 bytes (128 bits)
  • Precision: 28 to 29 significant digits
  • Range: ±1.0×10−28\pm 1.0 \times 10^{-28} to ±7.9228×1028\pm 7.9228 \times 10^{28}
  • Default Value: 0m
  • Underlying .NET Type: System.Decimal

​
Syntax and Initialization

To initialize a decimal with a real number literal, you must append the m or M suffix. Without the suffix, the compiler treats real number literals as double, resulting in a type mismatch error. 
// Correct initialization using the 'm' suffix
decimal pi = 3.14159265358979323846m;

// Implicit conversion from integer types is allowed
decimal wholeNumber = 42; 

// CS0664: Cannot implicitly convert type 'double' to 'decimal'
// decimal errorValue = 3.14; 

// Explicit casting is required when converting from floating-point types
decimal castValue = (decimal)3.14;

​
Trailing Zeros and Scaling

A unique semantic detail of the C# decimal type is that it preserves trailing zeros in its internal representation. The literals 1.5m and 1.50m possess different internal scaling factors and will output differently when .ToString() is called. However, the equality operator normalizes these values, meaning they evaluate as logically equal. 
decimal val1 = 1.5m;
decimal val2 = 1.50m;

Console.WriteLine(val1 == val2);       // Output: True
Console.WriteLine(val1.ToString());    // Output: 1.5
Console.WriteLine(val2.ToString());    // Output: 1.50

​
Internal Memory Layout

The 128 bits of a decimal instance are not structured like standard IEEE 754 floating-point numbers. Instead, the memory is partitioned into four 32-bit integers, representing the following components:
  1. Mantissa (Coefficient): 96 bits (the first three 32-bit integers) representing an unsigned integer value.
  2. Sign: 1 bit (bit 31, the highest bit of the fourth 32-bit integer) indicating positive (0) or negative (1).
  3. Exponent (Scaling Factor): 8 bits (bits 16–23 of the fourth 32-bit integer) representing an integer from 0 to 28. This defines the implicitly negative base-10 exponent, effectively determining the position of the decimal point.
  4. Reserved: 23 bits (bits 0–15 and 24–30 of the fourth 32-bit integer) are unused and must be zero.
The mathematical value of a decimal is evaluated as: (-1)^sign * mantissa / 10^exponent

​
Type Conversions

Because decimal has a different internal architecture and precision scale compared to other numeric types, conversion rules are strict:
  • Implicit Conversions: Allowed from integral types (sbyte, byte, short, ushort, int, uint, long, ulong, char).
  • Explicit Conversions: Required when converting to or from float and double. Converting from float/double to decimal can throw an OverflowException if the value exceeds the decimal range.
  • No Implicit Floating-Point Conversion: decimal cannot be implicitly converted to float or double. While float and double have significantly larger ranges than decimal (up to ≈1038\approx 10^{38} and 1030810^{308} respectively), decimal has higher precision. The conversion is strictly explicit to prevent the unintentional loss of precision and exactness that occurs when moving from base-10 to base-2 floating-point representations.
int intVal = 100;
decimal decVal = intVal; // Implicit conversion

double doubleVal = 1.234e5;
decimal convertedDec = (decimal)doubleVal; // Explicit conversion required

decimal largeDec = 12345.6789m;
float floatVal = (float)largeDec; // Explicit conversion required (precision lost)

​
Special Values and Exceptions

Unlike base-2 floating-point types, decimal does not support or represent NaN (Not a Number), PositiveInfinity, or NegativeInfinity. Consequently, operations that would result in infinity or undefined values in IEEE 754 arithmetic will instead throw exceptions in C#. For example, division by zero throws a DivideByZeroException, while arithmetic overflows (which result in infinity in IEEE 754) throw an OverflowException.

​
Performance Characteristics

Modern CPUs process base-2 floating-point arithmetic (float, double) natively via the hardware Floating-Point Unit (FPU). Because the CPU lacks native hardware instructions for 128-bit base-10 arithmetic, decimal operations are implemented purely in software within the .NET runtime libraries. Consequently, arithmetic operations, comparisons, and conversions involving decimal are significantly slower and consume more memory bandwidth than their double or float counterparts.
Master C# with Deep Grasping Methodology!Learn More