A constant is a class member that represents a constant value: a value that can be computed at compile-time. A constant-declaration introduces one or more constants of a given type. constant-declaration : attributesconstant-modifiersconsttypeconstant-declarators;constant-modifiers : constant-modifierconstant-modifiersconstant-modifierconstant-modifier : newpublicprotectedinternalprivateconstant-declarators : constant-declaratorconstant-declarators,constant-declaratorconstant-declarator : identifier=constant-expression A constant-declaration may include a set of attributes (24), a new modifier (17.2.2), and a valid combination of the four access modifiers (17.2.3). The attributes and modifiers apply to all of the members declared by the constant-declaration. Even though constants are considered static members, a constant-declaration neither requires nor allows a static modifier. It is an error for the same modifier to appear multiple times in a constant declaration. The type of a constant-declaration specifies the type of the members introduced by the declaration. The type is followed by a list of constant-declarators, each of which introduces a new member. A constant-declarator consists of an identifier that names themember, followed by an "=" token, followed by a constant-expression (14.15) that gives the value of the member. The type specified in a constant declaration must be sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, an enum-type, or a reference-type. Each constant-expression must yield a value of the target type or of a type that can be converted to the target type by an implicit conversion (13.1). The type of a constant must be at least as accessible as the constant itself (10.5.4). The value of a constant is obtained in an expression using a simple-name (14.5.2) or a member-access (14.5.4). A constant can itself participate in a constant-expression. Thus, a constant may be used in any construct that requires a constant-expression. [Note: Examples of such constructs include case labels, goto case statements, enum member declarations, attributes, and other constant declarations. end note] [Note: As described in 14.15, a constant-expression is an expression that can be fully evaluated at compile-time. Since the only way to create a non-null value of a reference-type other than string is to apply the new operator, and since the new operator is not permitted in a constant-expression, the only possible value for constants of reference-types other than string is null. end note] When a symbolic name for a constant value is desired, but when the type of that value is not permitted in a constant declaration, or when the value cannot be computed at compile-time by a constant-expression, a readonly field (17.4.2) may be used instead. [Note: The versioning semantics of const and readonly differ (17.4.2.2). end note] A constant declaration that declares multiple constants is equivalent to multiple declarations of single constants with the same attributes, modifiers, and type. [Example: For example is equivalent to end example] Constants are permitted to depend on other constants within the same program as long as the dependencies are not of a circular nature. The compiler automatically arranges to evaluate the constant declarations in the appropriate order. [Example: In the example the compiler first evaluates A.Y, then evaluates B.Z, and finally evaluates A.X, producing the values 10, 11, and 12. end example] Constant declarations may depend on constants from other programs, but such dependencies are only possible in one direction. [Example: Referring to the example above, if A and B were declared in separate programs, it would be possible for A.X to depend on B.Z, but B.Z could then not simultaneously depend on A.Y. end example]