BCL mscorlib [00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ] 1.0.5000.0 2.0.0.0 4.0.0.0 All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe. System.Object System.Collections.IList System.Collections.IStructuralComparable System.Collections.IStructuralEquatable System.ICloneable

Serves as the base class for arrays. Provides methods for creating, copying, manipulating, searching, and sorting arrays.

This class is intended to be used as a base class by language implementations that support arrays. Only the system can derive from this type: derived classes of are not to be created by the developer.

An array is a collection of identically typed data that are accessed and referenced by sets of integral .

The of an array is the number of dimensions in the array. Each dimension has its own set of indices. An array with a rank greater than one can have a different lower bound and a different number of elements for each dimension. Multidimensional arrays (i.e. arrays with a rank greater than one) are processed in row-major order.

The of a dimension is the starting index of that dimension.

The of an array is the total number of elements contained in all of its dimensions.

A is a one-dimensional array with a of '0'.

If the implementer creates a derived class of , expected behavior cannot be guaranteed. For information on array-like objects with increased functionality, see the and interfaces. For more information regarding the use of arrays versus the use of collections, see Partition V of the CLI Specification.

Every specific type has three instance methods defined on it. While some programming languages allow direct access to these methods, they are primarily intended to be called by the output of compilers based on language syntax that deals with arrays.

Get: Takes as many arguments as the array has dimensions and returns the value stored at the given index. It throws a exception for invalid indices.

Set: Takes as many arguments as the array has dimensions, plus one additional argument (the last argument) which has the same type as an array element. It stores the final value in the specified index of the array. It throws a exception for invalid indices.

Address: Takes as many arguments as the array has dimensions and returns the address of the element at the given index. It throws a exception for invalid indices.

In addition, every specific type has a constructor on it that takes as many non-negative arguments as the array has dimensions. The arguments specify the number of elements in each dimension, and a lower bound of 0. Thus, a two-dimensional array of objects would have a constructor that could be called with (2, 4) as its arguments to create an array of eight zeros with the first dimension indexed with 0 and 1 and the second dimension indexed with 0, 1, 2, and 3.

For all specific array types except vectors (i.e. those permitted to have non-zero lower bounds and those with more than one dimension) there is an additional constructor. It takes twice as many arguments as the array has dimensions. The arguments are considered in pairs, with the first of the pair specifying the lower bound for that dimension and the second specifying the total number of elements in that dimension. Thus, a two-dimensional array of

objects would also have a constructor that could be called with (-1, 2, 1, 3) as its arguments, specifying an array of 6 zeros, with the first dimension indexed by -1 and 0, and the second dimension indexed by 1, 2, and 3.

Enumeration over an array occurs in ascending row-major order, starting from the first element. (For example, a 2x3 array is traversed in the order [0,0], [0,1], [0,2], [1,0], [1,1], and [1,2].)

Parallel implementation of methods taking a argument are not permitted.

- Method
  System.Collections.ObjectModel.ReadOnlyCollection<T> `` To be added. The array to wrap in a read-only wrapper.

  Returns a read-only wrapper around the specified array.

  A read-only wrapper around the specified array.

  To prevent any modifications to the array, expose the array only through this wrapper.

  The returned has the same enumeration order as the array it wraps.

  A collection that is read-only is simply a collection with a wrapper that prevents modifying the underlying array; therefore, if changes are made to the underlying array, the read-only collection reflects those changes.

  is . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` A to search for an object. A for which to search.

  Searches the specified one-dimensional for the specified object.

  A with one of the following values based on the result of the search operation.

  Return Value
  Description
  The index of in the array.
  was found.
  The bitwise complement of the index of the first element that is larger than .
  was not found and the value of at least one element of was greater than .
  The bitwise complement of (.GetLowerBound(0) + .Length).
  was not found, and was greater than the value of all array elements.

  If is not found, the caller can take the bitwise complement of the return value to determine the index where value would be found in if it is sorted already.

  This version of is equivalent to (, .GetLowerBound(0), .Length, , ).

  is compared to each element of using the interface of the element being compared - or of if the element being compared does not implement the interface - until an element with a value greater than or equal to is found. If does not implement the interface and is compared to an element that does not implement the interface, a exception is thrown. If is not already sorted, correct results are not guaranteed.

  A null reference can be compared with any type; therefore, comparisons with a null reference do not generate exceptions.

  Both and at least one element of do not implement the interface.

  -or-

  is not assignment-compatible with at least one element of .

  -or-

  .UpperBound == .

  is .

  has more than one dimension.

  Both and at least one element of do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` A to search. A for which to search.

  The implementation to use when comparing elements. Specify a null reference to use the implementation of each element.

  Searches the specified one-dimensional for the specified value, using the specified implementation.

  A with one of the following values based on the result of the search operation.

  Return Value
  Description
  The index of in the array.
  was found.
  The bitwise complement of the index of the first element that is larger than .
  was not found, and at least one array element was greater than .
  The bitwise complement of (.GetLowerBound(0) + .Length).
  was not found, and was greater than all array elements.

  If is not found, the caller can take the bitwise complement of the return value to determine the index where value would be found in if it is already sorted.

  This version of is equivalent to (, .GetLowerBound(0), .Length, , ).

  is compared to each element of using until an element with a value greater than or equal to is found. If is , the interface of the element being compared - or of if the element being compared does not implement the interface - is used. If does not implement the interface and is compared to an element that does not implement the interface, a exception is thrown. If is not already sorted, correct results are not guaranteed.

  A null reference can be compared with any type; therefore, comparisons with a null reference do not generate exceptions.

  is , and both and at least one element of do not implement the interface.

  -or-

  is , and is not assignment-compatible with at least one element of .

  -or-

  .UpperBound == .

  is . has more than one dimension.

  is , and both and at least one element of do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` `` A to search. A that contains the index at which searching starts. A that contains the number of elements to search, beginning with . A for which to search.

  Searches the specified section of the specified one-dimensional for the specified value.

  A with one of the following values based on the result of the search operation.

  Return Value
  Description
  The index of in the array.
  was found.
  The bitwise complement of the index of the first element that is larger than .
  was not found, and at least one array element in the range of to + - 1 was greater than .
  The bitwise complement of ( + ).
  was not found, and was greater than all array elements in the range of to + - 1.

  If is not found, the caller can take the bitwise complement of the return value to determine the index of the array where would be found in the range of to + - 1 if is already sorted.

  This version of is equivalent to (, .GetLowerBound(0), .Length, , ).

  is compared to each element of using the interface of the element being compared - or of if the element being compared does not implement the interface - until an element with a value greater than or equal to is found. If does not implement the interface and is compared to an element that does not implement the interface, a exception is thrown. If is not already sorted, correct results are not guaranteed.

  A null reference can be compared with any type; therefore, comparisons with a null reference do not generate exceptions.

  is . has more than one dimension.

  < .GetLowerBound(0).

  -or-

  < 0.

  and do not specify a valid range in (i.e. + > .GetLowerBound(0) + .Length).

  -or-

  .UpperBound == .

  Either or at least one element of does not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` `` `` A to search. A that contains the index at which searching starts. A that contains the number of elements to search, beginning with . A for which to search.

  The implementation to use when comparing elements. Specify a null reference to use the implementation of each element.

  Searches the specified section of the specified one-dimensional for the specified value, using the specified implementation.

  A with one of the following values based on the result of the search operation.

  Return Value
  Description
  The index of in the array.
  was found.
  The bitwise complement of the index of the first element that is larger than .
  was not found, and at least one array element in the range of to + - 1 was greater than .
  The bitwise complement of ( + ).
  was not found, and was greater than all array elements in the range of to + - 1.

  If is not found, the caller can take the bitwise complement of the return value to determine the index of where would be found in the range of to + - 1 if is already sorted.

  is compared to each element of using until an element with a value greater than or equal to is found. If is , the interface of the element being compared - or of if the element being compared does not implement the interface -- is used. If does not implement the interface and is compared to an element that does not implement the interface, a exception is thrown. If is not already sorted, correct results are not guaranteed.

  A null reference can be compared with any type; therefore, comparisons with a null reference do not generate exceptions.

  is . has more than one dimension.

  is less than .

  -or-

  is less than zero.

  + is greater than + .

  -or-

  .UpperBound == .

  This example demonstrates the method.

  `using System; class BinarySearchExample { public static void Main() { int[] intAry = { 0, 2, 4, 6, 8 }; Console.WriteLine( "The indices and elements of the array are: "); for ( int i = 0; i < intAry.Length; i++ ) Console.Write("[{0}]: {1, -5}", i, intAry[i]); Console.WriteLine(); SearchFor( intAry, 3 ); SearchFor( intAry, 6 ); SearchFor( intAry, 9 ); } public static void SearchFor( Array ar, Object value ) { int i = Array.BinarySearch( ar, 0, ar.Length, value, null ); Console.WriteLine(); if ( i > 0 ) { Console.Write( "The object searched for, {0}, was found ", value ); Console.WriteLine( "at index {1}.", value, i ); } else if ( ~i == ar.Length ) { Console.Write( "The object searched for, {0}, was ", value ); Console.Write( "not found,\nand no object in the array had " ); Console.WriteLine( "greater value. " ); } else { Console.Write( "The object searched for, {0}, was ", value ); Console.Write( "not found.\nThe next larger object is at " ); Console.WriteLine( "index {0}.", ~i ); } } }`

  The output is

  The indices and elements of the array are:

  [0]:0 [1]:2 [2]:4 [3]:6 [4]:8

  The object searched for, 3, was not found.

  The next larger object is at index 2.

  The object searched for, 6, was found at index 3.

  The object searched for, 9, was not found,

  and no object in the array had greater value.

  is , and both and at least one element of do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` To be added. The one-dimensional array to search. The object for which to search.

  Searches an entire one-dimensional sorted array for a specific element, using the or interface implemented by each element of the array and by the specified object.

  One of the following values based on the result of the search operation:

  Return Value
  Description
  A non-negative index of in the array.
  was found.
  A negative value, which is the bitwise complement of the index of the first element that is larger than .
  was not found and the value of at least one element of array was greater than .
  A negative value, which is the bitwise complement of one more than the index of the final element.
  was not found, and was greater than the value of all array elements.

  Either or every element of must implement the or interface, which is used for comparisons. The elements of must already be sorted in increasing value according to the sort order defined by the or implementation; otherwise, the behavior is unspecified

  Duplicate elements are allowed. If the array contains more than one element equal to , the method returns the index of only one of the occurrences, but not necessarily the first one.

  can always be compared with any other reference type; therefore, comparisons with do not generate an exception.

  is .

  Neither nor the elements of the array implement the or interfaces.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` To be added. The one-dimensional array to search. The object for which to search.

  The implementation to use when comparing elements.

  -or-

  to use the or implementation of each element.

  Searches an entire one-dimensional sorted array for a value using the specified interface.

  One of the following values based on the result of the search operation:

  Return Value
  Description
  A non-negative index of in the array.
  was found.
  A negative value, which is the bitwise complement of the index of the first element that is larger than .
  was not found and the value of at least one element of array was greater than .
  A negative value, which is the bitwise complement of one more than the index of the final element.
  was not found, and was greater than the value of all array elements.

  The comparer customizes how the elements are compared.

  The elements of must already be sorted in increasing value according to the sort order defined by ; otherwise, the behavior is unspecified

  If is not , the elements of are compared to the specified value using the specified implementation.

  If is , the default comparer is used.

  Duplicate elements are allowed. If the array contains more than one element equal to , the method returns the index of only one of the occurrences, but not necessarily the first one.

  can always be compared with any other reference type; therefore, comparisons with do not generate an exception.

  is .

  is , and neither nor the elements of the array implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` `` To be added. The one-dimensional array to search. To be added. The length of the range to search. The object for which to search.

  Searches a range of elements in a one-dimensional sorted array for a value, using the interface implemented by each element of the array and by the specified value.

  One of the following values based on the result of the search operation:

  Return Value
  Description
  A non-negative index of in the array.
  was found.
  A negative value, which is the bitwise complement of the index of the first element that is larger than .
  was not found and the value of at least one element of array was greater than .
  A negative value, which is the bitwise complement of one more than the index of the final element.
  was not found, and was greater than the value of all array elements.

  Either or every element of must implement the interface, which is used for comparisons. The elements of must already be sorted in increasing value according to the sort order defined by the or implementation; otherwise, the behavior is unspecified

  Duplicate elements are allowed. If the array contains more than one element equal to , the method returns the index of only one of the occurrences, but not necessarily the first one.

  can always be compared with any other reference type; therefore, comparisons with do not generate an exception.

  + is greater than .

  is .

  is less than zero

  -or-

  is less than zero.

  Neither nor the elements of the array implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` `` `` To be added. The one-dimensional array to search. The starting index of the range to search. The length of the range to search. The object for which to search.

  The implementation to use when comparing elements.

  -or-

  to use the or implementation of each element.

  Searches a range of elements in a one-dimensional sorted array for a value, using the specified interface.

  One of the following values based on the result of the search operation:

  Return Value
  Description
  A non-negative index of in the array.
  was found.
  A negative value, which is the bitwise complement of the index of the first element that is larger than .
  was not found and the value of at least one element of array was greater than .
  A negative value, which is the bitwise complement of one more than the index of the final element.
  was not found, and was greater than the value of all array elements.

  The comparer customizes how the elements are compared.

  The elements of must already be sorted in increasing value according to the sort order defined by ; otherwise, the behavior is unspecified.

  If is not , the elements of are compared to the specified value using the specified implementation.

  If is , the comparison is done using the or implementation provided by the element itself or by the specified value.

  Duplicate elements are allowed. If the array contains more than one element equal to , the method returns the index of only one of the occurrences, but not necessarily the first one.

  can always be compared with any other reference type; therefore, comparisons with do not generate an exception.

  and do not specify a valid range in array.

  is .

  is less than zero

  -or-

  is less than zero.

  is , and neither nor the elements of the array implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` The to clear. A that contains the index at which clearing starts. A that contains the number of elements to clear, beginning with .

  Sets the specified range of elements in the specified to zero, false, or to a null reference, depending on the element type.

  Reference-type elements will be set to . Value-type elements will be set to zero, except for elements, which will be set to .

  is .

  < .GetLowerBound(0).

  < 0.

  and do not specify a valid range in (i.e. + > .GetLowerBound(0) + .Length ).

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
- Method
  System.Object

  Returns a that is a copy of the current instance.

  A that is a copy of the current instance.

  This method is implemented to support the interface.

  Each of the elements of the current instance is copied to the clone. If the elements are reference types, the references are copied. If the elements are value-types, the values are copied. The clone is of the same type as the current instance.

  As described above.

  Override this method to return a clone of an array.

  Use this method to obtain the clone of an array.

  This example demonstrates the method.

  `using System; public class ArrayCloneExample { public static void Main() { int[] intAryOrig = { 3, 4, 5 }; //must explicitly convert clones object into an array int[] intAryClone = (int[]) intAryOrig.Clone(); Console.Write( "The elements of the first array are: " ); foreach( int i in intAryOrig ) Console.Write( "{0,3}", i ); Console.WriteLine(); Console.Write( "The elements of the cloned array are: " ); foreach( int i in intAryClone ) Console.Write( "{0,3}", i ); Console.WriteLine(); //Clear the values of the original array. Array.Clear( intAryOrig, 0, 3 ); Console.WriteLine( "After clearing the first array," ); Console.Write( "The elements of the first array are: " ); foreach( int i in intAryOrig ) Console.Write( "{0,3}", i ); Console.WriteLine(); Console.Write( "The elements of the cloned array are: " ); foreach( int i in intAryClone ) Console.Write( "{0,3}", i ); } }`

  The output is

  The elements of the first array are: 3 4 5

  The elements of the cloned array are: 3 4 5

  After clearing the first array,

  The elements of the first array are: 0 0 0

  The elements of the cloned array are: 3 4 5

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` `` `` `` To be added. To be added. To be added. To be added. To be added. To be added. To be added. 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
- Method
  TOutput[] `` `` To be added. To be added. The one-dimensional array to convert.

  A that converts each element from one type to another type.

  Converts an array of one type to an array of another type.

  A new array of the target type containing the converted elements from .

  The is a delegate that converts an array element to the target type. The elements of are individually passed to this converter, and the converted elements are saved in the new array. The source array remains unchanged.

  is or is . 2.0.0.0 4.0.0.0
- Method
  System.Void `` `` `` A that contains the data to copy. A that receives the data. A designating the number of elements to copy, starting with the first element and proceeding in order.

  Copies the specified number of elements from the specified source array to the specified destination array.

  This version of is equivalent to (, .GetLowerBound(0), , .GetLowerBound(0), ).

  If and are of different types, performs widening conversions on the elements of as necessary before storing the information in . Value types will be boxed when being converted to a . If the necessary conversion is a narrowing conversion, a exception is thrown. For information regarding valid conversions performed by this method, see .

  If an exception is thrown while copying, the state of is undefined.

  If and are the same array, copies the source elements safely to their destination, as if the copy were done through an intermediate array.

  or is .

  and have different ranks.

  The elements in both arrays are built-in types, and converting from the type of the elements of into the type of the elements in requires a narrowing conversion.

  -or-

  Both arrays are built-in types, and one array is a value-type array and the other an array of interface type not implemented by that value-type.

  -or-

  Both arrays are user-defined value types and are not of the same type.

  At least one of the elements in is not assignment-compatible with the type of .

  < 0.

  > .Length.

  -or-

  > .Length.

  This example demonstrates the method.

  `using System; public class ArrayCopyExample { public static void Main() { int[] intAryOrig = new int[3]; double[] dAryCopy = new double[3]; for ( int i = 0; i < intAryOrig.Length; i++ ) intAryOrig[i] = i+3; //copy the first 2 elements of the source into the destination Array.Copy( intAryOrig, dAryCopy, 2); Console.Write( "The elements of the first array are: " ); for ( int i = 0; i < intAryOrig.Length; i++ ) Console.Write( "{0,3}", intAryOrig[i] ); Console.WriteLine(); Console.Write( "The elements of the copied array are: " ); for ( int i = 0; i < dAryCopy.Length; i++ ) Console.Write( "{0,3}", dAryCopy[i] ); } }`

  The output is

  The elements of the first array are: 3 4 5

  The elements of the copied array are: 3 4 0

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` `` The that contains the data to copy. A that contains the index in from which copying begins. The that receives the data. A that contains the index in at which storing begins. A that contains the number of elements to copy.

  Copies the specified number of elements from a source array starting at the specified source index to a destination array starting at the specified destination index.

  If and are of different types, performs widening conversions on the elements of as necessary before storing the information in . Value types will be boxed when being converted to a . If the necessary conversion is a narrowing conversion, a exception is thrown. For information regarding valid conversions performed by this method, see .

  If an exception is thrown while copying, the state of is undefined.

  If and are the same array, copies the source elements safely to their destination as if the copy were done through an intermediate array.

  or is .

  and have different ranks.

  The elements in both arrays are built-in types, and converting from the type of the elements of into the type of the elements in requires a narrowing conversion.

  -or-

  Both arrays are built-in types, and one array is a value-type array and the other an array of interface type not implemented by that value-type.

  -or-

  Both arrays are user-defined value types and are not of the same type.

  At least one element in is assignment-incompatible with the type of .

  < .GetLowerBound(0).

  -or-

  < .GetLowerBound(0).

  -or-

  < 0.

  ( + ) > (.GetLowerBound(0) + .Length).

  ( + ) > ( .GetLowerBound(0) + .Length).

  This example demonstrates the method.

  `using System; class ArrayCopyExample { public static void Main() { int[] intAry = { 0, 10, 20, 30, 40, 50 }; Console.Write( "The elements of the array are: " ); foreach ( int i in intAry ) Console.Write( "{0,3}", i ); Console.WriteLine(); Array.Copy( intAry, 2, intAry, 0, 4 ); Console.WriteLine( "After copying elements 2 through 5 into elements 0 through 4" ); Console.Write( "The elements of the array are: " ); foreach ( int i in intAry ) Console.Write( "{0,3}", i ); Console.WriteLine(); } }`

  The output is

  The elements of the array are: 0 10 20 30 40 50

  After copying elements 2 through 5 into elements 0 through 4

  The elements of the array are: 20 30 40 50 40 50

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` `` To be added. To be added. To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` A one-dimensional that is the destination of the elements copied from the current instance. A that contains the index in at which copying begins.

  Copies all the elements of the current zero-based instance to the specified one-dimensional array starting at the specified subscript in the destination array.

  is the array index in the destination array at which copying begins.

  This method is implemented to support the interface. If implementing is not explicitly required, use to avoid an extra indirection.

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

  As described above.

  As described above.

  Override this method to copy elements of the current instance to a specified array.

  Use this method to copy elements of the current instance to a specified array.

  is .

  The current instance has more than one dimension.

  < .

  has more than one dimension.

  -or-

  ( + Length of the current instance) > ( + ).

  -or-

  The number of elements in the current instance is greater than the available space from to the end of .

  The element type of the current instance is not assignment-compatible with the element type of .

  The following example shows how to copy the elements of one into another.

  `using System; public class ArrayCopyToExample { public static void Main() { Array aryOne = Array.CreateInstance(typeof(Object), 3); aryOne.SetValue("one", 0); aryOne.SetValue("two", 1); aryOne.SetValue("three", 2); Array aryTwo = Array.CreateInstance(typeof(Object), 5); for (int i=0; i < aryTwo.Length; i++) aryTwo.SetValue(i, i); Console.WriteLine("The contents of the first array are:"); foreach (object o in aryOne) Console.Write("{0} ", o); Console.WriteLine(); Console.WriteLine("The original contents of the second array are:"); foreach (object o in aryTwo) Console.Write("{0} ", o); Console.WriteLine(); aryOne.CopyTo(aryTwo, 1); Console.WriteLine("The new contents of the second array are:"); foreach( object o in aryTwo) Console.Write("{0} ", o); } }`

  The output is

  The contents of the first array are:

  one two three

  The original contents of the second array are:

  0 1 2 3 4

  The new contents of the second array are:

  0 one two three 4

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Array `` `` The of the elements contained in the new instance. A that contains the number of elements contained in the new instance.

  Constructs a zero-based, one-dimensional array with the specified number of elements of the specified type.

  A zero-based, one-dimensional object containing elements of type .

  Reference-type elements will be set to . Value-type elements will be set to zero, except for elements, which will be set to .

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

  is . is not a valid . < 0.

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

  `using System; public class ArrayCreateInstanceExample { public static void Main() { Array intAry = Array.CreateInstance(typeof(int),5); for (int i=intAry.GetLowerBound(0);i<=intAry.GetUpperBound(0);i++) intAry.SetValue(i*3,i); Console.Write("The values of the array are:"); foreach (int i in intAry) Console.Write("{0} ",i); } }`

  The output is

  The values of the array are: 0 3 6 9 12

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Array `` `System.ParamArray` The of the elements contained in the new instance. A one-dimensional array of objects that contains the size of each dimension of the new instance.

  Creates a zero-based, multidimensional array of the specified and dimension lengths.

  A new zero-based, multidimensional instance of the specified with the specified length for each dimension. The of the new instance is equal to .Length.

  The number of elements in is required to equal the number of dimensions in the new instance. Each element of specifies the length of the corresponding dimension in the new instance.

  Reference-type elements will be set to . Value-type elements will be set to zero, except for elements, which will be set to .

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

  or is .

  is not a valid .

  -or-

  .Length = 0.

  A value in is less than zero.

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

  `using System; public class CreateMultiDimArrayExample { public static void Main() { int i, j, k; int[] indexAry = {2, 4, 5}; Array ary = Array.CreateInstance( typeof(int), indexAry ); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ ) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ ) { for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ ) { ary.SetValue( (100*i + 10*j + k), i, j, k ); } } } Console.WriteLine("The elements of the array are:"); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++) { for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ ) { Console.Write("{0, 3} ", ary.GetValue(i, j, k)); } Console.WriteLine(); } Console.WriteLine(); } } }`

  The output is

  `The elements of the array are: 0 1 2 3 4 10 11 12 13 14 20 21 22 23 24 30 31 32 33 34 100 101 102 103 104 110 111 112 113 114 120 121 122 123 124 130 131 132 133 134` 1 ExtendedArray 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Array `` `System.ParamArray` To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Array `` `` `` The of the elements contained in the new instance. A that contains the number of elements contained in the first dimension of the new instance. A that contains the number of elements contained in the second dimension of the new instance.

  Creates a zero-based, two-dimensional array of the specified and dimension lengths.

  A new zero-indexed, two-dimensional instance of objects with the size for the first dimension and for the second.

  Reference-type elements will be set to . Value-type elements will be set to zero, except for elements, which will be set to .

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

  is . is not a valid .

  < 0.

  -or-

  < 0.

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

  `using System; public class Create2DArrayExample { public static void Main() { int i, j; Array ary = Array.CreateInstance( typeof(int), 5, 3 ); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ ) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ ) { ary.SetValue( (10*i + j), i, j ); } } Console.WriteLine("The elements of the array are:"); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++) { Console.Write("{0, 2} ", ary.GetValue(i, j)); } Console.WriteLine(); } } }`

  The output is

  `The elements of the array are: 0 1 2 10 11 12 20 21 22 30 31 32 40 41 42` 1 ExtendedArray 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Array `` `` `` The of the elements contained in the new instance. A one-dimensional array of objects that contains the size of each dimension of the new instance. A one-dimensional array of objects that contains the lower bound of each dimension of the new instance.

  Creates a multidimensional array whose element type is the specified , and dimension lengths and lower bounds, as specified.

  A new multidimensional whose element type is the specified and with the specified length and lower bound for each dimension.

  The and are required to have the same number of elements. The number of elements in equals the number of dimensions in the new instance

  Each element of specifies the length of the corresponding dimension in the new instance.

  Each element of specifies the lower bound of the corresponding dimension in the new instance.

  Reference-type elements will be set to . Value-type elements will be set to zero, except for elements, which will be set to .

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

  , , or is .

  is not a valid .

  -or-

  .Length = 0.

  -or-

  and do not contain the same number of elements.

  A value in is less than zero.

  The following example shows how to create and initialize a multidimensional with specified low bounds.

  `using System; public class MultiDimNonZeroBoundExample { public static void Main() { int i, j, k; int[] indexAry = {4, 2, 3}; int[] lowboundAry = {3, 2, 1}; Array ary = Array.CreateInstance( typeof(int), indexAry, lowboundAry ); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ ) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ ) { for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ ) { ary.SetValue( (100*i + 10*j + k), i, j, k ); } } } Console.WriteLine("The elements of the array are:"); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++) { for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ ) { Console.Write("{0, 3} ", ary.GetValue(i, j, k)); } Console.WriteLine(); } Console.WriteLine(); } } }`

  The output is

  `The elements of the array are: 321 322 323 331 332 333 421 422 423 431 432 433 521 522 523 531 532 533 621 622 623 631 632 633` 1 ExtendedArray 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Array `` `` `` `` The of the elements contained in the new instance. A that contains the number of elements contained in the first dimension of the new instance. A that contains the number of elements contained in the second dimension of the new instance. A that contains the number of elements contained in the third dimension of the new instance.

  Creates a zero-based, three-dimensional array of the specified and dimension lengths.

  A new zero-based, three-dimensional instance of objects with the size for the first dimension, for the second, and for the third.

  Reference-type elements will be set to . Value-type elements will be set to zero, except for elements, which will be set to .

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

  is . is not a valid .

  < 0.

  -or-

  < 0.

  -or-

  < 0.

  The following example shows how to create and initialize a three-dimensional .

  `using System; public class Create3DArrayExample { public static void Main() { int i, j, k; Array ary = Array.CreateInstance( typeof(int), 2, 4, 3 ); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ ) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ ) { for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ ) { ary.SetValue( (100*i + 10*j + k), i, j, k ); } } } Console.WriteLine("The elements of the array are:"); for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++) { for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++) { for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ ) { Console.Write("{0, 3} ", ary.GetValue(i, j, k)); } Console.WriteLine(); } Console.WriteLine(); } } }`

  The output is

  `The elements of the array are: 0 1 2 10 11 12 20 21 22 30 31 32 100 101 102 110 111 112 120 121 122 130 131 132` 1 ExtendedArray 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Boolean `` `` To be added. The array to search.

  The predicate that defines the conditions of the elements to search for.

  Determines whether the specified array contains any element that matches the conditions defined by the specified predicate.

  , if the array contains one or more elements that match the conditions defined by the specified predicate; otherwise, .

  The predicate returns if the object passed to it matches the delegate. Each element of is passed to the predicate in turn, and processing is stopped when the predicate returns .

  or is . 2.0.0.0 4.0.0.0
- Method
  T `` `` To be added. The array to search.

  The predicate that defines the conditions of the element to search for.

  Searches for an element that matches the predicate, and returns the first occurrence within the entire array.

  The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type .

  The elements of are individually passed to the predicate, moving forward in the array, starting with the first element and ending with the last element. Processing is stopped when the predicate returns .

  or is . 2.0.0.0 4.0.0.0
- Method
  T[] `` `` To be added. The array to search.

  The predicate that specifies the elements to search for.

  Retrieves all the elements that match the conditions defined by the specified predicate.

  An array containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty array.

  The elements of are individually passed to the predicate, and those elements for which the predicate returns , are saved in the returned array.

  or is . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` To be added. The array to search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the zero-based index of the first occurrence within the entire array.

  The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1.

  The elements of are individually passed to the predicate. The array is searched forward starting at the first element and ending at the last element. Processing is stopped when the predicate returns .

  or is . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` `` To be added. The array to search.

  The zero-based starting index of the search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the zero-based index of the first occurrence within the range of elements in the array that extends from the specified index to the last element.

  The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1.

  The elements of are individually passed to the predicate. The array is searched forward starting at the specified index and ending at the last element. Processing is stopped when the predicate returns .

  or is . is less than zero or greater than . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` `` `` To be added. The array to search.

  The zero-based starting index of the search

  The number of consecutive elements to search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the zero-based index of the first occurrence within the range of elements in the array that starts at the specified index and contains the specified number of elements.

  The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1.

  The elements of are individually passed to the predicate. The array is searched forward starting at the specified index and going for elements. Processing is stopped when the predicate returns .

  or is .

  is less than zero.

  -or-

  is less than zero.

  -or-

  + is greater than .

  2.0.0.0
  4.0.0.0
- Method
  T `` `` To be added. The array to search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the last occurrence within the entire array.

  The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type .

  The elements of are individually passed to the predicate, moving backward in the array, starting with the last element and ending with the first element. Processing is stopped when a match is found.

  or is . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` To be added. The array to search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the zero-based index of the last occurrence within the entire array.

  The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1.

  The elements of are individually passed to the predicate. The array is searched backwards starting at the last element and ending at the first element. Processing is stopped when the predicate returns .

  or is . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` `` To be added. The array to search.

  The zero-based starting index of the backward search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the zero-based index of the last occurrence within the range of elements in the array that extends from the specified index to the last element.

  The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1.

  The elements of are individually passed to the predicate. The array is searched backward starting at the specified index and ending at the first element. Processing is stopped when the predicate returns .

  or is . is less than zero or greater than . 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` `` `` To be added. The array to search.

  The zero-based starting index of the backward search.

  The number of consecutive elements to search.

  The predicate that specifies the elements to search for.

  Searches for an element that matches the predicate, and returns the zero-based index of the last occurrence within the range of elements in the array that ends at the specified index and contains the specified number of elements.

  The zero-based index of the first occurrence of an element that matches the conditions defined by , if found; otherwise, -1.

  The elements of are individually passed to the predicate. The array is searched backward starting at the specified index and going for elements. Processing is stopped when the predicate returns .

  or is .

  is less than zero or greater than .

  -or-

  is less than zero.

  -or-

  is greater than + 1.

  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` To be added. The array on whose elements the action is to be performed.

  The action to perform on each element of .

  Performs the specified action on each element of the specified array.

  The elements of are individually passed to the action. The elements of the current array are individually passed to the action delegate, sequentially, in index order, and on the same thread as that used to call . Execution stops if the action throws an exception.

  or is . 2.0.0.0 4.0.0.0
- Method
  System.Collections.IEnumerator

  Returns a for the current instance.

  A for the current instance.

  A grants read-access to the elements of a .

  This method is implemented to support the interface. For more information regarding the use of an enumerator, see .

  Enumerators can be used to read the data in the collection, but they cannot be used to modify the underlying collection.

  Initially, the enumerator is positioned before the first element of the current instance. returns the enumerator to this position. Therefore, after an enumerator is created or after a , is required to be called to advance the enumerator to the first element of the collection before reading the value of .

  returns the same object until either or is called. sets to the next element.

  If passes the end of the collection, the enumerator is positioned after the last element in the collection and returns false. When the enumerator is at this position, subsequent calls to also return . If the last call to returned , is unspecified. To set to the first element of the collection again, you can call followed by .

  An enumerator remains valid as long as the collection remains unchanged. If changes are made to the collection, such as adding, modifying, or deleting elements, the enumerator is irrecoverably invalidated and its behavior is undefined.

  The enumerator does not have exclusive access to the collection; therefore, enumerating through a collection is intrinsically not a thread safe procedure. To guarantee thread safety during enumeration, you can lock the collection during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

  Multidimensional arrays will be processed in Row-major form.

  For some multidimensional objects, it can be desirable for an enumerator to process them in Column-major form.

  Override this method to provide read-access to the current instance.

  Use this method to iterate over the elements of the current instance.

  This example demonstrates the method.

  `using System; using System.Collections; public class ArrayGetEnumerator { public static void Main() { string[,] strAry = {{"1","one"}, {"2", "two"}, {"3", "three"}}; Console.Write( "The elements of the array are: " ); IEnumerator sEnum = strAry.GetEnumerator(); while ( sEnum.MoveNext() ) Console.Write( " {0}", sEnum.Current ); } }`

  The output is

  The elements of the array are: 1 one 2 two 3 three

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Int32 `` The zero-based dimension of the array whose length is to be determined.

  Gets the number of elements in the specified dimension of the array.

  The number of elements in the specified dimension of the array.

  To be added.

  is less than zero.

  -or-

  is equal to or greater than .

  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Int64 `` To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Int32 `` A that contains the zero-based dimension of the current instance whose lower bound is to be determined.

  Returns the lower bound of the specified dimension in the current instance.

  A that contains the lower bound of the specified dimension in the current instance.

  For example, (0) returns the lower bound of the first dimension of the current instance, and ( - 1) returns the lower bound of the last dimension of the current instance.

  < 0.

  -or-

  is equal to or greater than the property of the current instance.

  1
  RuntimeInfrastructure
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
- Method
  System.Int32 `` A that contains the zero-based dimension of the current instance whose upper bound is to be determined.

  Returns the upper bound of the specified dimension in the current instance.

  A that contains the upper bound of the specified dimension in the current instance.

  For example, (0) returns the upper bound of the first dimension of the current instance, and ( - 1) returns the upper bound of the last dimension of the current instance.

  < 0.

  -or-

  is equal to or greater than the property of the current instance.

  1
  RuntimeInfrastructure
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
- Method
  System.Object `` A that contains the position of the value to get from the current instance.

  Gets the value at the specified position in the current one-dimensional instance.

  A that contains the value at the specified position in the current instance.

  Use the and methods to determine whether is out of bounds.

  The current instance has more than one dimension.

  is outside the range of valid indices for the current instance.

  This example demonstrates the method.

  `using System; public class ArrayGetValueExample { public static void Main() { String[] strAry = { "one", "two", "three", "four", "five" }; Console.Write( "The elements of the array are: " ); for( int i = 0; i < strAry.Length; i++ ) Console.Write( " '{0}' ", strAry.GetValue( i ) ); } }`

  The output is

  The elements of the array are: 'one' 'two' 'three' 'four' 'five'

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Object `System.ParamArray` A one-dimensional array of objects that contains the indices that specify the position of the element in the current instance whose value to get.

  Gets the value at the specified position in the current multidimensional instance.

  A that contains the value at the specified position in the current instance.

  The number of elements in is required to be equal to the number of dimensions in the current instance. All elements in collectively specify the position of the desired element in the current instance.

  Use the and methods to determine whether any of the values in are out of bounds.

  is . The number of dimensions in the current instance is not equal to the number of elements in .

  At least one element in is outside the range of valid indices for the corresponding dimension of the current instance.

  1
  ExtendedArray
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Object `` To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Object `System.ParamArray` To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Object `` `` A that contains the first-dimension index of the element in the current instance to get. A that contains the second-dimension index of the element in the current instance to get.

  Gets the value at the specified position in the current two-dimensional instance.

  A that contains the value at the specified position in the current instance.

  Use the and methods to determine whether any of the indices are out of bounds.

  The current instance does not have exactly two dimensions. At least one of or is outside the range of valid indexes for the corresponding dimension of the current instance. 1 ExtendedArray 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Object `` `` To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Object `` `` `` A that contains the first-dimension index of the element in the current instance to get. A that contains the second-dimension index of the element in the current instance to get. A that contains the third-dimension index of the element in the current instance to get.

  Gets the value at the specified position in the current three-dimensional instance.

  A that contains the value at the specified position in the current instance.

  Use the and methods to determine whether any of the indices are out of bounds.

  The current instance does not have exactly three dimensions.

  At least one of or or is outside the range of valid indexes for the corresponding dimension of the current instance.

  1
  ExtendedArray
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Object `` `` `` To be added. To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Int32 `` `` A one-dimensional to search. A to locate in .

  Searches the specified one-dimensional , returning the index of the first occurrence of the specified .

  A containing the index of the first occurrence of in , if found; otherwise, .GetLowerBound(0) - 1. For a vector, if is not found, the return value will be -1. This provides the caller with a standard code for a failed search.

  This version of is equivalent to (, , .GetLowerBound(0),.Length).

  The elements are compared using .

  is . has more than one dimension.

  The following example demonstrates the method.

  `using System; public class ArrayIndexOfExample { public static void Main() { int[] intAry = { 0, 1, 2, 0, 1 }; Console.Write( "The values of the array are: " ); foreach( int i in intAry ) Console.Write( "{0,5}", i ); Console.WriteLine(); int j = Array.IndexOf( intAry, 1 ); Console.WriteLine( "The first occurrence of 1 is at index {0}", j ); } }`

  The output is

  The values of the array are: 0 1 2 0 1

  The first occurrence of 1 is at index 1

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` A one-dimensional to search. A to locate in . A that contains the index at which searching starts.

  Searches the specified one-dimensional , returning the index of the first occurrence of the specified between the specified index and the last element.

  A containing the index of the first occurrence of in , within the range through the last element of , if found; otherwise, .GetLowerBound(0) - 1. For a vector, if is not found, the return value will be -1. This provides the caller with a standard code for the failed search.

  This version of is equivalent to (, , , (.Length - +.GetLowerBound(0))).

  The elements are compared using .

  is .

  is less than or greater than + .

  has more than one dimension. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` `` A one-dimensional to search. A to locate in . A that contains the index at which searching starts. A that contains the number of elements to search, beginning with .

  Searches the specified one-dimensional , returning the index of the first occurrence of the specified in the specified range.

  A containing the index of the first occurrence of in , within the range through + - 1, if found; otherwise, .GetLowerBound(0) - 1. For a vector, if is not found, the return value will be -1. This provides the caller with a standard code for the failed search.

  The elements are compared using .

  is .

  is less than .

  -or-

  is less than zero.

  -or-

  + is greater than + .

  has more than one dimension. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` To be added. The array to search. The value to locate.

  Searches the specified array, returning the index of the first occurrence of the specified value.

  The zero-based index of the first occurrence of in , if found; otherwise, - 1.

  The elements are compared using . The array is searched forward starting at the first element and ending at the last element. Processing is stopped when the predicate returns .

  is .

  2.0.0.0
  4.0.0.0
- Method
  System.Int32 `` `` `` To be added. The array to search. The value to locate. The zero-based starting index of the search.

  Searches the specified array, returning the index of the first occurrence in the specified array starting at the specified index and including the last element.

  The zero-based index of the first occurrence of within the range of elements in that extends from to the last element, if found; otherwise, -1. If is equal to the length of the array, -1 is returned.

  The elements are compared using . The array is searched forward starting at and ending at the last element. Processing is stopped when the predicate returns .

  is .

  is less than zero or greater than .

  2.0.0.0
  4.0.0.0
- Method
  System.Int32 `` `` `` `` To be added. The array to search. The value to locate. The zero-based starting index of the search. The number of consecutive elements to search.

  Searches for the specified value and returns the index of the first occurrence within the range of elements in the array starting at the specified index and continuing for, at most, the specified number of elements.

  The zero-based index of the first occurrence of within the range of elements in that starts at and contains the number of elements specified in , if found; otherwise, -1.

  The elements are compared using . The array is searched forward starting at and ending at + - 1. Processing is stopped when the predicate returns .

  is .

  is less than zero.

  -or-

  is less than zero.

  -or-

  + is greater than .

  2.0.0.0
  4.0.0.0
- Method
  System.Void

  Initializes every element of the current instance of value-type objects by calling the default constructor of that value type.

  This method cannot be used on reference-type arrays.

  If the current instance is not a value-type or if the value type does not have a default constructor, the current instance is not modified.

  The current instance can have any lower bound and any number of dimensions.

  This method can be used only on value types that have constructors.

  1
  RuntimeInfrastructure
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Property
  System.Boolean Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 0 1.0.5000.0 2.0.0.0 4.0.0.0
- Property
  System.Boolean Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 0 1.0.5000.0 2.0.0.0 4.0.0.0
- Property
  System.Boolean Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 0 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` `` A one-dimensional to search. A to locate in .

  Searches the specified one-dimensional , returning the index of the last occurrence of the specified .

  A containing the index of the last occurrence in of , if found; otherwise, .GetLowerBound(0) - 1. For a vector, if is not found, the return value will be -1. This provides the caller with a standard code for the failed search.

  This version of is equivalent to (, , (.GetLowerBound(0) + .Length - 1), .Length).

  The elements are compared using .

  is . has more than one dimension.

  The following example demonstrates the method.

  `using System; public class ArrayLastIndexOfExample { public static void Main() { int[] intAry = { 0, 1, 2, 0, 1 }; Console.Write( "The values of the array are: "); foreach( int i in intAry ) Console.Write( "{0,5}", i ); Console.WriteLine(); int j = Array.LastIndexOf( intAry, 1 ); Console.WriteLine( "The last occurrence of 1 is at index {0}", j ); } }`

  The output is

  The values of the array are: 0 1 2 0 1

  The last occurrence of 1 is at index 4

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` A one-dimensional to search. A to locate in . A that contains the index at which searching starts.

  Searches the specified one-dimensional , returning the index of the last occurrence of the specified between the specified index and the first element.

  A containing the index of the last occurrence of in the range through the lower bound of , if found; otherwise, .GetLowerBound(0) - 1. For a vector, if is not found, the return value will be -1. This provides the caller with a standard code for the failed search.

  This version of is equivalent to ( , , ,+ 1 -.GetLowerBound(0)).

  The elements are compared using .

  is .

  is outside the range of valid indices for .

  has more than one dimension. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` `` `` A one-dimensional to search. A to locate in . A that contains the index at which searching starts. A that contains the number of elements to search, beginning with .

  Searches the specified one-dimensional , returning the index of the last occurrence of the specified in the specified range.

  A containing the index of the last occurrence of in , within the range through - + 1, if found; otherwise, .GetLowerBound(0) - 1. For a vector, if is not found, the return value will be -1. This provides the caller with a standard code for the failed search.

  The elements are compared using .

  is .

  is outside the range of valid indices for .

  -or-

  < 0.

  -or-

  is greater than + 1.

  has more than one dimension. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Int32 `` `` To be added. The array to search. The value to locate.

  Searches the specified array, returning the index of the last occurrence of the specified value.

  The zero-based index of the last occurrence of in , if found; otherwise, - 1.

  The elements are compared using . The array is searched backward starting at the last element and ending at the first element. Processing is stopped when the predicate returns .

  is .

  2.0.0.0
  4.0.0.0
- Method
  System.Int32 `` `` `` To be added. The array to search. The value to locate. The zero-based starting index of the search.

  Searches the specified array backwards, returning the index of the last occurrence of the specified array, starting at the specified index.

  The zero-based index of the last occurrence of within the range of elements in that extends from to the first element, if found; otherwise, -1.

  The elements are compared using . The array is searched backward starting at and ending at the first element. Processing is stopped when the predicate returns .

  is .

  is outside the range of valid indices for .

  2.0.0.0
  4.0.0.0
- Method
  System.Int32 `` `` `` `` To be added. The array to search. The value to locate. The zero-based starting index of the search. The number of consecutive elements to search.

  Searches for the specified value and returns the index of the last occurrence within the range of elements in the array starting at the specified index and continuing backwards for, at most, the specified number of elements.

  The zero-based index of the last occurrence of within the range of elements in that ends at and contains the number of elements specified in , if found; otherwise, -1.

  The elements are compared using . The array is searched backward starting at and going for count elements. Processing is stopped when the predicate returns .

  is .

  is outside the range of valid indices for .

  -or-

  is less than zero.

  -or-

  is greater than + 1.

  2.0.0.0
  4.0.0.0
- Property
  System.Int32

  Gets the total number of elements in all the dimensions of the current instance.

  A that contains the total number of elements in all the dimensions of the current instance.

  This property is read-only.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  get: System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
- Property
  System.Int64

  Gets the total number of elements in all the dimensions of the current instance.

  A value containing the length of the array.

  This property is read-only.

  0
  System.Runtime.InteropServices.ComVisible(false)
  get: System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Property
  System.Int32

  Gets the rank (number of dimensions) of the current instance.

  A that contains the rank (number of dimensions) of the current instance.

  This property is read-only.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  get: System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.Success)
- Method
  System.Void `` `` To be added. To be added. To be added. To be added. To be added. 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` The one-dimensional to reverse.

  Reverses the sequence of the elements in the specified one-dimensional .

  This version of is equivalent to (, .GetLowerBound(0), .Length).

  is . has more than one dimension. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` The one-dimensional to reverse. A that contains the index at which reversing starts. A that contains the number of elements to reverse.

  Reverses the sequence of the elements in the specified range of the specified one-dimensional .

  To be added. is . is multidimensional.

  < .GetLowerBound(0).

  < 0.

  and do not specify a valid range in (i.e. + > .GetLowerBound(0) + .Length).

  The following example demonstrates the method.

  `using System; public class ArrayReverseExample { public static void Main() { string[] strAry = { "one", "two", "three" }; Console.Write( "The elements of the array are:"); foreach( string str in strAry ) Console.Write( " {0}", str ); Array.Reverse( strAry ); Console.WriteLine(); Console.WriteLine( "After reversing the array," ); Console.Write( "the elements of the array are:"); foreach( string str in strAry ) Console.Write( " {0}", str ); } }`

  The output is

  The elements of the array are: one two three

  After reversing the array,

  the elements of the array are: three two one

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` A that contains the new value for the specified element. A that contains the index of the element whose value is to be set.

  Sets the value of the element at the specified position in the current one-dimensional instance.

  Use the and methods to determine whether is out of bounds.

  For more information regarding valid conversions that will be performed by this method, see .

  The current instance has more than one dimension.

  is outside the range of valid indices for the current instance.

  is not assignment-compatible with the element type of the current instance.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `System.ParamArray` A that contains the new value for the specified element. A one-dimensional array of objects that contains the indices that specify the position of the element in the current instance to set.

  Sets the value of the element at the specified position in the current multidimensional instance.

  The number of elements in is required to be equal to the number of dimensions in the current instance. All elements in collectively specify the position of the desired element in the current instance.

  For more information regarding valid conversions that will be performed by this method, see .

  Use the and methods to determine whether any of the values in is out of bounds.

  is .

  The number of dimensions in the current instance is not equal to the number of elements in .

  At least one element in is outside the range of valid indices for the corresponding dimension of the current instance.

  is not assignment-compatible with the element type of the current instance.

  1
  ExtendedArray
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Void `` `System.ParamArray` To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Void `` `` `` A that contains the new value for the specified element. A that contains the first-dimension index of the element in the current instance to set. A that contains the second-dimension index of the element in the current instance to set.

  Sets the value of the element at the specified position in the current two-dimensional instance.

  For more information regarding valid conversions that will be performed by this method, see .

  Use the and methods to determine whether any of the indices are out of bounds.

  The current instance does not have exactly two dimensions.

  At least one of or is outside the range of valid indices for the corresponding dimension of the current instance.

  is not assignment-compatible with the element type of the current instance.

  1
  ExtendedArray
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` `` To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Void `` `` `` `` A that contains the new value for the specified element. A that contains the first-dimension index of the element in the current instance to set. A that contains the second-dimension index of the element in the current instance to set. A that contains the third-dimension index of the element in the current instance to set.

  Sets the value of the element at the specified position in the current three-dimensional instance.

  For more information regarding valid conversions that will be performed by this method, see .

  Use the and methods to determine whether any of the indices are out of bounds.

  The current instance does not have exactly three dimensions.

  At least one of , , or is outside the range of valid indices for the corresponding dimension of the current instance.

  is not assignment-compatible with the element type of the current instance.

  1
  ExtendedArray
  1.0.5000.0
  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` `` `` To be added. To be added. To be added. To be added. To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.InteropServices.ComVisible(false)
- Method
  System.Void `` A one-dimensional to sort.

  Sorts the elements of the specified one-dimensional .

  This version of is equivalent to (, , .GetLowerBound(0), .Length, ).

  Each element of is required to implement the interface to be capable of comparisons with every other element in array.

  is . has more than one dimension. One or more elements in do not implement the interface.

  This example demonstrates the method.

  `using System; public class ArraySortExample { public static void Main() { string[] strAry = { "All's", "well", "that", "ends", "well" }; Console.Write( "The original string array is: " ); foreach ( String str in strAry ) Console.Write( str + " " ); Console.WriteLine(); Array.Sort( strAry ); Console.Write( "The sorted string array is: " ); foreach ( string str in strAry ) Console.Write( str + " " ); } }`

  The output is

  The original string array is: All's well that ends well

  The sorted string array is: All's ends that well well

  One or more elements in that are used in a comparison do not implement the interface. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` A one-dimensional that contains the keys to sort.

  A one-dimensional that contains the items that correspond to each of element of . Specify a null reference to sort only .

  Sorts the specified pair of one-dimensional objects (one containing a set of keys and the other containing corresponding items) based on the keys in the first specified .

  This version of is equivalent to (, , .GetLowerBound(0), .Length, ).

  Each key in is required to have a corresponding item in . The sort is performed according to the order of . After a key is repositioned during the sort, the corresponding item in is similarly repositioned. Only .Length elements of are sorted. Therefore, is sorted according to the arrangement of the corresponding keys in . If the sort is not successfully completed, the results are unspecified.

  Each element of is required to implement the interface to be capable of comparisons with every other element in .

  is .

  has more than one dimension.

  -or-

  is not a null reference and has more than one dimension.

  is not a null reference, and .GetLowerBound(0) does not equal .GetLowerBound(0).

  -or-

  is not a null reference, and .Length > .Length.

  This example demonstrates the method.

  `using System; public class ArraySortExample { public static void Main() { string[] strAry = { "All's", "well", "that", "ends", "well" }; int[] intAry = { 3, 4, 0, 1, 2 }; Console.Write( "The original string array is: " ); foreach ( string str in strAry ) Console.Write( str + " " ); Console.WriteLine(); Console.Write( "The key array is: " ); foreach ( int i in intAry ) Console.Write( i + " " ); Console.WriteLine(); Array.Sort( intAry, strAry ); Console.Write( "The sorted string array is: " ); foreach ( string str in strAry ) Console.Write( str + " " ); } }`

  The output is

  The original string array is: All's well that ends well

  The key array is: 3 4 0 1 2

  The sorted string array is: that ends well All's well

  One or more elements in that are used in a comparison do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` The one-dimensional to sort.

  The implementation to use when comparing elements. Specify a null reference to use the implementation of each element.

  Sorts the elements in the specified one-dimensional using the specified implementation.

  This version of is equivalent to (, , .GetLowerBound(0), .Length, ).

  If is a null reference, each element of is required to implement the interface to be capable of comparisons with every other element in . If the sort is not successfully completed, the results are unspecified.

  is . has more than one dimension. is a null reference, and one or more elements in do not implement the interface. is a null reference, and one or more elements in that are used in a comparison do not implement the interface. 0 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` A one-dimensional that contains the keys to sort.

  A one-dimensional that contains the items that correspond to each element in . Specify a null reference to sort only .

  The implementation to use when comparing elements. Specify a null reference to use the implementation of each element.

  Sorts the specified pair of one-dimensional objects (one containing a set of keys and the other containing corresponding items) based on the keys in the first specified using the specified implementation.

  This version of is equivalent to (, , .GetLowerBound(0), .Length, ).

  Each key in is required to have a corresponding item in . The sort is performed according to the order of . After a key is repositioned during the sort, the corresponding item in is similarly repositioned. Only .Length elements of are sorted. Therefore, is sorted according to the arrangement of the corresponding keys in . If the sort is not successfully completed, the results are unspecified.

  If is a null reference, each element of is required to implement the interface to be capable of comparisons with every other element in .

  is .

  has more than one dimension.

  -or-

  is not a null reference and has more than one dimension.

  is not a null reference, and .GetLowerBound(0) does not equal .GetLowerBound(0).

  -or-

  is not a null reference, and .Length > .Length.

  is a , and one or more elements in that are used in a comparison do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` A one-dimensional to sort. A that contains the index at which sorting starts. A that contains the number of elements to sort.

  Sorts the elements in the specified range of the specified one-dimensional .

  This version of is equivalent to (, , , , ).

  Each element of is required to implement the interface to be capable of comparisons with every other element in . If the sort is not successfully completed, the results are unspecified.

  is . has more than one dimension.

  < .GetLowerBound(0).

  -or-

  < 0.

  and do not specify a valid range in .

  One or more elements in that are used in a comparison do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` A one-dimensional that contains the keys to sort. A one-dimensional that contains the items that correspond to each element in . Specify a null reference to sort only . A that contains the index at which sort begins. A that contains the number of elements to sort.

  Sorts the specified ranges of the specified pair of one-dimensional objects (one containing a set of keys and the other containing corresponding items) based on the keys in the first specified .

  This version of is equivalent to (, , , , ).

  Each key in is required to have a corresponding item in . The sort is performed according to the order of . After a key is repositioned during the sort, the corresponding item in is similarly repositioned. Therefore, is sorted according to the arrangement of the corresponding keys in . If the sort is not successfully completed, the results are undefined.

  Each element of is required to implement the interface to be capable of comparisons with every other element in .

  is .

  has more than one dimension.

  -or-

  is not a null reference and has more than one dimension.

  < .GetLowerBound(0).

  -or-

  < 0.

  is not a null reference, and .GetLowerBound(0) does not equal .GetLowerBound(0).

  -or-

  and do not specify a valid range in .

  -or-

  is not a null reference, and and do not specify a valid range in .

  One or more elements in that are used in a comparison do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` A one-dimensional to sort. A that contains the index at which sorting starts. A that contains the number of elements to sort.

  The implementation to use when comparing elements. Specify a null reference to use the implementation of each element.

  Sorts the elements in the specified section of the specified one-dimensional using the specified implementation.

  This version of is equivalent to (, , , , ).

  If is a null reference, each element of is required to implement the interface to be capable of comparisons with every other element in . If the sort is not successfully completed, the results are unspecified.

  is . has more than one dimension.

  < .GetLowerBound(0).

  -or-

  < 0.

  and do not specify a valid range in .

  is , and one or more elements in that are used in a comparison do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` `` A one-dimensional that contains the keys to sort.

  A one-dimensional that contains the items that correspond to each element of . Specify a null reference to sort only .

  A that contains the index at which sorting starts. A that contains the number of elements to sort.

  The implementation to use when comparing elements. Specify a null reference to use the implementation of each element.

  Sorts the specified range of the specified pair of one-dimensional objects (one containing a set of keys and the other containing corresponding items) based on the keys in the first specified using the specified implementation.

  Each key in is required to have a corresponding item in . The sort is performed according to the order of . After a key is repositioned during the sort, the corresponding item in is similarly repositioned. Only .Length elements of will be sorted. Therefore, is sorted according to the arrangement of the corresponding keys in . If the sort is not successfully completed, the results are undefined.

  If is a null reference, each element of is required to implement the interface to be capable of comparisons with every other element in .

  is .

  has more than one dimension.

  -or-

  is not a null reference and has more than one dimension.

  < .GetLowerBound(0).

  -or-

  < 0.

  is not a null reference, and .GetLowerBound(0) does not equal .GetLowerBound(0).

  -or-

  and do not specify a valid range in .

  -or-

  is not a null reference, and and do not specify a valid range in .

  is , and one or more elements in that are used in a comparison do not implement the interface.

  0
  1.0.5000.0
  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` To be added.

  The array to sort.

  Sorts the elements in an entire array using the or implementation of each element of that array.

  Each element of is required to implement the or interface to be capable of comparisons with every other element in .

  If the sort is not successfully completed, the results are undefined.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  is .

  One or more elements in that are used in a comparison are the null reference or do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` To be added.

  The array to sort.

  The implementation to use when comparing elements.

  -or-

  to use the or implementation of each element.

  Sorts the elements in an array using the specified comparer.

  If is null, each element of must implement the or interface to be capable of comparisons with every other element in .

  If the sort is not successfully completed, the results are undefined.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  is .

  is , and one or more elements in that are used in a comparison do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` To be added.

  The array to sort.

  The to use when comparing elements.

  Sorts the elements in an array using the specified comparison.

  If the sort is not successfully completed, the results are undefined.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  is .

  -or-

  is .

  2.0.0.0
  4.0.0.0
- Method
  System.Void `` `` `` To be added.

  The array to sort.

  The starting index of the range to sort. The number of elements in the range to sort.

  Sorts an array using the or implementation of each element of that array.

  Each element within the specified range of elements in must implement the or interface to be capable of comparisons with every other element in .

  If the sort is not successfully completed, the results are undefined.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  and do not specify a valid range in .

  is .

  is less than zero.

  -or-

  is less than zero.

  One or more elements in that are used in a comparison do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` To be added.

  The array to sort.

  The starting index of the range to sort. The number of elements in the range to sort.

  The implementation to use when comparing elements.

  -or-

  to use the or implementation of each element.

  Sorts the elements in a range of elements in an array using the specified comparer.

  If is null, each element within the specified range of elements in must implement the interface to be capable of comparisons with every other element in .

  If the sort is not successfully completed, the results are undefined.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  is .

  is less than zero.

  -or-

  is less than zero.

  and do not specify a valid range in .

  is , and one or more elements in that are used in a comparison do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` To be added. To be added.

  The array that contains the keys to sort.

  The array that contains the items that correspond to each of the keys in .

  -or-

  to sort only the array.

  Sorts a pair of arrays based on the keys in the first array using the implementation of each key.

  If is non-null, each key in is required to have a corresponding item in . When a key is repositioned during the sorting, the corresponding item in is similarly repositioned. Therefore, is sorted according to the arrangement of the corresponding keys in .

  Each key in must implement the or interface to be capable of comparisons with every other key.

  If the sort is not successfully completed, the results are undefined.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  is not , and the length of does not equal the length of .

  is .

  One or more elements in that are used in a comparison are the null reference or do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` To be added. To be added.

  The array that contains the keys to sort.

  The array that contains the items that correspond to each of the keys in .

  -or-

  to sort only the array.

  The implementation to use when comparing elements.

  -or-

  to use the or implementation of each element.

  Sorts a pair of arrays based on the keys in the first array, using the specified .

  This version of is equivalent to .

  If is non-null, each key in is required to have a corresponding item in . The sort is performed according to the order of . After a key is repositioned during the sort, the corresponding item in is similarly repositioned. Only .Length elements of will be sorted. Therefore, is sorted according to the arrangement of the corresponding keys in . If the sort is not successfully completed, the results are unspecified.

  If is a null reference, each element of is required to implement the or interface to be capable of comparisons with every other element in .

  is .

  is not , and the length of does not match the length of .

  is , and one or more elements in that are used in a comparison do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` To be added. To be added.

  The array that contains the keys to sort.

  The array that contains the items that correspond to each of the keys in .

  -or-

  to sort only the array.

  The starting index of the range to sort. The number of elements in the range to sort.

  Sorts a range of elements in a pair of arrays based on the keys in the first array, using the or implementation of each key.

  If is non-null, each key in is required to have a corresponding item in . When a key is repositioned during the sorting, the corresponding item in is similarly repositioned. Therefore, is sorted according to the arrangement of the corresponding keys in .

  If the sort is not successfully completed, the results are unspecified.

  Each key within the specified range of elements in must implement the or interface to be capable of comparisons with every other key.

  This implementation performs an unstable sort; that is, if two elements are equal, their order might not be preserved. In contrast, a stable sort preserves the order of elements that are equal.

  and do not specify a valid range in .

  -or-

  is not , and and do not specify a valid range in .

  is .

  is less than zero.

  -or-

  is less than zero.

  One or more elements in that are used in a comparison are the null reference or do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` `` `` `` To be added. To be added.

  The array that contains the keys to sort.

  The array that contains the items that correspond to each of the keys in .

  -or-

  to sort only the array.

  The starting index of the range to sort. The number of elements in the range to sort.

  The implementation to use when comparing elements.

  -or-

  to use the or implementation of each element.

  Sorts a range of elements in a pair of arrays based on the keys in the first array using the specified .

  If is non-null, each key in is required to have a corresponding item in . The sort is performed according to the order of . After a key is repositioned during the sort, the corresponding item in is similarly repositioned. Only .Length elements of will be sorted. Therefore, is sorted according to the arrangement of the corresponding keys in . If the sort is not successfully completed, the results are undefined.

  If is a null reference, each element of is required to implement the or interface to be capable of comparisons with every other element in .

  and do not specify a valid range in .

  -or-

  is not , and and do not specify a valid range in .

  is .

  is less than zero.

  -or-

  is less than zero.

  is , and one or more elements in that are used in a comparison do not implement the or interface.

  2.0.0.0
  4.0.0.0
  System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.MayCorruptInstance, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Property
  System.Object Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 0 1.0.5000.0 2.0.0.0 4.0.0.0
- Property
  System.Int32 Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` To be added. Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Void Implemented to support the interface. [Note: For more information, see .] To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Boolean `` To be added. Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Int32 `` To be added. Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0 System.Runtime.ConstrainedExecution.ReliabilityContract(System.Runtime.ConstrainedExecution.Consistency.WillNotCorruptState, System.Runtime.ConstrainedExecution.Cer.MayFail)
- Method
  System.Void `` `` To be added. To be added. Implemented to support the interface. [Note: For more information, see .] To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Property
  System.Object `` To be added. Implemented to support the interface. [Note: For more information, see .] To be added. To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Void `` To be added. Implemented to support the interface. [Note: For more information, see .] To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  System.Void `` To be added. Implemented to support the interface. [Note: For more information, see .] To be added. 1.0.5000.0 2.0.0.0 4.0.0.0
- Method
  4.0.0.0
  System.Int32 `` `` To be added. To be added. To be added. To be added. To be added.
- Method
  4.0.0.0
  System.Boolean `` `` To be added. To be added. To be added. To be added. To be added.
- Method
  4.0.0.0
  System.Int32 `` To be added. To be added. To be added. To be added.
- Method
  System.Boolean `` `` To be added. The array to check against the conditions.

  The predicate against which the elements are checked..

  Determines whether every element in the array matches the predicate.

  , if every element in matches the specified predicate; otherwise, .

  The predicate returns if the object passed to it matches the delegate. The elements of are individually passed to the predicate, and processing is stopped when the delegate returns for any element.

  or is . 2.0.0.0 4.0.0.0
0 System.Runtime.InteropServices.ComVisible(true)