For any two reference-types A
and B
, if an implicit reference conversion (§6.1.4) or explicit reference conversion (§6.2.3) exists from A
to B
, then the same reference conversion also exists from the array type A[R]
to the array type B[R]
, where R
is any given rank-specifier (but the same for both array types). This relationship is known as array covariance. Array covariance in particular means that a value of an array type A[R]
may actually be a reference to an instance of an array type B[R]
, provided an implicit reference conversion exists from B
to A
.
Because of array covariance, assignments to elements of reference type arrays include a run-time check which ensures that the value being assigned to the array element is actually of a permitted type (§7.13.1). For example:
class Test { static void Fill(object[] array, int index, int count, object value) { for (int i = index; i < index + count; i++) array[i] = value; } static void Main() { string[] strings = new string[100]; Fill(strings, 0, 100, "Undefined"); Fill(strings, 0, 10, null); Fill(strings, 90, 10, 0); } }
The assignment to array[i]
in the Fill
method implicitly includes a run-time check which ensures that the object referenced by value
is either null
or an instance of a type that is compatible with the actual element type of array
. In Main
, the first two invocations of Fill
succeed, but the third invocation causes an ArrayTypeMismatchException
to be thrown upon executing the first assignment to array[i]
. The exception occurs because a boxed int
cannot be stored in a string
array.
Array covariance specifically does not extend to arrays of value-types. For example, no conversion exists that permits an int[]
to be treated as an object[]
.