X hits on this document

818 views

0 shares

0 downloads

0 comments

171 / 396

C# LANGUAGE SPECIFICATION

variable, property, or indexer element given by the left operand. The compound assignment operators are described in §‎7.13.2.

The += and -= operators with an event access expression as the left operand are called the event assignment operators. No other assignment operator is valid with an event access as the left operand. The event assignment operators are described in §‎7.13.3.

The assignment operators are right-associative, meaning that operations are grouped from right to left. For example, an expression of the form a = b = c is evaluated as a = (b = c).

7.13.1 Simple assignment

The = operator is called the simple assignment operator. In a simple assignment, the right operand must be an expression of a type that is implicitly convertible to the type of the left operand. The operation assigns the value of the right operand to the variable, property, or indexer element given by the left operand.

The result of a simple assignment expression is the value assigned to the left operand. The result has the same type as the left operand and is always classified as a value.

If the left operand is a property or indexer access, the property or indexer must have a set accessor. If this is not the case, a compile-time error occurs.

The run-time processing of a simple assignment of the form x = y consists of the following steps:

If x is classified as a variable:

x is evaluated to produce the variable.

y is evaluated and, if required, converted to the type of x through an implicit conversion (§‎6.1).

If the variable given by x is an array element of a reference-type, a run-time check is performed to ensure that the value computed for y is compatible with the array instance of which x is an element. The check succeeds if y is null, or if an implicit reference conversion (§‎6.1.4) exists from the actual type of the instance referenced by y to the actual element type of the array instance containing x. Otherwise, a System.ArrayTypeMismatchException is thrown.

The value resulting from the evaluation and conversion of y is stored into the location given by the evaluation of x.

If x is classified as a property or indexer access:

The instance expression (if x is not static) and the argument list (if x is an indexer access) associated with x are evaluated, and the results are used in the subsequent set accessor invocation.

y is evaluated and, if required, converted to the type of x through an implicit conversion (§‎6.1).

The set accessor of x is invoked with the value computed for y as its value argument.

The array co-variance rules (§‎12.5) permit a value of an array type A[] to be a reference to an instance of an array type B[], provided an implicit reference conversion exists from B to A. Because of these rules, assignment to an array element of a reference-type requires a run-time check to ensure that the value being assigned is compatible with the array instance. In the example

string[] sa = new string[10]; object[] oa = sa;

oa[0] = null;// Ok oa[1] = "Hello";// Ok oa[2] = new ArrayList();// ArrayTypeMismatchException

the last assignment causes a System.ArrayTypeMismatchException to be thrown because an instance of ArrayList cannot be stored in an element of a string[].

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

Document info
Document views818
Page views818
Page last viewedSun Dec 04 08:38:35 UTC 2016
Pages396
Paragraphs9401
Words133190

Comments