Type: System.Array

array is null.

index is less than zero.

-or-

length is less than zero.

-or-

The sum of index and length is greater than the size of the Array.

Remarks

Reference-type elements are set to null. Boolean-type elements are set to false. Other value-type elements are set to zero.

This method only clears the values of the elements; it does not delete the elements themselves. An Array has a fixed size; therefore, elements cannot be added or removed.

See also:
ICollection.Count

Return to top

Method: Clone()

Summary: Creates a shallow copy of the Array.

C# Syntax:


            public virtual object Clone();

Return Value:: A shallow copy of the Array.

Implements:: ICloneable.Clone

Remarks

A shallow copy of an Array copies only the elements of the Array, whether they are reference types or value types, but it does not copy the objects that the references refer to. The references in the new Array point to the same objects that the references in the original Array point to.

In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

The clone is of the same Type as the original Array.

Return to top

Overloaded Method: Copy(
   Array sourceArray,
   Array destinationArray,
   int length
)

Summary: Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element.

C# Syntax:


            public static void Copy(
   Array sourceArray,
   Array destinationArray,
   int length
);

Parameters:

sourceArray

The Array that contains the data to copy.

destinationArray

The Array that receives the data.

length

The number of elements to copy.

Exceptions

Exception Type	Condition
ArgumentNullException	sourceArray is null. -or- destinationArray is null.
RankException	sourceArray and destinationArray have different ranks.
ArrayTypeMismatchException	sourceArray and destinationArray are of incompatible types.
InvalidCastException	At least one element in sourceArray cannot be cast to the type of destinationArray.
ArgumentOutOfRangeException	length is less than zero.
ArgumentException	length is greater than the number of elements in sourceArray. -or- length is greater than the number of elements in destinationArray.

Remarks

The sourceArray and destinationArray parameters must have the same number of dimensions.

If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

This method is equivalent to the standard C/C++ function memmove, not memcpy.

The arrays can be reference-type arrays or value-type arrays. Type downcasting is performed, as required.

When copying from a reference-type array to a value-type array, each element is unboxed and then copied. When copying from a value-type array to a reference-type array, each element is boxed and then copied.
When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.
If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. A shallow copy of an Array is a new Array containing references to the same elements as the original Array. The elements themselves or anything referenced by the elements are not copied. In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Type compatibility is defined as follows:

A type is compatible with itself.
A value type is compatible with Object and with an interface type implemented by that value type. A value type is considered connected to an interface only if it implements that interface directly. Disconnected types are not compatible.
Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. A widening conversion never loses information, whereas a narrowing conversion can lose information. For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. For more information about conversions, see Convert.
A nonintrinsic (user-defined) value type is compatible only with itself.

If every element in sourceArray requires a downcast (for example, from a base class to a derived class or from an interface to an object) and one or more elements cannot be cast to the corresponding type in destinationArray, an InvalidCastException is thrown.

If this method throws an exception while copying, the state of destinationArray is undefined.

Return to top

Overloaded Method: Copy(
   Array sourceArray,
   int sourceIndex,
   Array destinationArray,
   int destinationIndex,
   int length
)

Summary: Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index.

C# Syntax:


            public static void Copy(
   Array sourceArray,
   int sourceIndex,
   Array destinationArray,
   int destinationIndex,
   int length
);

Parameters:

sourceArray

The Array that contains the data to copy.

sourceIndex

The index in the sourceArray at which copying begins.

destinationArray

The Array that receives the data.

destinationIndex

The index in the destinationArray at which storing begins.

length

The number of elements to copy.

Exceptions

Exception Type	Condition
ArgumentNullException	sourceArray is null. -or- destinationArray is null.
RankException	sourceArray and destinationArray have different ranks.
ArrayTypeMismatchException	sourceArray and destinationArray are of incompatible types.
InvalidCastException	At least one element in sourceArray cannot be cast to the type of destinationArray.
ArgumentOutOfRangeException	sourceIndex is less than the lower bound of the first dimension of sourceArray. -or- destinationIndex is less than the lower bound of the first dimension of destinationArray. -or- length is less than zero.
ArgumentException	The sum of sourceIndex and length is greater than the number of elements in sourceArray. -or- The sum of destinationIndex and length is greater than the number of elements in destinationArray.

Remarks

The sourceArray and destinationArray parameters must have the same number of dimensions.

When copying between multidimensional arrays, the array behaves like a long one-dimensional array, where the rows (or columns) are conceptually laid end to end. For example, if an array has three rows (or columns) with four elements each, copying six elements from the beginning of the array would copy all four elements of the first row (or column) and the first two elements of the second row (or column). To start copying from the second element of the third row (or column), srcIndex must be the upper bound of the first row (or column) plus the length of the second row (or column) plus two.

If sourceArray and destinationArray overlap, this method behaves as if the original values of sourceArray were preserved in a temporary location before destinationArray is overwritten.

This method is equivalent to the standard C/C++ function memmove, not memcpy.

The arrays can be reference-type arrays or value-type arrays. Type downcasting is performed, as required.

When copying from a reference-type array to a value-type array, each element is unboxed and then copied. When copying from a value-type array to a reference-type array, each element is boxed and then copied.
When copying from a reference-type or value-type array to an Object array, an Object is created to hold each value or reference and then copied. When copying from an Object array to a reference-type or value-type array and the assignment is not possible, an InvalidCastException is thrown.
If sourceArray and destinationArray are both reference-type arrays or are both arrays of type Object, a shallow copy is performed. A shallow copy of an Array is a new Array containing references to the same elements as the original Array. The elements themselves or anything referenced by the elements are not copied. In contrast, a deep copy of an Array copies the elements and everything directly or indirectly referenced by the elements.

An ArrayTypeMismatchException is thrown if the arrays are of incompatible types. Type compatibility is defined as follows:

A type is compatible with itself.
A value type is compatible with Object and with an interface type implemented by that value type. A value type is considered connected to an interface only if it implements that interface directly. Disconnected types are not compatible.
Two intrinsic (predefined) value types are compatible if copying from the source type to the destination type is a widening conversion. A widening conversion never loses information, whereas a narrowing conversion can lose information. For example, converting a 32-bit signed integer to a 64-bit signed integer is a widening conversion, and converting a 64-bit signed integer to a 32-bit signed integer is a narrowing conversion. For more information about conversions, see Convert.
A nonintrinsic (user-defined) value type is compatible only with itself.

If this method throws an exception while copying, the state of destinationArray is undefined.

Example

The following code example shows how to copy from one Array of type Object to another Array of type integer.

 using System;
 public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes a new Array of type Int32.
       Array myIntArray=Array.CreateInstance( Type.GetType("System.Int32"), 5 );
       for ( int i = myIntArray.GetLowerBound(0); i <= myIntArray.GetUpperBound(0); i++ )
          myIntArray.SetValue( i+1, i );
 
       // Creates and initializes a new Array of type Object.
       Array myObjArray = Array.CreateInstance( Type.GetType("System.Object"), 5 );
       for ( int i = myObjArray.GetLowerBound(0); i <= myObjArray.GetUpperBound(0); i++ )
          myObjArray.SetValue( i+26, i );
 
       // Displays the initial values of both arrays.
       Console.WriteLine( "Int32 array:" );
       PrintValues( myIntArray );
       Console.WriteLine( "Object array:" );
       PrintValues( myObjArray );
 
       // Copies the first element from the Int32 array to the Object array.
       Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray, myObjArray.GetLowerBound(0), 1 );
 
       // Copies the last two elements from the Object array to the Int32 array.
       Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );
 
       // Displays the values of the modified arrays.
       Console.WriteLine( "Int32 array - Last two elements should now be the same as Object array:" );
       PrintValues( myIntArray );
       Console.WriteLine( "Object array - First element should now be the same as Int32 array:" );
       PrintValues( myObjArray );
    }
 
 
    public static void PrintValues( Array myArr )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "\t{0}", myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /*
 This code produces the following output.
 
 Int32 array:
     1    2    3    4    5
 Object array:
     26    27    28    29    30
 Int32 array - Last two elements should now be the same as Object array:
     1    2    3    29    30
 Object array - First element should now be the same as Int32 array:
     1    27    28    29    30
 */

Return to top

Method: CopyTo(
Array array,
int index
)

Summary: Copies all the elements of the current one-dimensional Array to the specified one-dimensional Array starting at the specified destination Array index.

C# Syntax:


            public virtual void CopyTo(
   Array array,
   int index
);

Parameters:

array

The one-dimensional Array that is the destination of the elements copied from the current Array.

index

The index in array at which copying begins.

Exceptions

Exception Type	Condition
ArgumentNullException	array is null.
RankException	The source Array is multidimensional. -or- array is multidimensional.
ArgumentOutOfRangeException	index is less than zero.
ArgumentException	index is equal to or greater than the length of array. -or- The number of elements in the source Array is greater than the available space from index to the end of the destination array.
ArrayTypeMismatchException	The type of the source Array cannot be cast automatically to the type of the destination array.

Implements:: ICollection.CopyTo

Remarks

This method supports the ICollection interface. If implementing ICollection is not explicitly required, use Array.Copy to avoid an extra indirection.

If this method throws an exception while copying, the state of array is undefined.

Example

The following code example shows how to copy an Array to another Array.

 using System;
 public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes two new Arrays.
       Array mySourceArray=Array.CreateInstance( typeof(String), 6 );
       mySourceArray.SetValue( "three", 0 );
       mySourceArray.SetValue( "napping", 1 );
       mySourceArray.SetValue( "cats", 2 );
       mySourceArray.SetValue( "in", 3 );
       mySourceArray.SetValue( "the", 4 );
       mySourceArray.SetValue( "barn", 5 );
       Array myTargetArray=Array.CreateInstance( typeof(String), 15 );
       myTargetArray.SetValue( "The", 0 );
       myTargetArray.SetValue( "quick", 1 );
       myTargetArray.SetValue( "brown", 2 );
       myTargetArray.SetValue( "fox", 3 );
       myTargetArray.SetValue( "jumped", 4 );
       myTargetArray.SetValue( "over", 5 );
       myTargetArray.SetValue( "the", 6 );
       myTargetArray.SetValue( "lazy", 7 );
       myTargetArray.SetValue( "dog", 8 );
 
       // Displays the values of the Array.
       Console.WriteLine( "The target Array contains the following (before and after copying):" );
       PrintValues( myTargetArray, ' ' );
 
       // Copies the source Array to the target Array, starting at index 6.
       mySourceArray.CopyTo( myTargetArray, 6 );
 
       // Displays the values of the Array.
       PrintValues( myTargetArray, ' ' );
    }
 
 
    public static void PrintValues( Array myArr, char mySeparator )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "{0}{1}", mySeparator, myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /*
 This code produces the following output.
 
  The target Array contains the following (before and after copying):
  The quick brown fox jumped over the lazy dog      
  The quick brown fox jumped over three napping cats in the barn
 */

The following code example shows how to copy an Array to another Array with a nonzero lower bound. Note that the entire source Array is copied, including empty elements that overwrite existing elements in the target Array.

 public class SamplesArray2{
 
    public static void Main()  {
       // Creates and initializes the source Array.
       Array myArrayZero=Array.CreateInstance( typeof(String), 3 );
       myArrayZero.SetValue( "zero", 0 );
       myArrayZero.SetValue( "one", 1 );
 
       // Displays the source Array.
       Console.WriteLine( "The array with lower bound=0 contains:" );
       PrintIndexAndValues( myArrayZero );
 
       // Creates and initializes the target Array.
       int[] myArrLen = { 4 };
       int[] myArrLow = { 2 };
       Array myArrayTwo=Array.CreateInstance( typeof(String), myArrLen, myArrLow );
       myArrayTwo.SetValue( "two", 2 );
       myArrayTwo.SetValue( "three", 3 );
       myArrayTwo.SetValue( "four", 4 );
       myArrayTwo.SetValue( "five", 5 );
 
       // Displays the target Array.
       Console.WriteLine( "The array with lower bound=2 contains:" );
       PrintIndexAndValues( myArrayTwo );
 
       // Copies from the array with lower bound=0 to the array with lower bound=2.
       myArrayZero.CopyTo( myArrayTwo, 3 );
 
       // Displays the modified target Array.
       Console.WriteLine( "\nAfter copying to the target array from index 3:" );
       PrintIndexAndValues( myArrayTwo );
    }
 
 
    public static void PrintIndexAndValues( Array myArray )  {
       for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
          Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.GetValue( i ) );
    }
 }
 /* 
 This code produces the following output.
 
 The array with lower bound=0 contains:
     [0]:    zero
     [1]:    one
     [2]:    
 The array with lower bound=2 contains:
     [2]:    two
     [3]:    three
     [4]:    four
     [5]:    five
 
 After copying to the target array from index 3:
     [2]:    two
     [3]:    zero
     [4]:    one
     [5]:
 */

See also:
ICollection | Array.Copy

Return to top

Overloaded Method: CreateInstance(
Type elementType,
int length
)

Summary: Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

C# Syntax:


            public static Array CreateInstance(
   Type elementType,
   int length
);

Parameters:

elementType

The Type of the Array to create.

length

The size of the Array to create.

Return Value:: A new one-dimensional Array of the specified Type with the specified length, using zero-based indexing.

Exceptions

Exception Type	Condition
ArgumentNullException	elementType is null.
ArgumentException	elementType is not a valid Type.
ArgumentOutOfRangeException	length is less than zero.

Remarks

Unlike most classes, Array provides the Array.CreateInstance method, instead of public constructors, to allow for late bound access.

Reference-type elements are initialized to null. Value-type elements are initialized to zero.

Example

The following code example shows how to create and initialize a one-dimensional Array.

 using System;
 public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes a one-dimensional Array of type Int32.
       Array my1DArray=Array.CreateInstance( typeof(Int32), 5 );
       for ( int i = my1DArray.GetLowerBound(0); i <= my1DArray.GetUpperBound(0); i++ )
          my1DArray.SetValue( i+1, i );
 
       // Displays the values of the Array.
       Console.WriteLine( "The one-dimensional Array contains the following values:" );
       PrintValues( my1DArray );
    }
 
 
    public static void PrintValues( Array myArr )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "\t{0}", myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /*
 This code produces the following output.
 
 The one-dimensional Array contains the following values:
     1    2    3    4    5
 */

Return to top

Overloaded Method: CreateInstance(
Type elementType,
int[] lengths
)

Summary: Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing.

C# Syntax:


            public static Array CreateInstance(
   Type elementType,
   int[] lengths
);

Parameters:

elementType

The Type of the Array to create.

lengths

An array that contains the size of each dimension of the Array to create.

Return Value:: A new multidimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.

Exceptions

Exception Type	Condition
ArgumentNullException	elementType is null. -or- lengths is null.
ArgumentException	elementType is not a valid Type. -or- The lengths array contains less than one element.
ArgumentOutOfRangeException	Any value in lengths is less than zero.

Exception Type

Condition

elementType is null.

-or-

lengths is null.

elementType is not a valid Type.

-or-

The lengths array contains less than one element.

Any value in lengths is less than zero.

Remarks

Unlike most classes, Array provides the Array.CreateInstance method, instead of public constructors, to allow for late bound access.

The number of elements in the lengths array must equal the number of dimensions in the new Array. Each element of the lengths array must specify the length of the corresponding dimension in the new Array.

Reference-type elements are initialized to null. Value-type elements are initialized to zero.

Example

The following code example shows how to create and initialize a multidimensional Array.

 using System;
 public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes a multidimensional Array of type String.
       int[] myLengthsArray = new int[4] { 2, 3, 4, 5 };
       Array my4DArray=Array.CreateInstance( typeof(String), myLengthsArray );
       for ( int i = my4DArray.GetLowerBound(0); i <= my4DArray.GetUpperBound(0); i++ )
          for ( int j = my4DArray.GetLowerBound(1); j <= my4DArray.GetUpperBound(1); j++ )
             for ( int k = my4DArray.GetLowerBound(2); k <= my4DArray.GetUpperBound(2); k++ )
                for ( int l = my4DArray.GetLowerBound(3); l <= my4DArray.GetUpperBound(3); l++ )  {
                   int[] myIndicesArray = new int[4] { i, j, k, l };
                   my4DArray.SetValue( Convert.ToString(i) + j + k + l, myIndicesArray );
                }
 
       // Displays the values of the Array.
       Console.WriteLine( "The four-dimensional Array contains the following values:" );
       PrintValues( my4DArray );
    }
 
 
    public static void PrintValues( Array myArr )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "\t{0}", myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /*
 This code produces the following output.
 
 The four-dimensional Array contains the following values:
     0000    0001    0002    0003    0004
     0010    0011    0012    0013    0014
     0020    0021    0022    0023    0024
     0030    0031    0032    0033    0034
     0100    0101    0102    0103    0104
     0110    0111    0112    0113    0114
     0120    0121    0122    0123    0124
     0130    0131    0132    0133    0134
     0200    0201    0202    0203    0204
     0210    0211    0212    0213    0214
     0220    0221    0222    0223    0224
     0230    0231    0232    0233    0234
     1000    1001    1002    1003    1004
     1010    1011    1012    1013    1014
     1020    1021    1022    1023    1024
     1030    1031    1032    1033    1034
     1100    1101    1102    1103    1104
     1110    1111    1112    1113    1114
     1120    1121    1122    1123    1124
     1130    1131    1132    1133    1134
     1200    1201    1202    1203    1204
     1210    1211    1212    1213    1214
     1220    1221    1222    1223    1224
     1230    1231    1232    1233    1234
 */

Return to top

Overloaded Method: CreateInstance(
   Type elementType,
   int length1,
   int length2
)

Summary: Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

C# Syntax:


            public static Array CreateInstance(
   Type elementType,
   int length1,
   int length2
);

Parameters:

elementType

The Type of the Array to create.

length1

The size of the first dimension of the Array to create.

length2

The size of the second dimension of the Array to create.

Return Value:: A new two-dimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.

Exceptions

Exception Type

Condition

elementType is null.

elementType is not a valid Type.

length1 is less than zero.

-or-

length2 is less than zero.

Remarks

Unlike most classes, Array provides the Array.CreateInstance method, instead of public constructors, to allow for late bound access.

Reference-type elements are initialized to null. Value-type elements are initialized to zero.

Example

The following code example shows how to create and initialize a two-dimensional Array.

 using System;
 public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes a two-dimensional Array of type String.
       Array my2DArray=Array.CreateInstance( typeof(String), 2, 3 );
       for ( int i = my2DArray.GetLowerBound(0); i <= my2DArray.GetUpperBound(0); i++ )
          for ( int j = my2DArray.GetLowerBound(1); j <= my2DArray.GetUpperBound(1); j++ )
             my2DArray.SetValue( "abc" + i + j, i, j );
 
       // Displays the values of the Array.
       Console.WriteLine( "The two-dimensional Array contains the following values:" );
       PrintValues( my2DArray );
    }
 
 
    public static void PrintValues( Array myArr )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "\t{0}", myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /* 
 This code produces the following output.
 
 The two-dimensional Array contains the following values:
     abc00    abc01    abc02
     abc10    abc11    abc12
 */

Return to top

Overloaded Method: CreateInstance(
   Type elementType,
   int[] lengths,
   int[] lowerBounds
)

Summary: Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

C# Syntax:


            public static Array CreateInstance(
   Type elementType,
   int[] lengths,
   int[] lowerBounds
);

Parameters:

elementType

The Type of the Array to create.

lengths

A one-dimensional array that contains the size of each dimension of the Array to create.

lowerBounds

A one-dimensional array that contains the lower bound (starting index) of each dimension of the Array to create.

Return Value:: A new multidimensional Array of the specified Type with the specified length and lower bound for each dimension.

Exceptions

Exception Type	Condition
ArgumentNullException	elementType is null. -or- lengths is null. -or- lowerBounds is null.
ArgumentException	elementType is not a valid Type. -or- The lengths array contains less than one element. -or- The lengths and lowerBounds arrays do not contain the same number of elements.
ArgumentOutOfRangeException	Any value in lengths is less than zero.

Exception Type

Condition

elementType is null.

-or-

lengths is null.

-or-

lowerBounds is null.

elementType is not a valid Type.

-or-

The lengths array contains less than one element.

-or-

The lengths and lowerBounds arrays do not contain the same number of elements.

Any value in lengths is less than zero.

Remarks

Unlike most classes, Array provides the Array.CreateInstance method, instead of public constructors, to allow for late bound access.

The lengths and lowerBounds arrays must have the same number of elements. The number of elements in the lengths array must equal the number of dimensions in the new Array.

Each element of the lengths array must specify the length of the corresponding dimension in the new Array.

Each element of the lowerBounds array must specify the lower bound of the corresponding dimension in the new Array. Generally, the .NET Framework class library and many programming languages do not handle nonzero lower bounds.

Reference-type elements are initialized to null. Value-type elements are initialized to zero.

Example

The following code example shows how to create and initialize a multidimensional Array with specified lower bounds.

 using System;
 public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes a multidimensional Array of type String.
       int[] myLengthsArray = new int[2] { 3, 5 };
       int[] myBoundsArray = new int[2] { 2, 3 };
       Array myArray=Array.CreateInstance( typeof(String), myLengthsArray, myBoundsArray );
       for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
          for ( int j = myArray.GetLowerBound(1); j <= myArray.GetUpperBound(1); j++ )  {
             int[] myIndicesArray = new int[2] { i, j };
             myArray.SetValue( Convert.ToString(i) + j, myIndicesArray );
          }
 
       // Displays the lower bounds and the upper bounds of each dimension.
       Console.WriteLine( "Bounds:\tLower\tUpper" );
       for ( int i = 0; i < myArray.Rank; i++ )
          Console.WriteLine( "{0}:\t{1}\t{2}", i, myArray.GetLowerBound(i), myArray.GetUpperBound(i) );
 
       // Displays the values of the Array.
       Console.WriteLine( "The Array contains the following values:" );
       PrintValues( myArray );
    }
 
 
    public static void PrintValues( Array myArr )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "\t{0}", myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /* 
 This code produces the following output.
 
 Bounds:    Lower    Upper
 0:    2    4
 1:    3    7
 The Array contains the following values:
     23    24    25    26    27
     33    34    35    36    37
     43    44    45    46    47
 */

Return to top

Overloaded Method: CreateInstance(
   Type elementType,
   int length1,
   int length2,
   int length3
)

Summary: Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

C# Syntax:


            public static Array CreateInstance(
   Type elementType,
   int length1,
   int length2,
   int length3
);

Parameters:

elementType

The Type of the Array to create.

length1

The size of the first dimension of the Array to create.

length2

The size of the second dimension of the Array to create.

length3

The size of the third dimension of the Array to create.

Return Value:: A new three-dimensional Array of the specified Type with the specified length for each dimension, using zero-based indexing.

Exceptions

Exception Type

Condition

elementType is null.

elementType is not a valid Type.