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.
Chapter 14 Expressions
173
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 (?3.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 (?3.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 (?3.1).
The set accessor of x is invoked with the value computed for y as its value
argument.
[Note: The array covariance rules (?9.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[]. end note]
When a property or indexer declared in a struct-type is the target of an
assignment, the instance expression
associated with the property or indexer access must be classified as a
variable. If the instance expression is
classified as a value, a compile-time error occurs. [Note: Because of ?4.5.4
, the same rule also applies to
fields. end note]
[Example: Given the declarations:
struct Point
{
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public int X {
get { return x; }
set { x = value; }
}
C# LANGUAGE SPECIFICATION
174
public int Y {
get { return y; }
set { y = value; }
}
}
struct Rectangle
{
Point a, b;
public Rectangle(Point a, Point b) {
this.a = a;
this.b = b;
}
public Point A {
get { return a; }
set { a = value; }
}
public Point B {
get { return b; }
set { b = value; }
}
}
in the example
Point p = new Point();
p.X = 100;
p.Y = 100;
Rectangle r = new Rectangle();
r.A = new Point(10, 10);
r.B = p;
the assignments to p.X, p.Y, r.A, and r.B are permitted because p and r are
variables. However, in the
example
Rectangle r = new Rectangle();
r.A.X = 10;
r.A.Y = 10;
r.B.X = 100;
r.B.Y = 100;
the assignments are all invalid, since r.A and r.B are not variables. end
example]