X hits on this document





174 / 396

Chapter ‎18   Unsafe code

The right operand of the += or -= operator is evaluated, and, if required, converted to the type of the left operand through an implicit conversion (§‎6.1).

An event accessor of the event is invoked, with argument list consisting of the right operand, after evaluation and, if necessary, conversion. If the operator was +=, the add accessor is invoked; if the operator was -=, the remove accessor is invoked.

An event assignment expression does not yield a value. Thus, an event assignment expression is valid only in the context of a statement-expression (§‎8.6).

7.14 Expression

An expression is either a conditional-expression or an assignment.

expression: conditional-expression assignment

7.15 Constant expressions

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

constant-expression: expression

The type of a constant expression can be one of the following: sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool, string, any enumeration type, or the null type. The following constructs are permitted in constant expressions:

Literals (including the null literal).

References to const members of class and struct types.

References to members of enumeration types.

Parenthesized sub-expressions, which are themselves constant expressions.

Cast expressions, provided the target type is one of the types listed above.

The predefined +, , !, and ~ unary operators.

The predefined +, , *, /, %, <<, >>, &, |, ^, &&, ||, ==, !=, <, >, <=, and >= binary operators, provided each operand is of a type listed above.

The ?: conditional operator.

Whenever an expression is of one of the types listed above and contains only the constructs listed above, the expression is evaluated at compile-time. This is true even if the expression is a sub-expression of a larger expression that contains non-constant constructs.

The compile-time evaluation of constant expressions uses the same rules as run-time evaluation of non-constant expressions, except that where run-time 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.5.12).

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.3).

Copyright Microsoft Corporation 1999-2003. All Rights Reserved.161

Document info
Document views494
Page views494
Page last viewedMon Oct 24 02:24:06 UTC 2016