C# Numeric Promotion

Numeric promotion in C# is the automatic conversion of smaller numeric types to larger types during arithmetic operations. This ensures that operations between different numeric types can be performed without data loss, following C#'s type promotion rules.

When performing arithmetic operations, C# automatically promotes operands to a common type that can safely hold the result. For example, when multiplying a short and ushort, both are promoted to int before the operation.

How Numeric Promotion Works

The C# compiler follows a specific hierarchy when promoting numeric types during arithmetic operations −

Key Promotion Rules

• byte, sbyte, and short are promoted to int

• If one operand is long, the other is promoted to long

• If one operand is float, the other is promoted to float

• If one operand is double, the other is promoted to double

• decimal operations require explicit conversion from other types

Example

Basic Numeric Promotion

using System;

class Program {
    static void Main() {
        short val1 = 99;
        ushort val2 = 11;

        int res = val1 * val2;
        Console.WriteLine("Result: " + res);
        Console.WriteLine("Result type: " + res.GetType().Name);
        
        // Demonstrating promotion hierarchy
        byte b = 10;
        short s = 20;
        int result = b + s;  // Both promoted to int
        Console.WriteLine("Byte + Short = " + result + " (int)");
    }
}

The output of the above code is −

Result: 1089
Result type: Int32
Byte + Short = 30 (int)

Mixed Type Arithmetic Operations

using System;

class Program {
    static void Main() {
        int intValue = 100;
        long longValue = 200L;
        float floatValue = 3.5f;
        double doubleValue = 4.7;

        // int promoted to long
        long result1 = intValue + longValue;
        Console.WriteLine("int + long = " + result1 + " (" + result1.GetType().Name + ")");

        // int promoted to float
        float result2 = intValue + floatValue;
        Console.WriteLine("int + float = " + result2 + " (" + result2.GetType().Name + ")");

        // float promoted to double
        double result3 = floatValue + doubleValue;
        Console.WriteLine("float + double = " + result3 + " (" + result3.GetType().Name + ")");
    }
}

The output of the above code is −

int + long = 300 (Int64)
int + float = 103.5 (Single)
float + double = 8.2 (Double)

Decimal Type Promotion

using System;

class Program {
    static void Main() {
        decimal decValue = 10.5m;
        int intValue = 5;
        
        // Explicit conversion required for decimal
        decimal result1 = decValue + intValue;  // int implicitly converted to decimal
        Console.WriteLine("decimal + int = " + result1);
        
        float floatValue = 2.5f;
        // This would cause compile error: decimal result2 = decValue + floatValue;
        // Must explicitly convert:
        decimal result2 = decValue + (decimal)floatValue;
        Console.WriteLine("decimal + float (converted) = " + result2);
    }
}

The output of the above code is −

decimal + int = 15.5
decimal + float (converted) = 13.0

Comparison of Numeric Types

Conclusion

Numeric promotion in C# automatically converts smaller numeric types to larger, compatible types during arithmetic operations to prevent data loss. Understanding these promotion rules helps you predict the result type of expressions and avoid unexpected compilation errors, especially when working with mixed numeric types.