Home > Articles > Programming > C#

  • Print
  • + Share This
This chapter is from the book

7.18 Constant Expressions

A constant-expression is an expression that can be fully evaluated at compile time.

constant-expression:
    expression

A constant expression must be the null literal or a value with one of the following types: sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, or any enumeration type. Only the following constructs are permitted in constant expressions:

  • Literals (including the null literal)
  • References to const members of class and struct types
  • References to const parameters or local variables
  • References to members of enumeration types
  • Parenthesized subexpressions, which are themselves constant expressions
  • Cast expressions, provided the target type is one of the types listed above
  • checked and unchecked expressions
  • Default value expressions
  • The predefined +, , !, and ~ unary operators
  • The predefined +, , *, /, %, <<, >>, &, |, ^, &&, ||, ==, !=, <, >, <=, and >= binary operators, provided each operand is of a type listed above
  • The ?: conditional operator

The following conversions are permitted in constant expressions:

  • Identity conversions
  • Numeric conversions
  • Enumeration conversions
  • Constant expression conversions
  • Implicit and explicit reference conversions, provided that the source of the conversions is a constant expression that evaluates to the null value

Other conversions including boxing, unboxing, and implicit reference conversions of non-null values are not permitted in constant expressions. For example,

class C {
    const object i = 5;                    // Error: boxing conversion not permitted
    const object str = "hello";            // Error: implicit reference conversion
}

In this example, the initialization of i is an error because a boxing conversion is required. The initialization of str is an error because an implicit reference conversion from a non-null value is required.

Whenever an expression fulfills the requirements listed above, the expression is evaluated at compile time. This is true even if the expression is a subexpression of a larger expression that contains nonconstant constructs.

The compile-time evaluation of constant expressions uses the same rules as runtime evaluation of nonconstant expressions, except that where runtime evaluation would have thrown an exception, compile-time evaluation causes a compile-time error to occur.

Unless a constant expression is explicitly placed in an unchecked context, overflows that occur in integral-type arithmetic operations and conversions during the compile-time evaluation of the expression always cause compile-time errors (§7.18).

Constant expressions occur in the contexts listed below. In these contexts, a compile-time error occurs if an expression cannot be fully evaluated at compile time.

  • Constant declarations (§10.4)
  • Enumeration member declarations (§14.3)
  • case labels of a switch statement (§8.7.2)
  • goto case statements (§8.9.3)
  • Dimension lengths in an array creation expression (§7.5.10.4) that includes an initializer
  • Attributes (§17)

An implicit constant expression conversion (§6.1.8) permits a constant expression of type int to be converted to sbyte, byte, short, ushort, uint, or ulong, provided the value of the constant expression is within the range of the destination type.

  • + Share This
  • 🔖 Save To Your Account