1 <!-- ====================================================================== -->
\r
2 <!-- This XML is a description of the Common Language Infrastructure (CLI) library. -->
\r
3 <!-- This file is a normative part of Partition IV of the following standards: ISO/IEC 23271 and ECMA 335 -->
\r
4 <!-- ====================================================================== -->
\r
5 <!DOCTYPE Libraries SYSTEM "CLILibraryTypes.dtd">
\r
7 <Types Library="BCL">
\r
8 <Type Name="Action<T>" FullName="System.Action<T>" FullNameSP="System_Action<T>">
\r
9 <TypeSignature Language="ILAsm" Value=".class public sealed serializable Action`1<T> extends System.Delegate
\r
10 { .method public hidebysig newslot virtual instance void Invoke(!0 obj) }"/>
\r
11 <TypeSignature Language="C#" Value="public delegate void Action<T>(T obj);"/>
\r
12 <MemberOfLibrary>BCL</MemberOfLibrary>
\r
14 <AssemblyName>mscorlib</AssemblyName>
\r
15 <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ]</AssemblyPublicKey>
\r
16 <AssemblyVersion>2.0.x.x</AssemblyVersion>
\r
17 <AssemblyCulture>none</AssemblyCulture>
\r
20 <AttributeName>CLSCompliantAttribute(true)</AttributeName>
\r
21 <Excluded>0</Excluded>
\r
27 <para> Represents the method that performs an action on the specified object.</para>
\r
29 <param name="obj">The object on which to perform an action.</param>
\r
31 <block subset="none" type="note">
\r
32 <para>This delegate is used by the method <see cref="M:System.Array.ForEach"/>
\r
33 <see langword="(T[], Action<T>)"/>, and in <see cref="T:System.Collections.Generic.List<T>"/> to perform an action on each element of the collection.</para>
\r
38 <BaseTypeName>System.Delegate</BaseTypeName>
\r
42 <InterfaceName>System.ICloneable</InterfaceName>
\r
43 <Excluded>0</Excluded>
\r
47 <TypeExcluded>0</TypeExcluded>
\r
49 <Type Name="AsyncCallback" FullName="System.AsyncCallback" FullNameSP="System_AsyncCallback">
\r
50 <TypeSignature Language="ILAsm" Value=".class public sealed serializable AsyncCallback extends System.Delegate
\r
51 { .method public hidebysig newslot virtual instance void Invoke(IAsyncResult ar) }"/>
\r
52 <TypeSignature Language="C#" Value="public delegate void AsyncCallback(IAsyncResult ar);"/>
\r
53 <MemberOfLibrary>BCL</MemberOfLibrary>
\r
55 <AssemblyName>mscorlib</AssemblyName>
\r
56 <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ]</AssemblyPublicKey>
\r
57 <AssemblyVersion>2.0.x.x</AssemblyVersion>
\r
58 <AssemblyCulture>none</AssemblyCulture>
\r
61 <AttributeName>CLSCompliantAttribute(true)</AttributeName>
\r
62 <Excluded>0</Excluded>
\r
68 <para> References one or more methods called when an asynchronous operation completes.</para>
\r
70 <param name="ar">A <see cref="T:System.IAsyncResult"/> object containing information about the asynchronous operation that has completed.</param>
\r
73 <BaseTypeName>System.Delegate</BaseTypeName>
\r
77 <InterfaceName>System.ICloneable</InterfaceName>
\r
78 <Excluded>0</Excluded>
\r
82 <TypeExcluded>0</TypeExcluded>
\r
84 <Type Name="Environment" FullName="System.Environment" FullNameSP="System_Environment">
\r
85 <TypeSignature Language="ILAsm" Value=".class public sealed Environment extends System.Object"/>
\r
86 <TypeSignature Language="C#" Value="public sealed class Environment"/>
\r
87 <MemberOfLibrary>BCL</MemberOfLibrary>
\r
89 <AssemblyName>mscorlib</AssemblyName>
\r
90 <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ]</AssemblyPublicKey>
\r
91 <AssemblyVersion>2.0.x.x</AssemblyVersion>
\r
92 <AssemblyCulture>none</AssemblyCulture>
\r
95 <AttributeName>CLSCompliantAttribute(true)</AttributeName>
\r
96 <Excluded>0</Excluded>
\r
100 <ThreadingSafetyStatement>All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe.</ThreadingSafetyStatement>
\r
103 <para> Provides the current settings for, and information about, the execution environment.</para>
\r
106 <block subset="none" type="note">
\r
107 <para>Use this class to retrieve the following
\r
108 information:</para>
\r
109 <list type="bullet">
\r
111 <term>Command line arguments</term>
\r
114 <term>Exit codes</term>
\r
117 <term>Environment variable settings</term>
\r
120 <term>Contents of the call stack</term>
\r
123 <term>Time since last system boot</term>
\r
126 <term>Version of the execution engine</term>
\r
133 <BaseTypeName>System.Object</BaseTypeName>
\r
137 <Member MemberName="GetFolderPath">
\r
138 <MemberSignature Language="C#" Value="public static string GetCommandLineArgs(Environment.SpecialFolder folder);"/>
\r
139 <MemberType>Method</MemberType>
\r
141 <ReturnType>System.String</ReturnType>
\r
144 <Parameter Name="folder" Type="System.Environment+SpecialFolder" />
\r
148 <para> Returns the arguments specified on the command
\r
151 <param name="folder">
\r
152 <para>A <see cref="T:System.Environment+SpecialFolder" />.</para>
\r
155 <para> Returns a <see cref="T:System.String"/> array. Each <see cref="T:System.String"/> in the array
\r
156 contains a single command line argument.</para>
\r
159 <para>The first element in the array contains the filename of
\r
160 the executing program. If the filename is not available, the first element is
\r
161 equal to <see cref="F:System.String.Empty"/>. The remaining elements contain any additional tokens
\r
162 entered on the command line.</para>
\r
163 <block subset="none" type="note">
\r
164 <para>The program filename can, but is not required to,
\r
165 include path information.</para>
\r
166 <para>To obtain the command line as a single <see cref="T:System.String"/>, use the <see cref="P:System.Environment.CommandLine"/>
\r
170 <exception cref="T:System.ArgumentException">foo</exception>
\r
171 <permission cref="T:System.SomePermission">bar</permission>
\r
172 <altmember cref="T:System.SomeMember">alt member</altmember>
\r
173 <seealso cref="T:System.SomeMember">another member</seealso>
\r
174 <unrecognized attribute="a-ko">should be appended to new docs</unrecognized>
\r
176 <Excluded>0</Excluded>
\r
179 <TypeExcluded>0</TypeExcluded>
\r
181 <Type Name="Array" FullName="System.Array" FullNameSP="System_Array">
\r
182 <TypeSignature Language="ILAsm" Value=".class public abstract serializable Array extends System.Object implements System.ICloneable, System.Collections.ICollection, System.Collections.IEnumerable, System.Collections.IList"/>
\r
183 <TypeSignature Language="C#" Value="public abstract class Array : ICloneable, ICollection, IEnumerable, IList"/>
\r
184 <MemberOfLibrary>BCL</MemberOfLibrary>
\r
186 <AssemblyName>mscorlib</AssemblyName>
\r
187 <AssemblyPublicKey>[00 00 00 00 00 00 00 00 04 00 00 00 00 00 00 00 ]</AssemblyPublicKey>
\r
188 <AssemblyVersion>2.0.x.x</AssemblyVersion>
\r
189 <AssemblyCulture>none</AssemblyCulture>
\r
192 <AttributeName>CLSCompliantAttribute(true)</AttributeName>
\r
193 <Excluded>0</Excluded>
\r
197 <ThreadingSafetyStatement>All public static members of this type are safe for multithreaded operations. No instance members are guaranteed to be thread safe.</ThreadingSafetyStatement>
\r
200 <para> Serves as the base class for arrays. Provides methods for creating,
\r
201 copying, manipulating, searching, and sorting arrays.</para>
\r
204 <para>This class is intended to be used as a base class by
\r
205 language implementations that support arrays. Only the system can derive from
\r
206 this type: derived classes of <see cref="T:System.Array"/> are not to be created by the developer.</para>
\r
207 <block subset="none" type="note">
\r
208 <para>An array is a collection of
\r
209 identically typed data <paramref name="elements"/> that are accessed and referenced by
\r
210 sets of integral <paramref name="indices"/>. </para>
\r
211 <para>The <paramref name="rank"/> of an array is the number
\r
212 of dimensions in the array. Each dimension has its own set of indices. An array
\r
213 with a rank greater than one can have a different lower
\r
214 bound and a different number of elements for each dimension. Multidimensional
\r
215 arrays (i.e. arrays with a rank greater than one) are processed in row-major
\r
217 <para>The <paramref name="lower bound"/> of a dimension
\r
218 is the starting index of that dimension. </para>
\r
219 <para>The <paramref name="length"/> of an array is the total number of elements contained in all of its
\r
220 dimensions. </para>
\r
221 <para>A <paramref name="vector"/> is a
\r
222 one-dimensional array with a <paramref name="lower bound"/> of '0'. </para>
\r
223 <para>If the implementer creates a derived class of <see cref="T:System.Array"/>, expected <see cref="T:System.Array"/> behavior
\r
224 cannot be guaranteed. For information on array-like objects with increased
\r
225 functionality, see the <see cref="T:System.Collections.IList"/> and <see cref="T:System.Collections.Generic.IList<T>"/> interfaces. For more information regarding the use of arrays versus the use
\r
226 of collections, see Partition V of the CLI Specification. </para>
\r
228 <para>Every specific <see cref="T:System.Array"/> type has three instance methods defined on it.
\r
229 While some programming languages allow direct access to these methods, they are
\r
230 primarily intended to be called by the output of compilers based on language
\r
231 syntax that deals with arrays. </para>
\r
232 <list type="bullet">
\r
236 <c>Get</c>: Takes as many <see cref="T:System.Int32"/> arguments as the array
\r
237 has dimensions and returns the value stored at the given index. It throws a
\r
238 <see cref="T:System.IndexOutOfRangeException"/>
\r
239 exception for invalid indices. </para>
\r
245 <c>Set</c>: Takes as many <see cref="T:System.Int32"/> arguments as the array
\r
246 has dimensions, plus one additional argument (the last argument) which has the
\r
247 same type as an array element. It stores the final value in the specified
\r
248 index of the array. It throws a <see cref="T:System.IndexOutOfRangeException"/>
\r
249 exception for invalid indices. </para>
\r
255 <c>Address</c>: Takes as many <see cref="T:System.Int32"/> arguments as the
\r
256 array has dimensions and returns the address of the element at the given index.
\r
257 It throws a <see cref="T:System.IndexOutOfRangeException"/>
\r
258 exception for invalid indices. </para>
\r
262 <para>In addition, every specific <see cref="T:System.Array"/> type has a constructor on it that takes as many non-negative
\r
263 <see cref="T:System.Int32"/>
\r
264 arguments as the array has dimensions. The arguments specify the
\r
265 number of elements in each dimension, and a lower bound of 0. Thus, a
\r
266 two-dimensional array of <see cref="T:System.Int32"/> objects would have a constructor that could be called with
\r
267 <c>(2, 4)</c> as its arguments to create an array of eight zeros with the first dimension indexed
\r
268 with 0 and 1 and the second dimension indexed with 0, 1, 2, and 3. </para>
\r
269 <para>For all specific array types except vectors (i.e. those
\r
270 permitted to have non-zero lower bounds and those with more than one dimension)
\r
271 there is an additional constructor. It takes twice as many arguments as the
\r
272 array has dimensions. The arguments are considered in pairs, with the first of
\r
273 the pair specifying the lower bound for that dimension and the second specifying
\r
274 the total number of elements in that dimension. Thus, a two-dimensional array
\r
275 of <see cref="T:System.Int32"/>
\r
277 objects would also have a constructor that could be called with <c>(-1, 2, 1, 3)</c> as its arguments,
\r
278 specifying an array of 6 zeros, with the first dimension indexed by -1 and 0,
\r
279 and the second dimension indexed by 1, 2, and 3. </para>
\r
280 <para>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].)</para>
\r
281 <para>Parallel implementation of methods taking a <see cref="T:System.Predicate"/> argument are not permitted.</para>
\r
285 <BaseTypeName>System.Object</BaseTypeName>
\r
289 <InterfaceName>System.ICloneable</InterfaceName>
\r
290 <Excluded>0</Excluded>
\r
293 <InterfaceName>System.Collections.ICollection</InterfaceName>
\r
294 <Excluded>0</Excluded>
\r
297 <InterfaceName>System.Collections.IEnumerable</InterfaceName>
\r
298 <Excluded>0</Excluded>
\r
301 <InterfaceName>System.Collections.IList</InterfaceName>
\r
302 <Excluded>0</Excluded>
\r
306 <Member MemberName=".ctor">
\r
307 <MemberSignature Language="ILAsm" Value="private rtspecialname specialname instance void .ctor()"/>
\r
308 <MemberSignature Language="C#" Value="private Array();"/>
\r
309 <MemberType>Constructor</MemberType>
\r
313 <summary>Constructs a new instance of the <see cref="T:System.Array"/> class.</summary>
\r
315 <Excluded>0</Excluded>
\r
317 <Member MemberName="AsReadOnly<T>">
\r
318 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class System.Collections.Generic.IList`1<!!0> AsReadOnly<T>(!!0[] array)"/>
\r
319 <MemberSignature Language="C#" Value="public static IList<T> AsReadOnly<T>(T[] array)"/>
\r
320 <MemberType>Method</MemberType>
\r
322 <ReturnType>System.Collections.Generic.IList<T></ReturnType>
\r
325 <Parameter Name="array" Type="T[]"/>
\r
329 <para>Returns a read-only <see cref="T: System.Collections.Generic.IList<T>"/> wrapper around the specified array.</para>
\r
331 <param name="array">The array to wrap in a read-only <see cref="T:System.Collections.Generic.IList<T>"/> wrapper.</param>
\r
333 <para>A read-only <see cref="T:System.Collections.Generic.IList<T>"/> wrapper around the specified array.</para>
\r
335 <exception cref="T:System.ArgumentNullException">
\r
336 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
339 <block subset="none" type="note">To prevent any modifications to the array, expose the array only through this wrapper.</block>
\r
341 <para>The returned <see langword="IList<T>"/> has the same enumeration order as the array it wraps.</para>
\r
342 <para>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.</para>
\r
345 <Excluded>0</Excluded>
\r
347 <Member MemberName="BinarySearch">
\r
348 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch(class System.Array array, int32 index, int32 length, object value, class System.Collections.IComparer comparer)"/>
\r
349 <MemberSignature Language="C#" Value="public static int BinarySearch(Array array, int index, int length, object value, IComparer comparer);"/>
\r
350 <MemberType>Method</MemberType>
\r
352 <ReturnType>System.Int32</ReturnType>
\r
355 <Parameter Name="array" Type="System.Array"/>
\r
356 <Parameter Name="index" Type="System.Int32"/>
\r
357 <Parameter Name="length" Type="System.Int32"/>
\r
358 <Parameter Name="value" Type="System.Object"/>
\r
359 <Parameter Name="comparer" Type="System.Collections.IComparer"/>
\r
363 <para>Searches the specified section of the specified
\r
364 one-dimensional <see cref="T:System.Array"/> for the specified value, using the
\r
365 specified <see cref="T:System.Collections.IComparer"/>
\r
366 implementation.</para>
\r
368 <param name="array">A <see cref="T:System.Array"/> to search.</param>
\r
369 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which searching starts. </param>
\r
370 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to search, beginning with <paramref name="index"/> . </param>
\r
371 <param name="value">A <see cref="T:System.Object"/> for which to search. </param>
\r
372 <param name="comparer">
\r
373 <para>The <see cref="T:System.Collections.IComparer"/> implementation to use when comparing elements. Specify a null reference to use the <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
376 <para>A <see cref="T:System.Int32"/> with one of the following values based on the result of the search
\r
378 <list type="table">
\r
380 <term>Return Value</term>
\r
381 <description>Description</description>
\r
384 <term> The index of <paramref name="value"/> in the
\r
387 <paramref name="value"/> was found.</description>
\r
390 <term> The bitwise complement of the index of the first element that is larger than
\r
391 <paramref name="value"/>.</term>
\r
393 <paramref name="value"/> was not found, and at least one array element in the
\r
394 range of <paramref name="index"/> to <paramref name="index"/> + <paramref name="length"/> - 1 was greater
\r
395 than <paramref name="value"/>.</description>
\r
398 <term> The bitwise complement of (<paramref name="index"/> + <paramref name="length"/>).</term>
\r
400 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than all
\r
401 array elements in the range of <paramref name="index"/> to <paramref name="index"/> +
\r
402 <paramref name="length"/>- 1.</description>
\r
406 <block subset="none" type="note"> If <paramref name="value"/> is
\r
407 not found, the caller can take the bitwise complement of the return value to
\r
408 determine the index of <paramref name="array"/> where <paramref name="value"/> would be found in the
\r
409 range of <paramref name="index"/> to <paramref name="index"/> + <paramref name="length"/> - 1 if <paramref name="array"/> is
\r
410 already sorted.</block>
\r
413 <exception cref="T:System.ArgumentNullException">
\r
414 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
415 <exception cref="T:System.RankException">
\r
416 <paramref name="array"/> has more than one dimension.</exception>
\r
417 <exception cref="T:System.ArgumentOutOfRangeException">
\r
419 <paramref name="index"/> is less than <paramref name="array"/>
\r
420 <see langword=".GetLowerBound(0)"/>.</para>
\r
423 <paramref name="length"/> is less than zero.</para>
\r
425 <exception cref="T:System.ArgumentException">
\r
427 <paramref name="index"/> + <paramref name="length"/> is greater than <paramref name="array"/>
\r
428 <see langword=".GetLowerBound(0)"/> + <paramref name="array"/>
\r
429 <see langword=".Length"/>.</para>
\r
430 <para> -or- </para>
\r
432 <paramref name="array"/>.UpperBound == <see cref="F:System.Int32.MaxValue"/>.</para>
\r
434 <exception cref="T:System.InvalidOperationException">
\r
436 <paramref name="comparer"/> is <see langword="null"/>, and both <paramref name="value"/> and at least one element of <paramref name="array"/> do not implement the <see cref="T:System.IComparable"/> interface.</para>
\r
440 <paramref name="value"/> is compared to each element of
\r
441 <paramref name="array"/> using <paramref name="comparer"/> until an element with a value greater
\r
442 than or equal to <paramref name="value"/> is found. If <paramref name="comparer"/> is <see langword="null"/>,
\r
443 the <see cref="T:System.IComparable"/> interface of the element being compared - or of
\r
444 <paramref name="value"/> if the element being compared does not implement the interface
\r
445 -- is used. If <paramref name="value"/> does not implement the <see cref="T:System.IComparable"/> interface and is compared to an element
\r
446 that does not implement the <see cref="T:System.IComparable"/> interface, a <see cref="T:System.InvalidOperationException"/>
\r
447 exception is thrown. If <paramref name="array"/> is not already
\r
448 sorted, correct results are not guaranteed.</para>
\r
450 <block subset="none" type="note"> A null reference can
\r
451 be compared with any type; therefore, comparisons with a
\r
452 null reference do not generate exceptions.</block>
\r
456 <para>This example demonstrates the <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/> method.</para>
\r
457 <code lang="C#">using System;
\r
458 class BinarySearchExample {
\r
459 public static void Main() {
\r
460 int[] intAry = { 0, 2, 4, 6, 8 };
\r
461 Console.WriteLine( "The indices and elements of the array are: ");
\r
462 for ( int i = 0; i < intAry.Length; i++ )
\r
463 Console.Write("[{0}]: {1, -5}", i, intAry[i]);
\r
464 Console.WriteLine();
\r
465 SearchFor( intAry, 3 );
\r
466 SearchFor( intAry, 6 );
\r
467 SearchFor( intAry, 9 );
\r
469 public static void SearchFor( Array ar, Object value ) {
\r
470 int i = Array.BinarySearch( ar, 0, ar.Length, value, null );
\r
471 Console.WriteLine();
\r
473 Console.Write( "The object searched for, {0}, was found ", value );
\r
474 Console.WriteLine( "at index {1}.", value, i );
\r
476 else if ( ~i == ar.Length ) {
\r
477 Console.Write( "The object searched for, {0}, was ", value );
\r
478 Console.Write( "not found,\nand no object in the array had " );
\r
479 Console.WriteLine( "greater value. " );
\r
482 Console.Write( "The object searched for, {0}, was ", value );
\r
483 Console.Write( "not found.\nThe next larger object is at " );
\r
484 Console.WriteLine( "index {0}.", ~i );
\r
489 <para>The output is</para>
\r
491 <para>The indices and elements of the array are:</para>
\r
492 <para> [0]:0 [1]:2 [2]:4 [3]:6 [4]:8</para>
\r
493 <para>The object searched for, 3, was not found.</para>
\r
494 <para>The next larger object is at index 2.</para>
\r
495 <para>The object searched for, 6, was found at index 3.</para>
\r
496 <para>The object searched for, 9, was not found,</para>
\r
497 <para>and no object in the array had greater value.</para>
\r
501 <Excluded>0</Excluded>
\r
503 <Member MemberName="BinarySearch">
\r
504 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch(class System.Array array, object value, class System.Collections.IComparer comparer)"/>
\r
505 <MemberSignature Language="C#" Value="public static int BinarySearch(Array array, object value, IComparer comparer);"/>
\r
506 <MemberType>Method</MemberType>
\r
508 <ReturnType>System.Int32</ReturnType>
\r
511 <Parameter Name="array" Type="System.Array"/>
\r
512 <Parameter Name="value" Type="System.Object"/>
\r
513 <Parameter Name="comparer" Type="System.Collections.IComparer"/>
\r
517 <para>Searches the specified one-dimensional <see cref="T:System.Array"/> for the specified
\r
518 value, using the specified <see cref="T:System.Collections.IComparer"/>
\r
519 implementation.</para>
\r
521 <param name="array">A <see cref="T:System.Array"/> to search.</param>
\r
522 <param name="value">A <see cref="T:System.Object"/> for which to search. </param>
\r
523 <param name="comparer">
\r
524 <para>The <see cref="T:System.Collections.IComparer"/> implementation to use when comparing elements. Specify a null reference to use the <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
527 <para>A <see cref="T:System.Int32"/> with one of the following values based on the result of the search
\r
529 <list type="table">
\r
531 <term>Return Value</term>
\r
532 <description>Description</description>
\r
535 <term> The index of <paramref name="value"/> in the
\r
538 <paramref name="value"/> was found.</description>
\r
541 <term> The bitwise complement of the index of the first element that is larger than
\r
542 <paramref name="value"/>.</term>
\r
544 <paramref name="value"/> was not found, and at least one array element was
\r
545 greater than <paramref name="value"/>.</description>
\r
548 <term> The bitwise complement of (<paramref name="array"/>.GetLowerBound(0) +
\r
549 <paramref name="array"/>.Length).</term>
\r
551 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than all
\r
552 array elements.</description>
\r
556 <block subset="none" type="note"> If <paramref name="value"/>
\r
557 is not found, the caller can take the bitwise complement of the return value to
\r
558 determine the index where value would be found in <paramref name="array"/> if it is
\r
559 already sorted.</block>
\r
562 <exception cref="T:System.ArgumentNullException">
\r
563 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
564 <exception cref="T:System.RankException">
\r
565 <paramref name="array"/> has more than one dimension.</exception>
\r
566 <exception cref="T:System.InvalidOperationException">
\r
568 <paramref name="comparer"/> is <see langword="null"/>, and both <paramref name="value"/> and at least one element of <paramref name="array"/> do not implement the <see cref="T:System.IComparable"/> interface.</para>
\r
571 <para>This version of <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/>(<paramref name="array"/>, <paramref name="array"/>.GetLowerBound(0),
\r
572 <paramref name="array"/>.Length, <paramref name="value"/>, <paramref name="comparer"/>).</para>
\r
574 <paramref name="value"/> is compared to each element of
\r
575 <paramref name="array"/> using <paramref name="comparer"/> until an element with a value greater
\r
576 than or equal to <paramref name="value"/> is found. If <paramref name="comparer"/> is <see langword="null"/>,
\r
577 the <see cref="T:System.IComparable"/> interface of the element being compared - or of
\r
578 <paramref name="value"/> if the element being compared does not implement the interface
\r
579 - is used. If <paramref name="value"/> does not implement
\r
580 the <see cref="T:System.IComparable"/>
\r
581 interface and is compared to an element that does not implement
\r
582 the <see cref="T:System.IComparable"/>
\r
583 interface, a <see cref="T:System.InvalidOperationException"/> exception is thrown. If <paramref name="array"/> is
\r
584 not already sorted, correct results are not guaranteed.</para>
\r
586 <block subset="none" type="note"> A null reference
\r
587 can be compared with any type; therefore, comparisons
\r
588 with a null reference do not generate exceptions.</block>
\r
592 <Excluded>0</Excluded>
\r
594 <Member MemberName="BinarySearch">
\r
595 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch(class System.Array array, int32 index, int32 length, object value)"/>
\r
596 <MemberSignature Language="C#" Value="public static int BinarySearch(Array array, int index, int length, object value);"/>
\r
597 <MemberType>Method</MemberType>
\r
599 <ReturnType>System.Int32</ReturnType>
\r
602 <Parameter Name="array" Type="System.Array"/>
\r
603 <Parameter Name="index" Type="System.Int32"/>
\r
604 <Parameter Name="length" Type="System.Int32"/>
\r
605 <Parameter Name="value" Type="System.Object"/>
\r
609 <para>Searches the specified section of the specified
\r
610 one-dimensional <see cref="T:System.Array"/> for the specified value.</para>
\r
612 <param name="array">A <see cref="T:System.Array"/> to search.</param>
\r
613 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which searching starts.</param>
\r
614 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to search, beginning with <paramref name="index"/> .</param>
\r
615 <param name="value">A <see cref="T:System.Object"/> for which to search. </param>
\r
617 <para>A <see cref="T:System.Int32"/> with one of the following values based on the result of the search
\r
619 <list type="table">
\r
621 <term>Return Value</term>
\r
622 <description>Description</description>
\r
625 <term> The index of <paramref name="value"/> in the
\r
628 <paramref name="value"/> was found.</description>
\r
631 <term> The bitwise complement of the index of the first element that is larger than
\r
632 <paramref name="value"/>.</term>
\r
634 <paramref name="value"/> was not found, and at least one array element in the
\r
635 range of <paramref name="index"/> to <paramref name="index"/> + <paramref name="length"/> - 1 was greater
\r
636 than <paramref name="value"/>.</description>
\r
639 <term> The bitwise complement of (<paramref name="index"/> + <paramref name="length"/>).</term>
\r
641 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than all
\r
642 array elements in the range of <paramref name="index"/> to <paramref name="index"/> +
\r
643 <paramref name="length"/>- 1.</description>
\r
647 <block subset="none" type="note"> If <paramref name="value"/>
\r
648 is not found, the caller can take the bitwise complement of the return value to
\r
649 determine the index of the array where <paramref name="value"/> would be found in the
\r
650 range of <paramref name="index"/> to <paramref name="index"/> + <paramref name=" length"/> - 1 if <paramref name="array"/>
\r
651 is already sorted.</block>
\r
654 <exception cref="T:System.ArgumentNullException">
\r
655 <paramref name="array"/> is <see langword="null"/> .</exception>
\r
656 <exception cref="T:System.RankException">
\r
657 <paramref name="array"/> has more than one dimension.</exception>
\r
658 <exception cref="T:System.ArgumentOutOfRangeException">
\r
660 <paramref name="index"/> < <paramref name="array"/>.GetLowerBound(0).</para>
\r
663 <paramref name="length"/> < 0.</para>
\r
665 <exception cref="T:System.ArgumentException">
\r
667 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/> (i.e. <paramref name="index"/> + <paramref name="length"/> > <paramref name="array"/>.GetLowerBound(0) + <paramref name="array"/>.Length).</para>
\r
670 <paramref name="array"/>.UpperBound == <see cref="F:System.Int32.MaxValue"/>.</para>
\r
672 <exception cref="T:System.InvalidOperationException">
\r
673 <para>Either <paramref name="value"/> or at least one element of <paramref name="array"/> does not implement the <see cref="T:System.IComparable"/> interface.</para>
\r
676 <para>This version of <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/>(<paramref name="array"/>, <paramref name="array"/>.GetLowerBound(0),
\r
677 <paramref name="array"/>.Length, <paramref name="value"/>,
\r
678 <see langword="null"/>). </para>
\r
680 <paramref name="value"/> is compared to each element of <paramref name="array"/> using
\r
681 the <see cref="T:System.IComparable"/> interface of the element being compared - or of
\r
682 <paramref name="value"/> if the element being compared does not implement the interface -
\r
683 until an element with a value greater than or equal to <paramref name="value"/> is found.
\r
684 If <paramref name="value"/> does not implement the <see cref="T:System.IComparable"/> interface and is compared to an element
\r
685 that does not implement the <see cref="T:System.IComparable"/> interface, a <see cref="T:System.InvalidOperationException"/>
\r
686 exception is thrown. If <paramref name="array"/> is not already sorted, correct results
\r
687 are not guaranteed. </para>
\r
689 <block subset="none" type="note"> A null reference can be compared with
\r
690 any type; therefore, comparisons with a null reference do not generate
\r
691 exceptions.</block>
\r
695 <Excluded>0</Excluded>
\r
697 <Member MemberName="BinarySearch">
\r
698 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch(class System.Array array, object value)"/>
\r
699 <MemberSignature Language="C#" Value="public static int BinarySearch(Array array, object value);"/>
\r
700 <MemberType>Method</MemberType>
\r
702 <ReturnType>System.Int32</ReturnType>
\r
705 <Parameter Name="array" Type="System.Array"/>
\r
706 <Parameter Name="value" Type="System.Object"/>
\r
710 <para>Searches the specified one-dimensional <see cref="T:System.Array"/> for the specified object.</para>
\r
712 <param name="array">A <see cref="T:System.Array"/> to search for an object.</param>
\r
713 <param name="value">A <see cref="T:System.Object"/> for which to search. </param>
\r
715 <para>A <see cref="T:System.Int32"/> with one of the following values based on the result of the search
\r
717 <list type="table">
\r
719 <term>Return Value</term>
\r
720 <description> Description</description>
\r
723 <term> The index of <paramref name="value"/> in the
\r
726 <paramref name="value"/> was found.</description>
\r
729 <term> The bitwise complement of the index of the first element that is larger than
\r
730 <paramref name="value"/>.</term>
\r
732 <paramref name="value"/> was not found and the value of at least one element of
\r
733 <paramref name="array"/> was greater than <paramref name="value"/>.</description>
\r
736 <term> The bitwise complement of (<paramref name="array"/>.GetLowerBound(0) +
\r
737 <paramref name="array"/>.Length).</term>
\r
739 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than the
\r
740 value of all array elements.</description>
\r
744 <block subset="none" type="note"> If <paramref name="value"/>
\r
745 is not found, the caller can take the bitwise complement of the return value to
\r
746 determine the index where value would be found in <paramref name="array"/> if it is sorted
\r
750 <exception cref="T:System.ArgumentNullException">
\r
751 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
752 <exception cref="T:System.RankException">
\r
754 <paramref name="array"/> has more than one dimension.</para>
\r
756 <exception cref="T:System.InvalidOperationException">
\r
757 <para>Both <paramref name="value"/> and at least one element of <paramref name="array"/> do not implement the <see cref="T:System.IComparable"/> interface. </para>
\r
760 <para>This version of <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.BinarySearch(System.Array,System.Object)"/>(<paramref name="array"/>, <paramref name="array"/>.GetLowerBound(0),
\r
761 <paramref name="array"/>.Length, <paramref name="value"/>,
\r
762 <see langword="null"/>).</para>
\r
764 <paramref name="value"/> is compared to each element of
\r
765 <paramref name="array"/> using the <see cref="T:System.IComparable"/> interface of the element being
\r
766 compared - or of <paramref name="value"/> if the element being compared does not implement the
\r
767 interface - until an element with a value greater than or equal to
\r
768 <paramref name="value"/> is found. If <paramref name="value"/> does not implement the <see cref="T:System.IComparable"/> interface
\r
769 and is compared to an element that does not implement the <see cref="T:System.IComparable"/> interface,
\r
770 a <see cref="T:System.InvalidOperationException"/> exception is thrown. If <paramref name="array"/>
\r
771 is not already sorted, correct results are not guaranteed.</para>
\r
773 <block subset="none" type="note"> A null reference
\r
774 can be compared with any type; therefore,
\r
775 comparisons with a null reference do not generate exceptions.</block>
\r
779 <Excluded>0</Excluded>
\r
781 <Member MemberName="BinarySearch<T>">
\r
782 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch<T>(!!0[] array, !!0 value)"/>
\r
783 <MemberSignature Language="C#" Value="public static int BinarySearch<T>(T[] array, T value)"/>
\r
784 <MemberType>Method</MemberType>
\r
786 <ReturnType>System.Int32</ReturnType>
\r
789 <Parameter Name="array" Type="T[]"/>
\r
790 <Parameter Name="value" Type="T"/>
\r
794 <para>Searches an entire one-dimensional sorted array for a specific element, using the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface implemented by each element of the array and by the specified object.</para>
\r
796 <param name="array">The one-dimensional array to search.</param>
\r
797 <param name="value">The object for which to search.</param>
\r
799 <para>One of the following values based on the result of the search operation:</para>
\r
800 <list type="table">
\r
802 <term>Return Value</term>
\r
803 <description>Description</description>
\r
806 <term>A non-negative index of <paramref name="value"/> in the array.</term>
\r
808 <paramref name="value"/> was found.</description>
\r
811 <term>A negative value, which is the bitwise complement of the index of the first element that is larger than <paramref name="value"/>.</term>
\r
813 <paramref name="value"/> was not found and the value of at least one element of array was greater than <paramref name="value"/>.</description>
\r
816 <term>A negative value, which is the bitwise complement of one more than the index of the final element.</term>
\r
818 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than the value of all array elements.</description>
\r
822 <exception cref="T:System.ArgumentNullException">
\r
823 <paramref name="array"/> is <see langword="null"/> .</exception>
\r
824 <exception cref="T:System.InvalidOperationException">
\r
825 <para>Neither <paramref name="value"/> nor the elements of the array implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interfaces.</para>
\r
828 <para>Either <paramref name="value"/> or every element of <paramref name="array"/> must implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface, which is used for comparisons. The elements of <paramref name="array"/> must already be sorted in increasing value according to the sort order defined by the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation; otherwise, the behavior is unspecified</para>
\r
829 <para>Duplicate elements are allowed. If the array contains more than one element equal to <paramref name="value"/>, the method returns the index of only one of the occurrences, but not necessarily the first one.</para>
\r
831 <block subset="none" type="note">
\r
832 <see langword="null"/> can always be compared with any other reference type; therefore, comparisons with <see langword="null"/> do not generate an exception.</block>
\r
836 <Excluded>0</Excluded>
\r
838 <Member MemberName="BinarySearch<T>">
\r
839 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch<T>(!!0[] array, !!0 value, class System.Collections.Generic.IComparer`1<!!0> comparer)"/>
\r
840 <MemberSignature Language="C#" Value="public static int BinarySearch<T>(T[] array, T value, IComparer<T> comparer)"/>
\r
841 <MemberType>Method</MemberType>
\r
843 <ReturnType>System.Int32</ReturnType>
\r
846 <Parameter Name="array" Type="T[]"/>
\r
847 <Parameter Name="value" Type="T"/>
\r
848 <Parameter Name="comparer" Type="System.Collections.Generic.IComparer<T>"/>
\r
852 <para>Searches an entire one-dimensional sorted array for a value using the specified <see cref="T:System.Collections.Generic.IComparer<T>"/> interface.</para>
\r
854 <param name="array">The one-dimensional array to search.</param>
\r
855 <param name="value">The object for which to search.</param>
\r
856 <param name="comparer">
\r
857 <para>The implementation to use when comparing elements.</para>
\r
860 <see langword="null"/> to use the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
863 <para>One of the following values based on the result of the search operation:</para>
\r
864 <list type="table">
\r
866 <term>Return Value</term>
\r
867 <description>Description</description>
\r
870 <term>A non-negative index of <paramref name="value"/> in the array.</term>
\r
872 <paramref name="value"/> was found.</description>
\r
875 <term>A negative value, which is the bitwise complement of the index of the first element that is larger than <paramref name="value"/>.</term>
\r
877 <paramref name="value"/> was not found and the value of at least one element of array was greater than <paramref name="value"/>.</description>
\r
880 <term>A negative value, which is the bitwise complement of one more than the index of the final element.</term>
\r
882 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than the value of all array elements.</description>
\r
886 <exception cref="T:System.ArgumentNullException">
\r
887 <paramref name="array"/> is <see langword="null"/> .</exception>
\r
888 <exception cref="T:System.InvalidOperationException">
\r
890 <paramref name="comparer"/> is <see langword="null"/>, and neither <paramref name="value"/> nor the elements of the array implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface.</para>
\r
893 <para>The comparer customizes how the elements are compared.</para>
\r
894 <para>The elements of <paramref name="array"/> must already be sorted in increasing value according to the sort order defined by <paramref name="comparer"/>; otherwise, the behavior is unspecified</para>
\r
895 <para>If <paramref name="comparer"/> is not <see langword="null"/>, the elements of <paramref name="array"/> are compared to the specified value using the specified <see cref="T:System.Collections.Generic.IComparer"/> implementation. </para>
\r
896 <para>If <paramref name="comparer"/> is <see langword="null"/>, the default comparer is used.</para>
\r
897 <para>Duplicate elements are allowed. If the array contains more than one element equal to <paramref name="value"/>, the method returns the index of only one of the occurrences, but not necessarily the first one.</para>
\r
899 <block subset="none" type="note">
\r
900 <see langword="null"/> can always be compared with any other reference type; therefore, comparisons with <see langword="null"/> do not generate an exception.</block>
\r
904 <Excluded>0</Excluded>
\r
906 <Member MemberName="BinarySearch<T>">
\r
907 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch<T>(!!0 array, int32 index, int32 length, !!0 value)"/>
\r
908 <MemberSignature Language="C#" Value="public static int BinarySearch<T>(T[] array, int index, int length, T value)"/>
\r
909 <MemberType>Method</MemberType>
\r
911 <ReturnType>System.Int32</ReturnType>
\r
914 <Parameter Name="array" Type="T[]"/>
\r
915 <Parameter Name="index" Type="System.Int32"/>
\r
916 <Parameter Name="length" Type="System.Int32"/>
\r
917 <Parameter Name="value" Type="T"/>
\r
921 <para>Searches a range of elements in a one-dimensional sorted array for a value, using the <see cref="T:System.IComparable"/> interface implemented by each element of the array and by the specified value.</para>
\r
923 <param name="array">The one-dimensional array to search.</param>
\r
924 <param name="index">The starting index of the range to search.</param>
\r
925 <param name="length">The length of the range to search.</param>
\r
926 <param name="value">The object for which to search.</param>
\r
928 <para>One of the following values based on the result of the search operation:</para>
\r
929 <list type="table">
\r
931 <term>Return Value</term>
\r
932 <description>Description</description>
\r
935 <term>A non-negative index of <paramref name="value"/> in the array.</term>
\r
937 <paramref name="value"/> was found.</description>
\r
940 <term>A negative value, which is the bitwise complement of the index of the first element that is larger than <paramref name="value"/>.</term>
\r
942 <paramref name="value"/> was not found and the value of at least one element of array was greater than <paramref name="value"/>.</description>
\r
945 <term>A negative value, which is the bitwise complement of one more than the index of the final element.</term>
\r
947 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than the value of all array elements.</description>
\r
951 <exception cref="T:System.ArgumentException">
\r
953 <paramref name="index"/> + <paramref name="length"/> is greater than <paramref name="array"/>
\r
954 <see langword=".Length"/>.</para>
\r
956 <exception cref="T:System.ArgumentNullException">
\r
957 <paramref name="array"/> is <see langword="null"/> .</exception>
\r
958 <exception cref="T:System.ArgumentOutOfRangeException">
\r
960 <paramref name="index"/> is less than zero</para>
\r
963 <paramref name="length"/> is less than zero.</para>
\r
965 <exception cref="T:System.InvalidOperationException">
\r
966 <para>Neither <paramref name="value"/> nor the elements of the array implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface.</para>
\r
969 <para>Either <paramref name="value"/> or every element of <paramref name="array"/> must implement the <see cref="T:System.IComparable"/> interface, which is used for comparisons. The elements of <paramref name="array"/> must already be sorted in increasing value according to the sort order defined by the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation; otherwise, the behavior is unspecified</para>
\r
970 <para>Duplicate elements are allowed. If the array contains more than one element equal to <paramref name="value"/>, the method returns the index of only one of the occurrences, but not necessarily the first one.</para>
\r
972 <block subset="none" type="note">
\r
973 <see langword="null"/> can always be compared with any other reference type; therefore, comparisons with <see langword="null"/> do not generate an exception.</block>
\r
977 <Excluded>0</Excluded>
\r
979 <Member MemberName="BinarySearch<T>">
\r
980 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 BinarySearch<T>(!!0[] array, int32 index, int32 length, !!0 value, class System.Collections.Generic.IComparer`1<!!0> comparer)"/>
\r
981 <MemberSignature Language="C#" Value="public static int BinarySearch<T>(T[] array, int index, int length, T value, IComparer<T> comparer)"/>
\r
982 <MemberType>Method</MemberType>
\r
984 <ReturnType>System.Int32</ReturnType>
\r
987 <Parameter Name="array" Type="T[]"/>
\r
988 <Parameter Name="index" Type="System.Int32"/>
\r
989 <Parameter Name="length" Type="System.Int32"/>
\r
990 <Parameter Name="value" Type="T"/>
\r
991 <Parameter Name="comparer" Type="System.Collections.Generic.IComparer<T>"/>
\r
995 <para>Searches a range of elements in a one-dimensional sorted array for a value, using the specified <see cref="T:System.Collections.Generic.IComparer<T>"/> interface.</para>
\r
997 <param name="array">The one-dimensional array to search.</param>
\r
998 <param name="index">The starting index of the range to search.</param>
\r
999 <param name="length">The length of the range to search.</param>
\r
1000 <param name="value">The object for which to search.</param>
\r
1001 <param name="comparer">
\r
1002 <para>The implementation to use when comparing elements.</para>
\r
1005 <see langword="null"/> to use the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
1008 <para>One of the following values based on the result of the search operation:</para>
\r
1009 <list type="table">
\r
1011 <term>Return Value</term>
\r
1012 <description>Description</description>
\r
1015 <term>A non-negative index of <paramref name="value"/> in the array.</term>
\r
1017 <paramref name="value"/> was found.</description>
\r
1020 <term>A negative value, which is the bitwise complement of the index of the first element that is larger than <paramref name="value"/>.</term>
\r
1022 <paramref name="value"/> was not found and the value of at least one element of array was greater than <paramref name="value"/>.</description>
\r
1025 <term>A negative value, which is the bitwise complement of one more than the index of the final element.</term>
\r
1027 <paramref name="value"/> was not found, and <paramref name="value"/> was greater than the value of all array elements.</description>
\r
1031 <exception cref="T:System.ArgumentException">
\r
1033 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in array.</para>
\r
1035 <exception cref="T:System.ArgumentNullException">
\r
1036 <paramref name="array"/> is <see langword="null"/> .</exception>
\r
1037 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1039 <paramref name="index"/> is less than zero</para>
\r
1042 <paramref name="length"/> is less than zero.</para>
\r
1044 <exception cref="T:System.InvalidOperationException">
\r
1046 <paramref name="comparer"/> is <see langword="null"/>, and neither <paramref name="value"/> nor the elements of the array implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface.</para>
\r
1049 <para>The comparer customizes how the elements are compared.</para>
\r
1050 <para>The elements of <paramref name="array"/> must already be sorted in increasing value according to the sort order defined by <paramref name="comparer"/>; otherwise, the behavior is unspecified.</para>
\r
1051 <para>If <paramref name="comparer"/> is not <see langword="null"/>, the elements of <paramref name="array"/> are compared to the specified value using the specified <see cref="T:System.Collections.Generic.IComparer<T>"/> implementation. </para>
\r
1052 <para>If <paramref name="comparer"/> is <see langword="null"/>, the comparison is done using the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable "/> implementation provided by the element itself or by the specified value.</para>
\r
1053 <para>Duplicate elements are allowed. If the array contains more than one element equal to <paramref name="value"/>, the method returns the index of only one of the occurrences, but not necessarily the first one.</para>
\r
1055 <block subset="none" type="note">
\r
1056 <see langword="null"/> can always be compared with any other reference type; therefore, comparisons with <see langword="null"/> do not generate an exception.</block>
\r
1060 <Excluded>0</Excluded>
\r
1062 <Member MemberName="Clear">
\r
1063 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Clear(class System.Array array, int32 index, int32 length)"/>
\r
1064 <MemberSignature Language="C#" Value="public static void Clear(Array array, int index, int length);"/>
\r
1065 <MemberType>Method</MemberType>
\r
1067 <ReturnType>System.Void</ReturnType>
\r
1070 <Parameter Name="array" Type="System.Array"/>
\r
1071 <Parameter Name="index" Type="System.Int32"/>
\r
1072 <Parameter Name="length" Type="System.Int32"/>
\r
1076 <para>Sets the specified range of elements in the
\r
1077 specified <see cref="T:System.Array"/> to zero, false, or to a null reference, depending on the
\r
1078 element type.</para>
\r
1080 <param name="array">The <see cref="T:System.Array"/> to clear.</param>
\r
1081 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which clearing starts.</param>
\r
1082 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to clear, beginning with <paramref name="index"/>.</param>
\r
1083 <exception cref="T:System.ArgumentNullException">
\r
1084 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
1085 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1087 <paramref name="index"/> < <paramref name="array"/>.GetLowerBound(0).</para>
\r
1089 <paramref name="length"/> < 0.</para>
\r
1091 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/> (i.e. <paramref name="index"/> + <paramref name="length"/> > <paramref name="array"/>.GetLowerBound(0) + <paramref name="array"/>.Length ).</para>
\r
1094 <para>Reference-type elements will be set to
\r
1095 <see langword="null"/>. Value-type elements will be set to zero,
\r
1096 except for <see cref="T:System.Boolean"/>
\r
1097 elements, which will be set to
\r
1098 <see langword="false"/>.</para>
\r
1101 <Excluded>0</Excluded>
\r
1103 <Member MemberName="Clone">
\r
1104 <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual object Clone()"/>
\r
1105 <MemberSignature Language="C#" Value="public virtual object Clone();"/>
\r
1106 <MemberType>Method</MemberType>
\r
1108 <ReturnType>System.Object</ReturnType>
\r
1113 <para>Returns a <see cref="T:System.Object"/> that is a copy of the current instance.</para>
\r
1116 <para>A <see cref="T:System.Object"/> that is a copy of
\r
1117 the current instance.</para>
\r
1121 <block subset="none" type="note"> This method is implemented to support
\r
1122 the <see cref="T:System.ICloneable"/>
\r
1123 interface.</block>
\r
1126 <block subset="none" type="behaviors">Each of the
\r
1127 elements of the current instance is copied to the clone. If the elements are
\r
1128 reference types, the references are copied. If the elements are value-types, the
\r
1129 values are copied. The clone is of the same type as the current
\r
1133 <block subset="none" type="default">As described above.</block>
\r
1136 <block subset="none" type="overrides">Override this method to return a
\r
1137 clone of an array.</block>
\r
1140 <block subset="none" type="usage">Use this method to obtain the clone of
\r
1145 <para>This example demonstrates the <see cref="M:System.Array.Clone"/> method.</para>
\r
1146 <code lang="C#">using System;
\r
1147 public class ArrayCloneExample {
\r
1148 public static void Main() {
\r
1149 int[] intAryOrig = { 3, 4, 5 };
\r
1150 //must explicitly convert clones object into an array
\r
1151 int[] intAryClone = (int[]) intAryOrig.Clone();
\r
1152 Console.Write( "The elements of the first array are: " );
\r
1153 foreach( int i in intAryOrig )
\r
1154 Console.Write( "{0,3}", i );
\r
1155 Console.WriteLine();
\r
1156 Console.Write( "The elements of the cloned array are: " );
\r
1157 foreach( int i in intAryClone )
\r
1158 Console.Write( "{0,3}", i );
\r
1159 Console.WriteLine();
\r
1160 //Clear the values of the original array.
\r
1161 Array.Clear( intAryOrig, 0, 3 );
\r
1162 Console.WriteLine( "After clearing the first array," );
\r
1163 Console.Write( "The elements of the first array are: " );
\r
1164 foreach( int i in intAryOrig )
\r
1165 Console.Write( "{0,3}", i );
\r
1166 Console.WriteLine();
\r
1167 Console.Write( "The elements of the cloned array are: " );
\r
1168 foreach( int i in intAryClone )
\r
1169 Console.Write( "{0,3}", i );
\r
1173 <para>The output is</para>
\r
1175 <para>The elements of the first array are: 3 4 5</para>
\r
1176 <para>The elements of the cloned array are: 3 4 5</para>
\r
1177 <para>After clearing the first array,</para>
\r
1178 <para>The elements of the first array are: 0 0 0</para>
\r
1179 <para>The elements of the cloned array are: 3 4 5</para>
\r
1183 <Excluded>0</Excluded>
\r
1185 <Member MemberName="ConvertAll<T,U>">
\r
1186 <MemberSignature Language="ILAsm" Value=".method public hidebysig static !!1[] ConvertAll<T,U>(!!0[] array, class System.Converter`1<!!0,!!1> converter)"/>
\r
1187 <MemberSignature Language="C#" Value="public static U[] ConvertAll<T,U>(T[] array, Converter<T,U> converter)"/>
\r
1188 <MemberType>Method</MemberType>
\r
1190 <ReturnType>U[]</ReturnType>
\r
1193 <Parameter Name="array" Type="T[]"/>
\r
1194 <Parameter Name="converter" Type="System.Converter<T,U>"/>
\r
1198 <para>Converts an array of one type to an array of another type.</para>
\r
1200 <param name="array">The one-dimensional array to convert.</param>
\r
1201 <param name="converter">
\r
1202 <para>A <see cref="T:System.Converter<T,U>"/> that converts each element from one type to another type.</para>
\r
1205 <para>A new array of the target type containing the converted elements from <paramref name="array"/>.</para>
\r
1207 <exception cref="T:System.ArgumentNullException">
\r
1208 <paramref name="array"/> is <see langword="null"/> or <paramref name="converter"/> is <see langword="null"/>.</exception>
\r
1210 <para>The <see cref="T:System.Converter<T,U>"/> is a delegate that converts an array element to the target type. The elements of <paramref name="array"/> are individually passed to this converter, and the converted elements are saved in the new array. The source array remains unchanged.</para>
\r
1213 <Excluded>0</Excluded>
\r
1215 <Member MemberName="Copy">
\r
1216 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Copy(class System.Array sourceArray, class System.Array destinationArray, int32 length)"/>
\r
1217 <MemberSignature Language="C#" Value="public static void Copy(Array sourceArray, Array destinationArray, int length);"/>
\r
1218 <MemberType>Method</MemberType>
\r
1220 <ReturnType>System.Void</ReturnType>
\r
1223 <Parameter Name="sourceArray" Type="System.Array"/>
\r
1224 <Parameter Name="destinationArray" Type="System.Array"/>
\r
1225 <Parameter Name="length" Type="System.Int32"/>
\r
1229 <para> Copies the specified number of elements from the
\r
1230 specified source array to the specified destination array.</para>
\r
1232 <param name="sourceArray">A <see cref="T:System.Array"/> that contains the data to copy.</param>
\r
1233 <param name="destinationArray">A <see cref="T:System.Array"/> that receives the data.</param>
\r
1234 <param name="length">A <see cref="T:System.Int32"/> designating the number of elements to copy, starting with the first element and proceeding in order.</param>
\r
1235 <exception cref="T:System.ArgumentNullException">
\r
1237 <paramref name="sourceArray"/> or <paramref name="destinationArray"/> is <see langword="null"/>.</para>
\r
1239 <exception cref="T:System.RankException">
\r
1241 <paramref name="sourceArray"/> and <paramref name="destinationArray"/> have different ranks.</para>
\r
1243 <exception cref="T:System.ArrayTypeMismatchException">
\r
1244 <para>The elements in both arrays are built-in types, and converting from the type of the elements of <paramref name="sourceArray"/> into the type of the elements in <paramref name="destinationArray"/> requires a narrowing conversion.</para>
\r
1245 <para> -or-</para>
\r
1246 <para>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.</para>
\r
1247 <para> -or-</para>
\r
1248 <para>Both arrays are user-defined value types and are not of the same type.</para>
\r
1250 <exception cref="T:System.InvalidCastException">
\r
1251 <para> At least one of the elements in <paramref name="sourceArray"/> is not assignment-compatible with the type of <paramref name="destinationArray"/>.</para>
\r
1253 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1255 <paramref name="length"/> < 0.</para>
\r
1257 <exception cref="T:System.ArgumentException">
\r
1259 <paramref name="length"/> > <paramref name="sourceArray"/>.Length.</para>
\r
1262 <paramref name="length "/> > <paramref name="destinationArray"/>.Length.</para>
\r
1265 <para>This version of <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> is equivalent to <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> (<paramref name="sourceArray"/>, <paramref name="sourceArray"/>.GetLowerBound(0), <paramref name="destinationArray"/>,
\r
1266 <paramref name="destinationArray"/>.GetLowerBound(0), <paramref name="length"/>). </para>
\r
1267 <para>If <paramref name="sourceArray"/> and <paramref name="destinationArray"/> are of different
\r
1268 types, <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> performs widening conversions on the elements of
\r
1269 <paramref name="sourceArray"/> as necessary before storing the information in
\r
1270 <paramref name="destinationArray"/>. Value types will be boxed when being converted to a
\r
1271 <see cref="T:System.Object"/>. If the necessary
\r
1272 conversion is a narrowing conversion, a <see cref="T:System.ArrayTypeMismatchException"/> exception is thrown. <block subset="none" type="note">
\r
1273 For information regarding valid conversions performed by this method, see
\r
1274 <see cref="T:System.Convert"/>.</block>
\r
1276 <para>If an exception is thrown while copying, the state of
\r
1277 <paramref name="destinationArray"/> is undefined. </para>
\r
1278 <para>If <paramref name="sourceArray"/> and <paramref name="destinationArray"/> are the same
\r
1279 array, <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> copies the source elements safely to their
\r
1280 destination, as if the copy were done through an intermediate array. </para>
\r
1283 <para>This example demonstrates the <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> method.</para>
\r
1284 <code lang="C#">using System;
\r
1285 public class ArrayCopyExample {
\r
1286 public static void Main() {
\r
1287 int[] intAryOrig = new int[3];
\r
1288 double[] dAryCopy = new double[3];
\r
1289 for ( int i = 0; i < intAryOrig.Length; i++ )
\r
1290 intAryOrig[i] = i+3;
\r
1291 //copy the first 2 elements of the source into the destination
\r
1292 Array.Copy( intAryOrig, dAryCopy, 2);
\r
1293 Console.Write( "The elements of the first array are: " );
\r
1294 for ( int i = 0; i < intAryOrig.Length; i++ )
\r
1295 Console.Write( "{0,3}", intAryOrig[i] );
\r
1296 Console.WriteLine();
\r
1297 Console.Write( "The elements of the copied array are: " );
\r
1298 for ( int i = 0; i < dAryCopy.Length; i++ )
\r
1299 Console.Write( "{0,3}", dAryCopy[i] );
\r
1303 <para>The output is</para>
\r
1305 <para>The elements of the first array are: 3 4 5</para>
\r
1306 <para>The elements of the copied array are: 3 4 0</para>
\r
1310 <Excluded>0</Excluded>
\r
1312 <Member MemberName="Copy">
\r
1313 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Copy(class System.Array sourceArray, int32 sourceIndex, class System.Array destinationArray, int32 destinationIndex, int32 length)"/>
\r
1314 <MemberSignature Language="C#" Value="public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);"/>
\r
1315 <MemberType>Method</MemberType>
\r
1317 <ReturnType>System.Void</ReturnType>
\r
1320 <Parameter Name="sourceArray" Type="System.Array"/>
\r
1321 <Parameter Name="sourceIndex" Type="System.Int32"/>
\r
1322 <Parameter Name="destinationArray" Type="System.Array"/>
\r
1323 <Parameter Name="destinationIndex" Type="System.Int32"/>
\r
1324 <Parameter Name="length" Type="System.Int32"/>
\r
1328 <para> Copies the specified number of elements from a source
\r
1329 array starting at the specified source index to a destination array
\r
1330 starting at the specified destination index.</para>
\r
1332 <param name="sourceArray">The <see cref="T:System.Array"/> that contains the data to copy.</param>
\r
1333 <param name="sourceIndex">A <see cref="T:System.Int32"/> that contains the index in <paramref name="sourceArray"/> from which copying begins.</param>
\r
1334 <param name="destinationArray">The <see cref="T:System.Array"/> that receives the data.</param>
\r
1335 <param name="destinationIndex">A <see cref="T:System.Int32"/> that contains the index in <paramref name="destinationArray"/> at which storing begins.</param>
\r
1336 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to copy.</param>
\r
1337 <exception cref="T:System.ArgumentNullException">
\r
1339 <paramref name="sourceArray"/> or <paramref name="destinationArray"/> is <see langword="null"/>.</para>
\r
1341 <exception cref="T:System.RankException">
\r
1343 <paramref name="sourceArray"/> and <paramref name="destinationArray"/> have different ranks.</para>
\r
1345 <exception cref="T:System.ArrayTypeMismatchException">
\r
1346 <para>The elements in both arrays are built-in types, and converting from the type of the elements of <paramref name="sourceArray"/> into the type of the elements in <paramref name="destinationArray"/> requires a narrowing conversion.</para>
\r
1348 <para>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.</para>
\r
1350 <para>Both arrays are user-defined value types and are not of the same type.</para>
\r
1352 <exception cref="T:System.InvalidCastException">
\r
1353 <para>At least one element in <paramref name="sourceArray"/> is assignment-incompatible with the type of <paramref name="destinationArray"/>.</para>
\r
1355 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1357 <paramref name="sourceIndex"/> < <paramref name="sourceArray"/>.GetLowerBound(0).</para>
\r
1360 <paramref name="destinationIndex"/> < <paramref name="destinationArray"/>.GetLowerBound(0).</para>
\r
1363 <paramref name="length"/> < 0.</para>
\r
1365 <exception cref="T:System.ArgumentException">
\r
1366 <para>(<paramref name="sourceIndex"/> + <paramref name="length"/> ) > (<paramref name="sourceArray"/>.GetLowerBound(0) + <paramref name="sourceArray"/>.Length).</para>
\r
1367 <para>(<paramref name="destinationIndex"/> + <paramref name="length"/> ) > ( <paramref name="destinationArray"/>.GetLowerBound(0) + <paramref name="destinationArray"/>.Length).</para>
\r
1370 <para>If <paramref name="sourceArray"/> and <paramref name="destinationArray"/>
\r
1371 are of different types, <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> performs widening conversions on the elements of
\r
1372 <paramref name="sourceArray"/> as necessary before storing the information in
\r
1373 <paramref name="destinationArray"/>. Value types will be boxed when being converted to a
\r
1374 <see cref="T:System.Object"/>. If the necessary
\r
1375 conversion is a narrowing conversion, a <see cref="T:System.ArrayTypeMismatchException"/> exception is thrown. <block subset="none" type="note">
\r
1376 For information regarding valid conversions performed by this method, see
\r
1377 <see cref="T:System.Convert"/> .</block>
\r
1379 <para>If an exception is thrown while copying, the state of
\r
1380 <paramref name="destinationArray"/> is undefined. </para>
\r
1381 <para>If <paramref name="sourceArray"/> and <paramref name="destinationArray"/>
\r
1382 are the same array, <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> copies the source elements safely to their
\r
1383 destination as if the copy were done through an intermediate array. </para>
\r
1386 <para>This example demonstrates the <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/> method.</para>
\r
1387 <code lang="C#">using System;
\r
1388 class ArrayCopyExample {
\r
1389 public static void Main() {
\r
1390 int[] intAry = { 0, 10, 20, 30, 40, 50 };
\r
1391 Console.Write( "The elements of the array are: " );
\r
1392 foreach ( int i in intAry )
\r
1393 Console.Write( "{0,3}", i );
\r
1394 Console.WriteLine();
\r
1395 Array.Copy( intAry, 2, intAry, 0, 4 );
\r
1396 Console.WriteLine( "After copying elements 2 through 5 into elements 0 through 4" );
\r
1397 Console.Write( "The elements of the array are: " );
\r
1398 foreach ( int i in intAry )
\r
1399 Console.Write( "{0,3}", i );
\r
1400 Console.WriteLine();
\r
1404 <para>The output is</para>
\r
1406 <para>The elements of the array are: 0 10 20 30 40 50</para>
\r
1407 <para>After copying elements 2 through 5 into elements 0 through 4</para>
\r
1408 <para>The elements of the array are: 20 30 40 50 40 50</para>
\r
1412 <Excluded>0</Excluded>
\r
1414 <Member MemberName="CopyTo">
\r
1415 <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual void CopyTo(class System.Array array, int32 index)"/>
\r
1416 <MemberSignature Language="C#" Value="public virtual void CopyTo(Array array, int index);"/>
\r
1417 <MemberType>Method</MemberType>
\r
1419 <ReturnType>System.Void</ReturnType>
\r
1422 <Parameter Name="array" Type="System.Array"/>
\r
1423 <Parameter Name="index" Type="System.Int32"/>
\r
1427 <para> 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.</para>
\r
1429 <param name="array">A one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from the current instance.</param>
\r
1430 <param name="index">A <see cref="T:System.Int32"/> that contains the index in <paramref name="array"/> at which copying begins.</param>
\r
1431 <exception cref="T:System.ArgumentNullException">
\r
1432 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
1433 <exception cref="T:System.RankException">
\r
1434 <para>The current instance has more than one dimension.</para>
\r
1436 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1437 <paramref name="index"/> < <paramref name="array"/>
\r
1438 <see langword=".GetLowerBound(0)"/>.</exception>
\r
1439 <exception cref="T:System.ArgumentException">
\r
1441 <paramref name="array"/> has more than one dimension.</para>
\r
1442 <para> -or-</para>
\r
1443 <para>( <paramref name="index"/> + Length of the current instance) > (<paramref name="array"/>
\r
1444 <see langword=".GetLowerBound(0)"/> + <paramref name="array"/>
\r
1445 <see langword=".Length"/>).</para>
\r
1446 <para> -or-</para>
\r
1447 <para>The number of elements in the current instance is greater than the available space from <paramref name="index"/> to the end of <paramref name="array"/>.</para>
\r
1449 <exception cref="T:System.ArrayTypeMismatchException">The element type of the current instance is not assignment-compatible with the element type of <paramref name="array"/>.</exception>
\r
1452 <paramref name="index"/> is the array index in the destination array at which copying begins.</para>
\r
1453 <block subset="none" type="note">
\r
1454 <para>This method is implemented to support the <see cref="T:System.Collections.ICollection"/> interface. If implementing <see cref="T:System.Collections.ICollection"/> is not explicitly required, use <see cref="M:System.Array.Copy(System.Array,System.Array,System.Int32)"/>
\r
1455 to avoid an extra indirection.</para>
\r
1456 <para>If this method throws an exception while copying, the state of <paramref name="array"/>
\r
1457 is undefined.</para>
\r
1460 <block subset="none" type="behaviors">As described
\r
1464 <block subset="none" type="default">As described
\r
1468 <block subset="none" type="overrides">Override this
\r
1469 method to copy elements of the current instance to a specified
\r
1473 <block subset="none" type="usage">Use this method to
\r
1474 copy elements of the current instance to a specified array.</block>
\r
1478 <para> The following example shows how to copy the elements of one <see cref="T:System.Array"/> into another.</para>
\r
1479 <code lang="C#">using System;
\r
1481 public class ArrayCopyToExample
\r
1483 public static void Main()
\r
1485 Array aryOne = Array.CreateInstance(typeof(Object), 3);
\r
1486 aryOne.SetValue("one", 0);
\r
1487 aryOne.SetValue("two", 1);
\r
1488 aryOne.SetValue("three", 2);
\r
1490 Array aryTwo = Array.CreateInstance(typeof(Object), 5);
\r
1491 for (int i=0; i < aryTwo.Length; i++)
\r
1492 aryTwo.SetValue(i, i);
\r
1494 Console.WriteLine("The contents of the first array are:");
\r
1495 foreach (object o in aryOne)
\r
1496 Console.Write("{0} ", o);
\r
1497 Console.WriteLine();
\r
1498 Console.WriteLine("The original contents of the second array are:");
\r
1499 foreach (object o in aryTwo)
\r
1500 Console.Write("{0} ", o);
\r
1501 Console.WriteLine();
\r
1503 aryOne.CopyTo(aryTwo, 1);
\r
1505 Console.WriteLine("The new contents of the second array are:");
\r
1506 foreach( object o in aryTwo)
\r
1507 Console.Write("{0} ", o);
\r
1511 <para>The output is</para>
\r
1513 <c>The contents of the first array are:</c>
\r
1516 <c> one two three</c>
\r
1519 <c>The original contents of the second array are:</c>
\r
1525 <c> The new contents of the second array are:</c>
\r
1528 <c>0 one two three 4</c>
\r
1532 <Excluded>0</Excluded>
\r
1534 <Member MemberName="CreateInstance">
\r
1535 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class System.Array CreateInstance(class System.Type elementType, int32[] lengths)"/>
\r
1536 <MemberSignature Language="C#" Value="public static Array CreateInstance(Type elementType, int[] lengths);"/>
\r
1537 <MemberType>Method</MemberType>
\r
1539 <ReturnType>System.Array</ReturnType>
\r
1542 <Parameter Name="elementType" Type="System.Type"/>
\r
1543 <Parameter Name="lengths" Type="System.Int32[]"/>
\r
1547 <para>Creates a zero-based, multidimensional array of the
\r
1548 specified <see cref="T:System.Type"/> and dimension lengths.</para>
\r
1550 <param name="elementType">The <see cref="T:System.Type"/> of the elements contained in the new <see cref="T:System.Array"/> instance. </param>
\r
1551 <param name="lengths">A one-dimensional array of <see cref="T:System.Int32"/> objects that contains the size of each dimension of the new <see cref="T:System.Array"/> instance.</param>
\r
1553 <para>A new zero-based, multidimensional <see cref="T:System.Array"/> instance of the
\r
1554 specified <see cref="T:System.Type"/> with the specified length for
\r
1555 each dimension. The <see cref="P:System.Array.Rank"/> of the new instance is equal to
\r
1556 <paramref name="lengths"/>.Length.</para>
\r
1558 <exception cref="T:System.ArgumentNullException">
\r
1560 <paramref name="elementType"/> or <paramref name="lengths"/> is <see langword="null"/>.</para>
\r
1562 <exception cref="T:System.ArgumentException">
\r
1564 <paramref name="elementType"/> is not a valid <see cref="T:System.Type"/>.</para>
\r
1567 <paramref name="lengths"/>.Length = 0.</para>
\r
1569 <exception cref="T:System.ArgumentOutOfRangeException">A value in <paramref name="lengths"/> is less than zero.</exception>
\r
1571 <para>The number of elements in <paramref name="lengths"/> is required to equal the number of
\r
1572 dimensions in the new <see cref="T:System.Array"/> instance. Each element of <paramref name="lengths"/> specifies
\r
1573 the length of the corresponding dimension in the new instance.</para>
\r
1574 <para>Reference-type elements will be set to <see langword="null"/>. Value-type elements will be set to zero,
\r
1575 except for <see cref="T:System.Boolean"/>
\r
1576 elements, which will be set to
\r
1577 <see langword="false"/>.</para>
\r
1579 <block subset="none" type="note">Unlike most classes, <see cref="T:System.Array"/> provides the
\r
1580 <see cref="M:System.Array.CreateInstance(System.Type,System.Int32)"/> method, instead of public constructors, to allow
\r
1581 for late bound access.</block>
\r
1585 <para> The following example shows how to create and initialize a
\r
1586 multidimensional <see cref="T:System.Array"/>.</para>
\r
1590 public class CreateMultiDimArrayExample
\r
1592 public static void Main()
\r
1595 int[] indexAry = {2, 4, 5};
\r
1596 Array ary = Array.CreateInstance( typeof(int), indexAry );
\r
1597 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ )
\r
1599 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ )
\r
1601 for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ )
\r
1603 ary.SetValue( (100*i + 10*j + k), i, j, k );
\r
1607 Console.WriteLine("The elements of the array are:");
\r
1608 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++)
\r
1610 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++)
\r
1612 for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ )
\r
1614 Console.Write("{0, 3} ", ary.GetValue(i, j, k));
\r
1616 Console.WriteLine();
\r
1618 Console.WriteLine();
\r
1623 <para>The output is</para>
\r
1624 <code>The elements of the array are:
\r
1630 100 101 102 103 104
\r
1631 110 111 112 113 114
\r
1632 120 121 122 123 124
\r
1633 130 131 132 133 134
\r
1637 <Excluded>1</Excluded>
\r
1638 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
1640 <Member MemberName="CreateInstance">
\r
1641 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class System.Array CreateInstance(class System.Type elementType, int32 length1, int32 length2, int32 length3)"/>
\r
1642 <MemberSignature Language="C#" Value="public static Array CreateInstance(Type elementType, int length1, int length2, int length3);"/>
\r
1643 <MemberType>Method</MemberType>
\r
1645 <ReturnType>System.Array</ReturnType>
\r
1648 <Parameter Name="elementType" Type="System.Type"/>
\r
1649 <Parameter Name="length1" Type="System.Int32"/>
\r
1650 <Parameter Name="length2" Type="System.Int32"/>
\r
1651 <Parameter Name="length3" Type="System.Int32"/>
\r
1655 <para>Creates a zero-based, three-dimensional array of the
\r
1656 specified <see cref="T:System.Type"/> and dimension lengths.</para>
\r
1658 <param name="elementType">The <see cref="T:System.Type"/> of the elements contained in the new <see cref="T:System.Array"/> instance. </param>
\r
1659 <param name="length1">A <see cref="T:System.Int32"/> that contains the number of elements contained in the first dimension of the new <see cref="T:System.Array"/> instance. </param>
\r
1660 <param name="length2">A <see cref="T:System.Int32"/> that contains the number of elements contained in the second dimension of the new <see cref="T:System.Array"/> instance. </param>
\r
1661 <param name="length3">A <see cref="T:System.Int32"/> that contains the number of elements contained in the third dimension of the new <see cref="T:System.Array"/> instance. </param>
\r
1663 <para>A new zero-based, three-dimensional <see cref="T:System.Array"/> instance of <paramref name="elementType"/> objects with the size
\r
1664 <paramref name="length1"/> for the first dimension, <paramref name="length2"/> for the second, and
\r
1665 <paramref name="length3"/> for the third.</para>
\r
1667 <exception cref="T:System.ArgumentNullException">
\r
1668 <paramref name="elementType"/> is <see langword="null"/>.</exception>
\r
1669 <exception cref="T:System.ArgumentException">
\r
1670 <paramref name="elementType"/> is not a valid <see cref="T:System.Type"/>.</exception>
\r
1671 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1673 <paramref name="length1"/> < 0.</para>
\r
1676 <paramref name="length2"/> < 0.</para>
\r
1679 <paramref name="length3"/> < 0.</para>
\r
1682 <para>Reference-type elements will be set to <see langword="null"/>. Value-type elements will be set to zero,
\r
1683 except for <see cref="T:System.Boolean"/>
\r
1684 elements, which will be set to
\r
1685 <see langword="false"/>.</para>
\r
1687 <block subset="none" type="note">Unlike most classes, <see cref="T:System.Array"/> provides the
\r
1688 <see cref="M:System.Array.CreateInstance(System.Type,System.Int32)"/> method, instead of public constructors, to allow
\r
1689 for late bound access.</block>
\r
1693 <para> The following example shows how to create and
\r
1694 initialize a three-dimensional <see cref="T:System.Array"/>.</para>
\r
1698 public class Create3DArrayExample
\r
1700 public static void Main()
\r
1703 Array ary = Array.CreateInstance( typeof(int), 2, 4, 3 );
\r
1704 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ )
\r
1706 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ )
\r
1708 for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ )
\r
1710 ary.SetValue( (100*i + 10*j + k), i, j, k );
\r
1714 Console.WriteLine("The elements of the array are:");
\r
1715 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++)
\r
1717 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++)
\r
1719 for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ )
\r
1721 Console.Write("{0, 3} ", ary.GetValue(i, j, k));
\r
1723 Console.WriteLine();
\r
1725 Console.WriteLine();
\r
1730 <para>The output is</para>
\r
1731 <code>The elements of the array are:
\r
1744 <Excluded>1</Excluded>
\r
1745 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
1747 <Member MemberName="CreateInstance">
\r
1748 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class System.Array CreateInstance(class System.Type elementType, int32 length1, int32 length2)"/>
\r
1749 <MemberSignature Language="C#" Value="public static Array CreateInstance(Type elementType, int length1, int length2);"/>
\r
1750 <MemberType>Method</MemberType>
\r
1752 <ReturnType>System.Array</ReturnType>
\r
1755 <Parameter Name="elementType" Type="System.Type"/>
\r
1756 <Parameter Name="length1" Type="System.Int32"/>
\r
1757 <Parameter Name="length2" Type="System.Int32"/>
\r
1761 <para>Creates a zero-based, two-dimensional array of the specified <see cref="T:System.Type"/>
\r
1762 and dimension lengths.</para>
\r
1764 <param name="elementType">The <see cref="T:System.Type"/> of the elements contained in the new <see cref="T:System.Array"/> instance. </param>
\r
1765 <param name="length1">A <see cref="T:System.Int32"/> that contains the number of elements contained in the first dimension of the new <see cref="T:System.Array"/> instance. </param>
\r
1766 <param name="length2">A <see cref="T:System.Int32"/> that contains the number of elements contained in the second dimension of the new <see cref="T:System.Array"/> instance. </param>
\r
1768 <para>A new zero-indexed, two-dimensional <see cref="T:System.Array"/> instance of <paramref name="elementType"/> objects with the size
\r
1769 <paramref name="length1"/> for the first dimension and <paramref name="length2"/>
\r
1770 for the second.</para>
\r
1772 <exception cref="T:System.ArgumentNullException">
\r
1773 <paramref name="elementType"/> is <see langword="null"/>.</exception>
\r
1774 <exception cref="T:System.ArgumentException">
\r
1775 <paramref name="elementType"/> is not a valid <see cref="T:System.Type"/>.</exception>
\r
1776 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1778 <paramref name="length1"/> < 0.</para>
\r
1781 <paramref name="length2"/> < 0.</para>
\r
1784 <para>Reference-type elements will be set to <see langword="null"/>. Value-type elements will be set to zero,
\r
1785 except for <see cref="T:System.Boolean"/>
\r
1786 elements, which will be set to
\r
1787 <see langword="false"/>.</para>
\r
1789 <block subset="none" type="note">Unlike most classes, <see cref="T:System.Array"/> provides the
\r
1790 <see cref="M:System.Array.CreateInstance(System.Type,System.Int32)"/> method, instead of public constructors, to allow
\r
1791 for late bound access.</block>
\r
1795 <para> The following example shows how to create and
\r
1796 initialize a two-dimensional <see cref="T:System.Array"/>.</para>
\r
1800 public class Create2DArrayExample
\r
1802 public static void Main()
\r
1805 Array ary = Array.CreateInstance( typeof(int), 5, 3 );
\r
1806 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ )
\r
1808 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ )
\r
1810 ary.SetValue( (10*i + j), i, j );
\r
1813 Console.WriteLine("The elements of the array are:");
\r
1814 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++)
\r
1816 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++)
\r
1818 Console.Write("{0, 2} ", ary.GetValue(i, j));
\r
1820 Console.WriteLine();
\r
1825 <para>The output is</para>
\r
1826 <code>The elements of the array are:
\r
1835 <Excluded>1</Excluded>
\r
1836 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
1838 <Member MemberName="CreateInstance">
\r
1839 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class System.Array CreateInstance(class System.Type elementType, int32 length)"/>
\r
1840 <MemberSignature Language="C#" Value="public static Array CreateInstance(Type elementType, int length);"/>
\r
1841 <MemberType>Method</MemberType>
\r
1843 <ReturnType>System.Array</ReturnType>
\r
1846 <Parameter Name="elementType" Type="System.Type"/>
\r
1847 <Parameter Name="length" Type="System.Int32"/>
\r
1851 <para>Constructs a zero-based, one-dimensional array with the specified number of elements of the specified type.</para>
\r
1853 <param name="elementType">The <see cref="T:System.Type"/> of the elements contained in the new <see cref="T:System.Array"/> instance.</param>
\r
1854 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements contained in the new <see cref="T:System.Array"/> instance.</param>
\r
1856 <para>A zero-based, one-dimensional <see cref="T:System.Array"/> object containing <paramref name="length"/> elements of type
\r
1857 <paramref name="elementType"/>.</para>
\r
1859 <exception cref="T:System.ArgumentNullException">
\r
1860 <paramref name="elementType"/> is <see langword="null"/>.</exception>
\r
1861 <exception cref="T:System.ArgumentException">
\r
1862 <paramref name="elementType"/> is not a valid <see cref="T:System.Type"/>.</exception>
\r
1863 <exception cref="T:System.ArgumentOutOfRangeException">
\r
1864 <paramref name="length"/> < 0.</exception>
\r
1866 <para>Reference-type elements will be set to <see langword="null"/>. Value-type elements will be set to zero,
\r
1867 except for <see cref="T:System.Boolean"/>
\r
1868 elements, which will be set to
\r
1869 <see langword="false"/>.</para>
\r
1871 <block subset="none" type="note">Unlike most classes, <see cref="T:System.Array"/> provides the <see cref="M:System.Array.CreateInstance(System.Type,System.Int32)"/> method, instead of public constructors, to allow
\r
1872 for late bound access.</block>
\r
1876 <para> The following example shows how to create and
\r
1877 initialize a one-dimensional <see cref="T:System.Array"/>.</para>
\r
1878 <code lang="C#">using System;
\r
1880 public class ArrayCreateInstanceExample
\r
1883 public static void Main()
\r
1886 Array intAry = Array.CreateInstance(typeof(int),5);
\r
1887 for (int i=intAry.GetLowerBound(0);i<=intAry.GetUpperBound(0);i++)
\r
1888 intAry.SetValue(i*3,i);
\r
1889 Console.Write("The values of the array are:");
\r
1890 foreach (int i in intAry)
\r
1891 Console.Write("{0} ",i);
\r
1897 <para>The output is</para>
\r
1899 <c>The values of the array are: 0 3 6 9 12</c>
\r
1903 <Excluded>0</Excluded>
\r
1905 <Member MemberName="CreateInstance">
\r
1906 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class System.Array CreateInstance(class System.Type elementType, int32[] lengths, int32[] lowerBounds)"/>
\r
1907 <MemberSignature Language="C#" Value="public static Array CreateInstance(Type elementType, int[] lengths, int[] lowerBounds);"/>
\r
1908 <MemberType>Method</MemberType>
\r
1910 <ReturnType>System.Array</ReturnType>
\r
1913 <Parameter Name="elementType" Type="System.Type"/>
\r
1914 <Parameter Name="lengths" Type="System.Int32[]"/>
\r
1915 <Parameter Name="lowerBounds" Type="System.Int32[]"/>
\r
1919 <para>Creates a multidimensional array whose element type is the specified <see cref="T:System.Type"/>, and dimension lengths and lower bounds, as specified.</para>
\r
1921 <param name="elementType">The <see cref="T:System.Type"/> of the elements contained in the new <see cref="T:System.Array"/> instance. </param>
\r
1922 <param name="lengths">A one-dimensional array of <see cref="T:System.Int32"/> objects that contains the size of each dimension of the new <see cref="T:System.Array"/> instance.</param>
\r
1923 <param name="lowerBounds">A one-dimensional array of <see cref="T:System.Int32"/> objects that contains the lower bound of each dimension of the new <see cref="T:System.Array"/> instance.</param>
\r
1925 <para>A new multidimensional <see cref="T:System.Array"/> whose element type is the specified <see cref="T:System.Type"/> and with
\r
1926 the specified length and lower bound for each dimension.</para>
\r
1928 <exception cref="T:System.ArgumentNullException">
\r
1930 <paramref name="elementType"/>, <paramref name="lengths"/>, or <paramref name="lowerBounds"/> is <see langword="null"/>. </para>
\r
1932 <exception cref="T:System.ArgumentException">
\r
1934 <paramref name="elementType"/> is not a valid <see cref="T:System.Type"/>.</para>
\r
1937 <paramref name="lengths"/>.Length = 0.</para>
\r
1938 <para> -or-</para>
\r
1940 <paramref name="lengths"/> and <paramref name="lowerBounds"/> do not contain the same number of elements.</para>
\r
1942 <exception cref="T:System.ArgumentOutOfRangeException">A value in <paramref name="lengths"/> is less than zero.</exception>
\r
1944 <para>The <paramref name="lengths"/> and <paramref name="lowerBounds"/>
\r
1945 are required to have the same number of elements. The number of elements in
\r
1946 <paramref name="lengths"/>
\r
1947 equals the number of dimensions in the new <see cref="T:System.Array"/> instance</para>
\r
1948 <para> Each element of <paramref name="lengths"/>
\r
1949 specifies the length of the corresponding dimension in the new <see cref="T:System.Array"/> instance.</para>
\r
1950 <para> Each element of <paramref name="lowerBounds"/> specifies the lower bound of the
\r
1951 corresponding dimension in the new <see cref="T:System.Array"/> instance.</para>
\r
1952 <para> Reference-type elements will be set to <see langword="null"/>. Value-type elements will be set to zero,
\r
1953 except for <see cref="T:System.Boolean"/>
\r
1954 elements, which will be set to
\r
1955 <see langword="false"/>.</para>
\r
1957 <block subset="none" type="note">Unlike most classes, <see cref="T:System.Array"/> provides the
\r
1958 <see cref="M:System.Array.CreateInstance(System.Type,System.Int32)"/> method, instead of public constructors, to allow
\r
1959 for late bound access.</block>
\r
1963 <para> The following example shows how to create and
\r
1964 initialize a multidimensional <see cref="T:System.Array"/>
\r
1965 with specified low bounds.</para>
\r
1969 public class MultiDimNonZeroBoundExample
\r
1971 public static void Main()
\r
1974 int[] indexAry = {4, 2, 3};
\r
1975 int[] lowboundAry = {3, 2, 1};
\r
1976 Array ary = Array.CreateInstance( typeof(int), indexAry, lowboundAry );
\r
1977 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++ )
\r
1979 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++ )
\r
1981 for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ )
\r
1983 ary.SetValue( (100*i + 10*j + k), i, j, k );
\r
1987 Console.WriteLine("The elements of the array are:");
\r
1988 for( i = ary.GetLowerBound(0); i <= ary.GetUpperBound(0); i++)
\r
1990 for( j = ary.GetLowerBound(1); j <= ary.GetUpperBound(1); j++)
\r
1992 for( k = ary.GetLowerBound(2); k <= ary.GetUpperBound(2); k++ )
\r
1994 Console.Write("{0, 3} ", ary.GetValue(i, j, k));
\r
1996 Console.WriteLine();
\r
1998 Console.WriteLine();
\r
2003 <para>The output is</para>
\r
2004 <code>The elements of the array are:
\r
2019 <Excluded>1</Excluded>
\r
2020 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
2022 <Member MemberName="Exists<T>">
\r
2023 <MemberSignature Language="ILAsm" Value=".method public hidebysig static bool Exists<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
2024 <MemberSignature Language="C#" Value="public static bool Exists<T>(T[] array, Predicate<T> match)"/>
\r
2025 <MemberType>Method</MemberType>
\r
2027 <ReturnType>System.Boolean</ReturnType>
\r
2030 <Parameter Name="array" Type="T[]"/>
\r
2031 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2035 <para>Determines whether the specified array contains any element that matches the conditions defined by the specified predicate.</para>
\r
2037 <param name="array">The array to search.</param>
\r
2038 <param name="match">
\r
2039 <para>The predicate that defines the conditions of the elements to search for.</para>
\r
2043 <see langword="true"/>, if the array contains one or more elements that match the conditions defined by the specified predicate; otherwise, <see langword="false"/>.</para>
\r
2045 <exception cref="T:System.ArgumentNullException">
\r
2046 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2048 <para>The predicate returns <see langword="true"/> if the object passed to it matches the delegate. Each element of <paramref name="array"/> is passed to the predicate in turn, and processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
2051 <Excluded>0</Excluded>
\r
2053 <Member MemberName="Find<T>">
\r
2054 <MemberSignature Language="ILAsm" Value=".method public hidebysig static !!0 Find<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
2055 <MemberSignature Language="C#" Value="public static T Find<T>(T[] array, Predicate<T> match)"/>
\r
2056 <MemberType>Method</MemberType>
\r
2058 <ReturnType>T</ReturnType>
\r
2061 <Parameter Name="array" Type="T[]"/>
\r
2062 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2066 <para>Searches for an element that matches the predicate, and returns the first occurrence within the entire array.</para>
\r
2068 <param name="array">The array to search.</param>
\r
2069 <param name="match">
\r
2070 <para>The predicate that defines the conditions of the element to search for.</para>
\r
2073 <para>The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type <paramref name="T"/>.</para>
\r
2075 <exception cref="T:System.ArgumentNullException">
\r
2076 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2078 <para>The elements of <paramref name="array"/> 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 <see langword="true"/>.</para>
\r
2081 <Excluded>0</Excluded>
\r
2083 <Member MemberName="FindAll<T>">
\r
2084 <MemberSignature Language="ILAsm" Value=".method public hidebysig static class !!0[] FindAll<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
2085 <MemberSignature Language="C#" Value="public static T[] FindAll<T>(T[] array, Predicate<T> match)"/>
\r
2086 <MemberType>Method</MemberType>
\r
2088 <ReturnType>T[]</ReturnType>
\r
2091 <Parameter Name="array" Type="T[]"/>
\r
2092 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2096 <para>Retrieves all the elements that match the conditions defined by the specified predicate.</para>
\r
2098 <param name="array">The array to search.</param>
\r
2099 <param name="match">
\r
2100 <para>The predicate that specifies the elements to search for.</para>
\r
2103 <para>An array containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty array.</para>
\r
2105 <exception cref="T:System.ArgumentNullException">
\r
2106 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2108 <para>The elements of <paramref name="array"/> are individually passed to the predicate, and those elements for which the predicate returns <see langword="true"/>, are saved in the returned array.</para>
\r
2111 <Excluded>0</Excluded>
\r
2113 <Member MemberName="FindIndex<T>">
\r
2114 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 FindIndex<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
2115 <MemberSignature Language="C#" Value="public static int FindIndex<T>(T[] array, Predicate<T> match)"/>
\r
2116 <MemberType>Method</MemberType>
\r
2118 <ReturnType>System.Int32</ReturnType>
\r
2121 <Parameter Name="array" Type="T[]"/>
\r
2122 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2126 <para>Searches for an element that matches the predicate, and returns the zero-based index of the first occurrence within the entire array.</para>
\r
2128 <param name="array">The array to search.</param>
\r
2129 <param name="match">
\r
2130 <para>The predicate that specifies the elements to search for.</para>
\r
2133 <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match"/>, if found; otherwise, -1.</para>
\r
2135 <exception cref="T:System.ArgumentNullException">
\r
2136 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2138 <para>The elements of <paramref name="array"/> 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 <see langword="true"/>.</para>
\r
2141 <Excluded>0</Excluded>
\r
2143 <Member MemberName="FindIndex<T>">
\r
2144 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 FindIndex<T>(!!0[] array, int32 startIndex, class System.Predicate`1<!!0> match)"/>
\r
2145 <MemberSignature Language="C#" Value="public static int FindIndex<T>(T[] array, int startIndex, Predicate<T> match)"/>
\r
2146 <MemberType>Method</MemberType>
\r
2148 <ReturnType>System.Int32</ReturnType>
\r
2151 <Parameter Name="array" Type="T[]"/>
\r
2152 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2153 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2157 <para>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.</para>
\r
2159 <param name="array">The array to search.</param>
\r
2160 <param name="startIndex">
\r
2161 <para>The zero-based starting index of the search.</para>
\r
2163 <param name="match">
\r
2164 <para>The predicate that specifies the elements to search for.</para>
\r
2167 <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match"/>, if found; otherwise, -1.</para>
\r
2169 <exception cref="T:System.ArgumentNullException">
\r
2170 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2171 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2172 <paramref name="startIndex"/> is less than zero or greater than <paramref name="array"/>
\r
2173 <see langword=".Length"/>.</exception>
\r
2175 <para>The elements of <paramref name="array"/> 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 <see langword="true"/>.</para>
\r
2178 <Excluded>0</Excluded>
\r
2180 <Member MemberName="FindIndex<T>">
\r
2181 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 FindIndex<T>(!!0[] array, int32 startIndex, int32 count, class System.Predicate`1<!!0> match)"/>
\r
2182 <MemberSignature Language="C#" Value="public static int FindIndex<T>(T[] array, int startIndex, int count, Predicate<T> match)"/>
\r
2183 <MemberType>Method</MemberType>
\r
2185 <ReturnType>System.Int32</ReturnType>
\r
2188 <Parameter Name="array" Type="T[]"/>
\r
2189 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2190 <Parameter Name="count" Type="System.Int32"/>
\r
2191 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2195 <para>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.</para>
\r
2197 <param name="array">The array to search.</param>
\r
2198 <param name="startIndex">
\r
2199 <para>The zero-based starting index of the search</para>
\r
2201 <param name="count">
\r
2202 <para>The number of consecutive elements to search.</para>
\r
2204 <param name="match">
\r
2205 <para>The predicate that specifies the elements to search for.</para>
\r
2208 <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match"/>, if found; otherwise, -1.</para>
\r
2210 <exception cref="T:System.ArgumentNullException">
\r
2211 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2212 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2214 <paramref name="startIndex"/> is less than zero.</para>
\r
2217 <paramref name="count"/> is less than zero.</para>
\r
2220 <paramref name="startIndex"/> + <paramref name="count"/> is greater than <paramref name="array"/>
\r
2221 <see langword=".Length"/>.</para>
\r
2224 <para>The elements of <paramref name="array"/> are individually passed to the predicate. The array is searched forward starting at the specified index and going for <paramref name="count"/> elements. Processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
2227 <Excluded>0</Excluded>
\r
2229 <Member MemberName="FindLast<T>">
\r
2230 <MemberSignature Language="ILAsm" Value=".method public hidebysig static !!0 FindLast<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
2231 <MemberSignature Language="C#" Value="public static T FindLast<T>(T[] array, Predicate<T> match)"/>
\r
2232 <MemberType>Method</MemberType>
\r
2234 <ReturnType>T</ReturnType>
\r
2237 <Parameter Name="array" Type="T[]"/>
\r
2238 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2242 <para>Searches for an element that matches the predicate, and returns the last occurrence within the entire array.</para>
\r
2244 <param name="array">The array to search.</param>
\r
2245 <param name="match">
\r
2246 <para>The predicate that specifies the elements to search for.</para>
\r
2249 <para>The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type <paramref name="T"/>.</para>
\r
2251 <exception cref="T:System.ArgumentNullException">
\r
2252 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2254 <para>The elements of <paramref name="array"/> 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.</para>
\r
2257 <Excluded>0</Excluded>
\r
2259 <Member MemberName="FindLastIndex<T>">
\r
2260 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 FindLastIndex<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
2261 <MemberSignature Language="C#" Value="public static int FindLastIndex<T>(T[] array, Predicate<T> match)"/>
\r
2262 <MemberType>Method</MemberType>
\r
2264 <ReturnType>System.Int32</ReturnType>
\r
2267 <Parameter Name="array" Type="T[]"/>
\r
2268 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2272 <para>Searches for an element that matches the predicate, and returns the zero-based index of the last occurrence within the entire array.</para>
\r
2274 <param name="array">The array to search.</param>
\r
2275 <param name="match">
\r
2276 <para>The predicate that specifies the elements to search for.</para>
\r
2279 <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match"/>, if found; otherwise, -1.</para>
\r
2281 <exception cref="T:System.ArgumentNullException">
\r
2282 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2284 <para>The elements of <paramref name="array"/> 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 <see langword="true"/>.</para>
\r
2287 <Excluded>0</Excluded>
\r
2289 <Member MemberName="FindLastIndex<T>">
\r
2290 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 FindLastIndex<T>(!!0[] array, int32 startIndex, class System.Predicate`1<!!0> match)"/>
\r
2291 <MemberSignature Language="C#" Value="public static int FindLastIndex<T>(T[] array, int startIndex, Predicate<T> match)"/>
\r
2292 <MemberType>Method</MemberType>
\r
2294 <ReturnType>System.Int32</ReturnType>
\r
2297 <Parameter Name="array" Type="T[]"/>
\r
2298 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2299 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2303 <para>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.</para>
\r
2305 <param name="array">The array to search.</param>
\r
2306 <param name="startIndex">
\r
2307 <para>The zero-based starting index of the backward search.</para>
\r
2309 <param name="match">
\r
2310 <para>The predicate that specifies the elements to search for.</para>
\r
2313 <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match"/>, if found; otherwise, -1.</para>
\r
2315 <exception cref="T:System.ArgumentNullException">
\r
2316 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2317 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2318 <paramref name="startIndex"/> is less than zero or greater than <paramref name="array"/>
\r
2319 <see langword=".Length"/>.</exception>
\r
2321 <para>The elements of <paramref name="array"/> 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 <see langword="true"/>.</para>
\r
2324 <Excluded>0</Excluded>
\r
2326 <Member MemberName="FindLastIndex<T>">
\r
2327 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 FindLastIndex<T>(!!0[] array, int32 startIndex, int32 count, class System.Predicate`1<!!0> match)"/>
\r
2328 <MemberSignature Language="C#" Value="public static int FindLastIndex<T>(T[] array, int startIndex, int count, Predicate<T> match)"/>
\r
2329 <MemberType>Method</MemberType>
\r
2331 <ReturnType>System.Int32</ReturnType>
\r
2334 <Parameter Name="array" Type="T[]"/>
\r
2335 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2336 <Parameter Name="count" Type="System.Int32"/>
\r
2337 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
2341 <para>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.</para>
\r
2343 <param name="array">The array to search.</param>
\r
2344 <param name="startIndex">
\r
2345 <para>The zero-based starting index of the backward search.</para>
\r
2347 <param name="count">
\r
2348 <para>The number of consecutive elements to search.</para>
\r
2350 <param name="match">
\r
2351 <para>The predicate that specifies the elements to search for.</para>
\r
2354 <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match"/>, if found; otherwise, -1.</para>
\r
2356 <exception cref="T:System.ArgumentNullException">
\r
2357 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
2358 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2360 <paramref name="startIndex"/> is less than zero or greater than <paramref name="array"/>
\r
2361 <see langword=".Length"/>.</para>
\r
2364 <paramref name="count"/> is less than zero.</para>
\r
2367 <paramref name="count"/> is greater than <paramref name="startIndex"/> + 1.</para>
\r
2370 <para>The elements of <paramref name="array"/> are individually passed to the predicate. The array is searched backward starting at the specified index and going for <paramref name="count"/> elements. Processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
2373 <Excluded>0</Excluded>
\r
2375 <Member MemberName="ForEach<T>">
\r
2376 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void ForEach<T>(!!0[] array, class System.Action`1<!!0> action)"/>
\r
2377 <MemberSignature Language="C#" Value="public static void ForEach<T>(T[] array, Action<T> action)"/>
\r
2378 <MemberType>Method</MemberType>
\r
2380 <ReturnType>System.Void</ReturnType>
\r
2383 <Parameter Name="array" Type="T[]"/>
\r
2384 <Parameter Name="action" Type="System.Action<T>"/>
\r
2388 <para>Performs the specified action on each element of the specified array.</para>
\r
2390 <param name="array">The array on whose elements the action is to be performed.</param>
\r
2391 <param name="action">
\r
2392 <para>The action to perform on each element of <paramref name="array"/>.</para>
\r
2395 <para>The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type <paramref name="T"/>.</para>
\r
2397 <exception cref="T:System.ArgumentNullException">
\r
2398 <paramref name="array"/> or <paramref name="action"/> is <see langword="null"/>.</exception>
\r
2400 <para>The elements of <paramref name="array"/> 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 <see langword="ForEach"/>. Execution stops if the action throws an exception.</para>
\r
2403 <Excluded>0</Excluded>
\r
2405 <Member MemberName="GetEnumerator">
\r
2406 <MemberSignature Language="ILAsm" Value=".method public hidebysig virtual class System.Collections.IEnumerator GetEnumerator()"/>
\r
2407 <MemberSignature Language="C#" Value="public virtual IEnumerator GetEnumerator();"/>
\r
2408 <MemberType>Method</MemberType>
\r
2410 <ReturnType>System.Collections.IEnumerator</ReturnType>
\r
2415 <para>Returns a <see cref="T:System.Collections.IEnumerator"/> for the current instance.</para>
\r
2418 <para>A <see cref="T:System.Collections.IEnumerator"/> for the current instance.</para>
\r
2421 <para>A <see cref="T:System.Collections.IEnumerator"/> grants read-access to the elements of a
\r
2422 <see cref="T:System.Array"/>.</para>
\r
2424 <block subset="none" type="note"> This method is
\r
2425 implemented to support the <see cref="T:System.Collections.IEnumerator"/> interface. For more information regarding the use of an
\r
2426 enumerator, see <see cref="T:System.Collections.IEnumerator"/>.</block>
\r
2428 <block subset="none" type="behaviors">
\r
2429 <para>Enumerators can be used to read the data in the collection, but they cannot be used to modify the underlying collection.</para>
\r
2430 <para> Initially, the enumerator is positioned before the
\r
2431 first element of the current instance. <see cref="M:System.Collections.IEnumerator.Reset"/> returns the enumerator to this
\r
2432 position. Therefore, after an enumerator is created or after a
\r
2433 <see cref="M:System.Collections.IEnumerator.Reset"/>, <see cref="M:System.Collections.IEnumerator.MoveNext"/> is required to be
\r
2434 called to advance the enumerator to the first element of the collection before
\r
2435 reading the value of <see cref="P:System.Collections.IEnumerator.Current"/>.</para>
\r
2437 <see cref="P:System.Collections.IEnumerator.Current"/> returns the same object until either
\r
2438 <see cref="M:System.Collections.IEnumerator.MoveNext"/> or
\r
2439 <see cref="M:System.Collections.IEnumerator.Reset"/> is called. <see cref="M:System.Collections.IEnumerator.MoveNext"/> sets <see cref="P:System.Collections.IEnumerator.Current"/> to the next element.</para>
\r
2440 <para>If <see cref="M:System.Collections.IEnumerator.MoveNext"/> passes the end of the collection, the enumerator is positioned after the last element in the collection and <see cref="M:System.Collections.IEnumerator.MoveNext"/> returns false. When the enumerator is at this position, subsequent calls to<see cref="M:System.Collections.IEnumerator.MoveNext"/> also return <see langword="false"/>. If the last call to <see cref="M:System.Collections.IEnumerator.MoveNext"/> returned <see langword="false"/>, <see cref="P:System.Collections.IEnumerator.Current"/> is unspecified. To set <see cref="P:System.Collections.IEnumerator.Current"/> to the first element of the collection again, you can call <see cref="M:System.Collections.IEnumerator.Reset"/> followed by <see cref="M:System.Collections.IEnumerator.MoveNext"/>.</para>
\r
2441 <para>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.</para>
\r
2442 <para>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.</para>
\r
2444 <block subset="none" type="default">
\r
2445 <para>Multidimensional arrays will be processed in Row-major form. </para>
\r
2447 <block subset="none" type="note"> For some
\r
2448 multidimensional <see cref="T:System.Array"/>
\r
2449 objects, it can be desirable for an enumerator to process them in Column-major form.</block>
\r
2453 <block subset="none" type="overrides">Override this
\r
2454 method to provide read-access to the current instance.</block>
\r
2457 <block subset="none" type="usage">Use this method
\r
2458 to iterate over the elements of the current instance.</block>
\r
2462 <para>This example demonstrates the <see cref="M:System.Array.GetEnumerator"/> method.</para>
\r
2463 <code lang="C#">using System;
\r
2464 using System.Collections;
\r
2465 public class ArrayGetEnumerator {
\r
2466 public static void Main() {
\r
2467 string[,] strAry = {{"1","one"}, {"2", "two"}, {"3", "three"}};
\r
2468 Console.Write( "The elements of the array are: " );
\r
2469 IEnumerator sEnum = strAry.GetEnumerator();
\r
2470 while ( sEnum.MoveNext() )
\r
2471 Console.Write( " {0}", sEnum.Current );
\r
2475 <para>The output is</para>
\r
2477 <para>The elements of the array are: 1 one 2 two 3 three</para>
\r
2481 <Excluded>0</Excluded>
\r
2483 <Member MemberName="GetLength">
\r
2484 <MemberSignature Language="ILAsm" Value=".method public hidebysig int32 GetLength(int32 dimension)"/>
\r
2485 <MemberSignature Language="C#" Value="public int GetLength(int dimension)"/>
\r
2486 <MemberType>Method</MemberType>
\r
2488 <ReturnType>System.Int32</ReturnType>
\r
2491 <Parameter Name="dimension" Type="System.Int32"/>
\r
2495 <para>Gets the number of elements in the specified dimension of the array.</para>
\r
2497 <param name="dimension">The zero-based dimension of the array whose length is to be determined.</param>
\r
2499 <para>The number of elements in the specified dimension of the array.</para>
\r
2501 <exception cref="T:System.IndexOutOfRangeException">
\r
2503 <paramref name="dimension"/> is less than zero.</para>
\r
2506 <paramref name="dimension"/> is equal to or greater than <see cref="P:System.Array.Rank"/>.</para>
\r
2509 <Excluded>1</Excluded>
\r
2510 <ExcludedLibrary>RuntimeInfrastructure</ExcludedLibrary>
\r
2512 <Member MemberName="GetLowerBound">
\r
2513 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 GetLowerBound(int32 dimension)"/>
\r
2514 <MemberSignature Language="C#" Value="public int GetLowerBound(int dimension);"/>
\r
2515 <MemberType>Method</MemberType>
\r
2517 <ReturnType>System.Int32</ReturnType>
\r
2520 <Parameter Name="dimension" Type="System.Int32"/>
\r
2524 <para>Returns the lower bound of the specified dimension in
\r
2525 the current instance.</para>
\r
2527 <param name="dimension">A <see cref="T:System.Int32"/> that contains the zero-based dimension of the current instance whose lower bound is to be determined.</param>
\r
2529 <para>A <see cref="T:System.Int32"/> that contains the lower bound of the specified dimension in the
\r
2530 current instance.</para>
\r
2532 <exception cref="T:System.IndexOutOfRangeException">
\r
2534 <paramref name="dimension"/> < 0.</para>
\r
2537 <paramref name="dimension"/> is equal to or greater than the <see cref="P:System.Array.Rank"/> property of the current instance.</para>
\r
2541 <block subset="none" type="note">For example,
\r
2542 <see cref="M:System.Array.GetLowerBound(System.Int32)"/> (0) returns the lower bound of the first
\r
2543 dimension of the current instance, and <see cref="M:System.Array.GetLowerBound(System.Int32)"/>(<see cref="P:System.Array.Rank"/> - 1) returns the lower bound of the last dimension of
\r
2544 the current instance.</block>
\r
2548 <Excluded>1</Excluded>
\r
2549 <ExcludedLibrary>RuntimeInfrastructure</ExcludedLibrary>
\r
2551 <Member MemberName="GetUpperBound">
\r
2552 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance int32 GetUpperBound(int32 dimension)"/>
\r
2553 <MemberSignature Language="C#" Value="public int GetUpperBound(int dimension);"/>
\r
2554 <MemberType>Method</MemberType>
\r
2556 <ReturnType>System.Int32</ReturnType>
\r
2559 <Parameter Name="dimension" Type="System.Int32"/>
\r
2563 <para>Returns the upper bound of the specified dimension in
\r
2564 the current instance.</para>
\r
2566 <param name="dimension">A <see cref="T:System.Int32"/> that contains the zero-based dimension of the current instance whose upper bound is to be determined.</param>
\r
2568 <para>A <see cref="T:System.Int32"/> that contains the upper bound of the specified dimension in the
\r
2569 current instance.</para>
\r
2571 <exception cref="T:System.IndexOutOfRangeException">
\r
2573 <paramref name="dimension"/> < 0.</para>
\r
2576 <paramref name="dimension"/> is equal to or greater than the <see cref="P:System.Array.Rank"/> property of the current instance.</para>
\r
2580 <block subset="none" type="note">For example, <see cref="M:System.Array.GetUpperBound(System.Int32)"/>
\r
2581 (0) returns the upper bound of the first dimension of the current
\r
2582 instance, and <see cref="M:System.Array.GetUpperBound(System.Int32)"/>(<see cref="P:System.Array.Rank"/> - 1) returns the upper bound of the last dimension
\r
2583 of the current instance.</block>
\r
2587 <Excluded>1</Excluded>
\r
2588 <ExcludedLibrary>RuntimeInfrastructure</ExcludedLibrary>
\r
2590 <Member MemberName="GetValue">
\r
2591 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance object GetValue(int32[] indices)"/>
\r
2592 <MemberSignature Language="C#" Value="public object GetValue(int[] indices);"/>
\r
2593 <MemberType>Method</MemberType>
\r
2595 <ReturnType>System.Object</ReturnType>
\r
2598 <Parameter Name="indices" Type="System.Int32[]"/>
\r
2602 <para>Gets the value at the specified position in the
\r
2603 current multidimensional instance.</para>
\r
2605 <param name="indices">A one-dimensional array of <see cref="T:System.Int32"/> objects that contains the indices that specify the position of the element in the current instance whose value to get.</param>
\r
2607 <para>A <see cref="T:System.Object"/> that contains the value at the specified position in the
\r
2608 current instance.</para>
\r
2610 <exception cref="T:System.ArgumentNullException">
\r
2611 <paramref name="indices"/> is <see langword="null"/>.</exception>
\r
2612 <exception cref="T:System.ArgumentException">The number of dimensions in the current instance is not equal to the number of elements in <paramref name="indices"/>.</exception>
\r
2613 <exception cref="T:System.IndexOutOfRangeException">
\r
2614 <para>At least one element in <paramref name="indices"/> is outside the range of valid indices for the corresponding dimension of the current instance.</para>
\r
2617 <para>The number of elements in <paramref name="indices"/> is required to be equal to the number of
\r
2618 dimensions in the current instance. All elements in <paramref name="indices"/> collectively specify the position of the
\r
2619 desired element in the current instance.</para>
\r
2621 <block subset="none" type="note">Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and
\r
2622 <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine whether any of the values in
\r
2623 <paramref name="indices"/> are out of
\r
2628 <Excluded>1</Excluded>
\r
2629 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
2631 <Member MemberName="GetValue">
\r
2632 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance object GetValue(int32 index)"/>
\r
2633 <MemberSignature Language="C#" Value="public object GetValue(int index);"/>
\r
2634 <MemberType>Method</MemberType>
\r
2636 <ReturnType>System.Object</ReturnType>
\r
2639 <Parameter Name="index" Type="System.Int32"/>
\r
2643 <para> Gets the value at the specified position in the current one-dimensional
\r
2646 <param name="index">A <see cref="T:System.Int32"/> that contains the position of the value to get from the current instance.</param>
\r
2648 <para>A <see cref="T:System.Object"/> that contains the value at the specified position in the current
\r
2651 <exception cref="T:System.ArgumentException">The current instance has more than one dimension.</exception>
\r
2652 <exception cref="T:System.IndexOutOfRangeException">
\r
2654 <paramref name="index"/> is outside the range of valid indices for the current instance.</para>
\r
2658 <block subset="none" type="note">Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and
\r
2659 <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine
\r
2660 whether <paramref name="index"/> is out of bounds.</block>
\r
2664 <para>This example demonstrates the <see cref="M:System.Array.GetValue(System.Int32[])"/> method.</para>
\r
2665 <code lang="C#">using System;
\r
2666 public class ArrayGetValueExample {
\r
2667 public static void Main() {
\r
2668 String[] strAry = { "one", "two", "three", "four", "five" };
\r
2669 Console.Write( "The elements of the array are: " );
\r
2670 for( int i = 0; i < strAry.Length; i++ )
\r
2671 Console.Write( " '{0}' ", strAry.GetValue( i ) );
\r
2675 <para>The output is</para>
\r
2678 of the array are: 'one' 'two' 'three' 'four' 'five'</c>
\r
2682 <Excluded>0</Excluded>
\r
2684 <Member MemberName="GetValue">
\r
2685 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance object GetValue(int32 index1, int32 index2)"/>
\r
2686 <MemberSignature Language="C#" Value="public object GetValue(int index1, int index2);"/>
\r
2687 <MemberType>Method</MemberType>
\r
2689 <ReturnType>System.Object</ReturnType>
\r
2692 <Parameter Name="index1" Type="System.Int32"/>
\r
2693 <Parameter Name="index2" Type="System.Int32"/>
\r
2697 <para>Gets the value at the specified position in the current
\r
2698 two-dimensional instance.</para>
\r
2700 <param name="index1">A <see cref="T:System.Int32"/> that contains the first-dimension index of the element in the current instance to get.</param>
\r
2701 <param name="index2">A <see cref="T:System.Int32"/> that contains the second-dimension index of the element in the current instance to get.</param>
\r
2703 <para>A <see cref="T:System.Object"/> that contains the value at the specified position in the current
\r
2706 <exception cref="T:System.ArgumentException">The current instance does not have exactly two dimensions.</exception>
\r
2707 <exception cref="T:System.IndexOutOfRangeException">At least one of <paramref name="index1"/> or <paramref name="index2"/> is outside the range of valid indexes for the corresponding dimension of the current instance.</exception>
\r
2710 <block subset="none" type="note">Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and
\r
2711 <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine
\r
2712 whether any of the indices are out of bounds.</block>
\r
2716 <Excluded>1</Excluded>
\r
2717 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
2719 <Member MemberName="GetValue">
\r
2720 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance object GetValue(int32 index1, int32 index2, int32 index3)"/>
\r
2721 <MemberSignature Language="C#" Value="public object GetValue(int index1, int index2, int index3);"/>
\r
2722 <MemberType>Method</MemberType>
\r
2724 <ReturnType>System.Object</ReturnType>
\r
2727 <Parameter Name="index1" Type="System.Int32"/>
\r
2728 <Parameter Name="index2" Type="System.Int32"/>
\r
2729 <Parameter Name="index3" Type="System.Int32"/>
\r
2733 <para>Gets the value at the specified position in the
\r
2734 current three-dimensional instance.</para>
\r
2736 <param name="index1">A <see cref="T:System.Int32"/> that contains the first-dimension index of the element in the current instance to get. </param>
\r
2737 <param name="index2">A <see cref="T:System.Int32"/> that contains the second-dimension index of the element in the current instance to get. </param>
\r
2738 <param name="index3">A <see cref="T:System.Int32"/> that contains the third-dimension index of the element in the current instance to get. </param>
\r
2740 <para>A <see cref="T:System.Object"/> that contains the value at the specified position in the
\r
2741 current instance.</para>
\r
2743 <exception cref="T:System.ArgumentException">The current instance does not have exactly three dimensions.</exception>
\r
2744 <exception cref="T:System.IndexOutOfRangeException">
\r
2745 <para>At least one of<paramref name="index1"/> or <paramref name="index2"/> or <paramref name="index3"/> is outside the range of valid indexes for the corresponding dimension of the current instance.</para>
\r
2749 <block subset="none" type="note">Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and
\r
2750 <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine
\r
2751 whether any of the indices are out of bounds.</block>
\r
2755 <Excluded>1</Excluded>
\r
2756 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
2758 <Member MemberName="IndexOf">
\r
2759 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 IndexOf(class System.Array array, object value, int32 startIndex, int32 count)"/>
\r
2760 <MemberSignature Language="C#" Value="public static int IndexOf(Array array, object value, int startIndex, int count);"/>
\r
2761 <MemberType>Method</MemberType>
\r
2763 <ReturnType>System.Int32</ReturnType>
\r
2766 <Parameter Name="array" Type="System.Array"/>
\r
2767 <Parameter Name="value" Type="System.Object"/>
\r
2768 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2769 <Parameter Name="count" Type="System.Int32"/>
\r
2773 <para>Searches the specified one-dimensional <see cref="T:System.Array"/>, returning the index of the first
\r
2774 occurrence of the specified <see cref="T:System.Object"/> in the specified range.</para>
\r
2776 <param name="array">A one-dimensional <see cref="T:System.Array"/> to search.</param>
\r
2777 <param name="value">A <see cref="T:System.Object"/> to locate in <paramref name="array"/>.</param>
\r
2778 <param name="startIndex">A <see cref="T:System.Int32"/> that contains the index at which searching starts. </param>
\r
2779 <param name="count">A <see cref="T:System.Int32"/> that contains the number of elements to search, beginning with <paramref name="startIndex"/>.</param>
\r
2781 <para>A <see cref="T:System.Int32"/> containing the index of the first occurrence of <paramref name="value"/> in
\r
2782 <paramref name="array"/>, within the range <paramref name="startIndex"/> through <paramref name="startIndex"/>
\r
2783 + <paramref name="count"/>- 1, if found; otherwise,
\r
2784 <paramref name="array"/>.GetLowerBound(0) - 1.
\r
2785 <block subset="none" type="note"> For a vector, if <paramref name="value"/> is not
\r
2786 found, the return value will be -1. This provides the caller with a standard code for the failed search.</block>
\r
2789 <exception cref="T:System.ArgumentNullException">
\r
2791 <paramref name="array"/> is <see langword="null"/>.</para>
\r
2793 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2795 <paramref name="startIndex"/> is less than <paramref name="array"/>
\r
2796 <see langword=".GetLowerBound(0)"/>.</para>
\r
2799 <paramref name="count"/> is less than zero.</para>
\r
2802 <paramref name="startIndex"/> + <paramref name="count"/> is greater than <paramref name="array"/>
\r
2803 <see langword=".GetLowerBound(0)"/> + <paramref name="array"/>
\r
2804 <see langword=".Length"/>.</para>
\r
2806 <exception cref="T:System.RankException">
\r
2807 <paramref name="array"/> has more than one dimension.</exception>
\r
2809 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>.</para>
\r
2812 <Excluded>0</Excluded>
\r
2814 <Member MemberName="IndexOf">
\r
2815 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 IndexOf(class System.Array array, object value, int32 startIndex)"/>
\r
2816 <MemberSignature Language="C#" Value="public static int IndexOf(Array array, object value, int startIndex);"/>
\r
2817 <MemberType>Method</MemberType>
\r
2819 <ReturnType>System.Int32</ReturnType>
\r
2822 <Parameter Name="array" Type="System.Array"/>
\r
2823 <Parameter Name="value" Type="System.Object"/>
\r
2824 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2828 <para>Searches the specified one-dimensional <see cref="T:System.Array"/>, returning the index of the first
\r
2829 occurrence of the specified <see cref="T:System.Object"/> between the specified index and the last element.</para>
\r
2831 <param name="array">A one-dimensional <see cref="T:System.Array"/> to search.</param>
\r
2832 <param name="value">A <see cref="T:System.Object"/> to locate in <paramref name="array"/>.</param>
\r
2833 <param name="startIndex">A <see cref="T:System.Int32"/> that contains the index at which searching starts.</param>
\r
2835 <para>A <see cref="T:System.Int32"/> containing the index of the first occurrence of <paramref name="value"/> in
\r
2836 <paramref name="array"/>, within the range <paramref name="startIndex"/> through the last element of
\r
2837 <paramref name="array"/>, if found; otherwise,
\r
2838 <paramref name="array"/>.GetLowerBound(0) - 1.
\r
2839 <block subset="none" type="note"> For a vector, if <paramref name="value"/> is not
\r
2840 found, the return value will be -1. This provides the caller with a standard code for the failed search.</block>
\r
2843 <exception cref="T:System.ArgumentNullException">
\r
2845 <paramref name="array"/> is <see langword="null"/>. </para>
\r
2847 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2849 <paramref name="startIndex"/> is less than <paramref name="array"/>
\r
2850 <see langword=".GetLowerBound(0)"/> or greater than <paramref name="array"/>
\r
2851 <see langword=".GetLowerBound(0)"/> + <paramref name="array"/>
\r
2852 <see langword=".Length"/>.</para>
\r
2854 <exception cref="T:System.RankException">
\r
2855 <paramref name="array"/> has more than one dimension.</exception>
\r
2857 <para>This version of <see cref="M:System.Array.IndexOf(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.IndexOf(System.Array,System.Object)"/> (<paramref name="array"/>, <paramref name="value"/> ,
\r
2858 <paramref name="startIndex"/>, (<paramref name="array"/>.Length - <paramref name="startIndex"/>+<paramref name="array"/>.GetLowerBound(0))).</para>
\r
2859 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>.</para>
\r
2862 <Excluded>0</Excluded>
\r
2864 <Member MemberName="IndexOf">
\r
2865 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 IndexOf(class System.Array array, object value)"/>
\r
2866 <MemberSignature Language="C#" Value="public static int IndexOf(Array array, object value);"/>
\r
2867 <MemberType>Method</MemberType>
\r
2869 <ReturnType>System.Int32</ReturnType>
\r
2872 <Parameter Name="array" Type="System.Array"/>
\r
2873 <Parameter Name="value" Type="System.Object"/>
\r
2877 <para>Searches the specified one-dimensional <see cref="T:System.Array"/>, returning the
\r
2878 index of the first occurrence of the specified <see cref="T:System.Object"/>.</para>
\r
2880 <param name="array">A one-dimensional <see cref="T:System.Array"/> to search.</param>
\r
2881 <param name="value">A <see cref="T:System.Object"/> to locate in <paramref name="array"/>.</param>
\r
2883 <para>A <see cref="T:System.Int32"/> containing the index of the first occurrence of <paramref name="value"/> in
\r
2884 <paramref name="array"/>, if found; otherwise, <paramref name="array"/>.GetLowerBound(0) - 1. <block subset="none" type="note"> For a vector, if <paramref name="value"/> is not
\r
2885 found, the return value will be -1. This provides the caller with a standard code for a failed search.</block>
\r
2888 <exception cref="T:System.ArgumentNullException">
\r
2889 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
2890 <exception cref="T:System.RankException">
\r
2891 <paramref name="array"/> has more than one dimension.</exception>
\r
2893 <para>This version of <see cref="M:System.Array.IndexOf(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.IndexOf(System.Array,System.Object)"/>(<paramref name="array"/>, <paramref name="value"/>, <paramref name="array"/>.GetLowerBound(0),<paramref name="array"/>.Length).</para>
\r
2894 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>.</para>
\r
2897 <para>The following example demonstrates the <see cref="M:System.Array.IndexOf(System.Array,System.Object)"/>
\r
2899 <code lang="C#">using System;
\r
2900 public class ArrayIndexOfExample {
\r
2901 public static void Main() {
\r
2902 int[] intAry = { 0, 1, 2, 0, 1 };
\r
2903 Console.Write( "The values of the array are: " );
\r
2904 foreach( int i in intAry )
\r
2905 Console.Write( "{0,5}", i );
\r
2906 Console.WriteLine();
\r
2907 int j = Array.IndexOf( intAry, 1 );
\r
2908 Console.WriteLine( "The first occurrence of 1 is at index {0}", j );
\r
2912 <para> The output is</para>
\r
2914 <para>The values of the array are: 0 1 2 0 1</para>
\r
2915 <para>The first occurrence of 1 is at index 1</para>
\r
2919 <Excluded>0</Excluded>
\r
2921 <Member MemberName="IndexOf<T>">
\r
2922 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 IndexOf<T>(!!0[] array, !!0 value, int32 startIndex, int32 count)"/>
\r
2923 <MemberSignature Language="C#" Value="public static int IndexOf<T>(T[] array, T value, int startIndex, int count)"/>
\r
2924 <MemberType>Method</MemberType>
\r
2926 <ReturnType>System.Int32</ReturnType>
\r
2929 <Parameter Name="array" Type="T[]"/>
\r
2930 <Parameter Name="value" Type="T"/>
\r
2931 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2932 <Parameter Name="count" Type="System.Int32"/>
\r
2936 <para>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.</para>
\r
2938 <param name="array">The array to search.</param>
\r
2939 <param name="value">The value to locate.</param>
\r
2940 <param name="startIndex">The zero-based starting index of the search.</param>
\r
2941 <param name="count">The number of consecutive elements to search.</param>
\r
2943 <para>The zero-based index of the first occurrence of <paramref name="value"/> within the range of elements in
\r
2944 <paramref name="array"/> that starts at
\r
2945 <paramref name="startIndex"/> and contains the number of elements specified in <paramref name="count"/>
\r
2946 , if found; otherwise, -1.</para>
\r
2948 <exception cref="T:System.ArgumentNullException">
\r
2950 <paramref name="array"/> is <see langword="null"/>.</para>
\r
2952 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2954 <paramref name="startIndex"/> is less than zero.</para>
\r
2957 <paramref name="count"/> is less than zero.</para>
\r
2960 <paramref name="startIndex"/> + <paramref name="count"/> is greater than <see cref="P:System.Array.Length"/>.</para>
\r
2963 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>. The array is searched forward starting at <paramref name="startIndex"/> and ending at <paramref name="startIndex"/> + <paramref name="count"/> - 1. Processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
2966 <Excluded>0</Excluded>
\r
2968 <Member MemberName="IndexOf<T>">
\r
2969 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 IndexOf<T>(!!0[] array, !!0 value, int32 startIndex)"/>
\r
2970 <MemberSignature Language="C#" Value="public static int IndexOf<T>(T[] array, T value, int startIndex)"/>
\r
2971 <MemberType>Method</MemberType>
\r
2973 <ReturnType>System.Int32</ReturnType>
\r
2976 <Parameter Name="array" Type="T[]"/>
\r
2977 <Parameter Name="value" Type="T"/>
\r
2978 <Parameter Name="startIndex" Type="System.Int32"/>
\r
2982 <para>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.</para>
\r
2984 <param name="array">The array to search.</param>
\r
2985 <param name="value">The value to locate.</param>
\r
2986 <param name="startIndex">The zero-based starting index of the search.</param>
\r
2988 <para>The zero-based index of the first occurrence of <paramref name="value"/> within the range of elements in
\r
2989 <paramref name="array"/> that extends from
\r
2990 <paramref name="startIndex"/> to the last element, if found; otherwise, -1. If <paramref name="startIndex"/> is equal to the length of the array, -1 is returned.</para>
\r
2992 <exception cref="T:System.ArgumentNullException">
\r
2994 <paramref name="array"/> is <see langword="null"/>.</para>
\r
2996 <exception cref="T:System.ArgumentOutOfRangeException">
\r
2998 <paramref name="startIndex"/> is less than zero or greater than <paramref name="array"/>
\r
2999 <see langword=".Length"/>.</para>
\r
3002 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>. The array is searched forward starting at <paramref name="startIndex"/> and ending at the last element. Processing is stopped when the predicate returns <see langword="true"/>. </para>
\r
3005 <Excluded>0</Excluded>
\r
3007 <Member MemberName="IndexOf<T>">
\r
3008 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 IndexOf<T>(!!0[] array, !!0 value)"/>
\r
3009 <MemberSignature Language="C#" Value="public static int IndexOf<T>(T[] array, T value)"/>
\r
3010 <MemberType>Method</MemberType>
\r
3012 <ReturnType>System.Int32</ReturnType>
\r
3015 <Parameter Name="array" Type="T[]"/>
\r
3016 <Parameter Name="value" Type="T"/>
\r
3020 <para>Searches the specified array, returning the index of the first occurrence of the specified value.</para>
\r
3022 <param name="array">The array to search.</param>
\r
3023 <param name="value">The value to locate.</param>
\r
3025 <para>The zero-based index of the first occurrence of <paramref name="value"/> in
\r
3026 <paramref name="array"/>, if found; otherwise, - 1.</para>
\r
3028 <exception cref="T:System.ArgumentNullException">
\r
3030 <paramref name="array"/> is <see langword="null"/>.</para>
\r
3033 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>. The array is searched forward starting at the first element and ending at the last element. Processing is stopped when the predicate returns <see langword="true"/>. </para>
\r
3036 <Excluded>0</Excluded>
\r
3038 <Member MemberName="Initialize">
\r
3039 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void Initialize()"/>
\r
3040 <MemberSignature Language="C#" Value="public void Initialize();"/>
\r
3041 <MemberType>Method</MemberType>
\r
3043 <ReturnType>System.Void</ReturnType>
\r
3048 <para>Initializes every element of the current instance of
\r
3049 value-type objects by calling the
\r
3050 default constructor of that value type.</para>
\r
3053 <para> This method cannot be used on reference-type arrays.</para>
\r
3054 <para>If the current instance is not a value-type <see cref="T:System.Array"/> or if the value type does not have a default
\r
3055 constructor, the current instance is not modified.</para>
\r
3056 <para>The current instance can have any lower bound and any number of dimensions.</para>
\r
3058 <block subset="none" type="note">This method can be used only
\r
3059 on value types that have constructors. </block>
\r
3063 <Excluded>1</Excluded>
\r
3064 <ExcludedLibrary>RuntimeInfrastructure</ExcludedLibrary>
\r
3066 <Member MemberName="IsFixedSize">
\r
3067 <MemberSignature Language="ILAsm" Value=".property public bool IsFixedSize { public hidebysig virtual abstract specialname bool get_IsFixedSize() }"/>
\r
3068 <MemberSignature Language="C#" Value="public bool IsFixedSize { get; }"/>
\r
3069 <MemberType>Property</MemberType>
\r
3071 <ReturnType>System.Boolean</ReturnType>
\r
3075 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.IsFixedSize"/>.]</summary>
\r
3077 <Excluded>0</Excluded>
\r
3079 <Member MemberName="IsReadOnly">
\r
3080 <MemberSignature Language="ILAsm" Value=".property public bool IsReadOnly { public hidebysig virtual abstract specialname bool get_IsReadOnly() }"/>
\r
3081 <MemberSignature Language="C#" Value="public bool IsReadOnly { get; }"/>
\r
3082 <MemberType>Property</MemberType>
\r
3084 <ReturnType>System.Boolean</ReturnType>
\r
3088 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.IsReadOnly"/>.]</summary>
\r
3090 <Excluded>0</Excluded>
\r
3092 <Member MemberName="IsSynchronized">
\r
3093 <MemberSignature Language="ILAsm" Value="property public bool IsSynchronized { public hidebysig virtual abstract specialname bool get_IsSynchronized() }"/>
\r
3094 <MemberSignature Language="C#" Value="public bool IsSynchronized { get; }"/>
\r
3095 <MemberType>Property</MemberType>
\r
3097 <ReturnType>System.Boolean</ReturnType>
\r
3101 <summary>Implemented to support the <see cref="T:System.Collections.ICollection"/> interface. [Note: For more information, see <see cref="M:System.Collections.ICollection.IsSynchronized"/>.]</summary>
\r
3103 <Excluded>0</Excluded>
\r
3105 <Member MemberName="LastIndexOf">
\r
3106 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 LastIndexOf(class System.Array array, object value, int32 startIndex, int32 count)"/>
\r
3107 <MemberSignature Language="C#" Value="public static int LastIndexOf(Array array, object value, int startIndex, int count);"/>
\r
3108 <MemberType>Method</MemberType>
\r
3110 <ReturnType>System.Int32</ReturnType>
\r
3113 <Parameter Name="array" Type="System.Array"/>
\r
3114 <Parameter Name="value" Type="System.Object"/>
\r
3115 <Parameter Name="startIndex" Type="System.Int32"/>
\r
3116 <Parameter Name="count" Type="System.Int32"/>
\r
3120 <para> Searches the specified one-dimensional <see cref="T:System.Array"/>, returning the index of the last
\r
3121 occurrence of the specified <see cref="T:System.Object"/> in the specified range.</para>
\r
3123 <param name="array">A one-dimensional <see cref="T:System.Array"/> to search.</param>
\r
3124 <param name="value">A <see cref="T:System.Object"/> to locate in <paramref name="array"/>.</param>
\r
3125 <param name="startIndex">A <see cref="T:System.Int32"/> that contains the index at which searching starts. </param>
\r
3126 <param name="count">A <see cref="T:System.Int32"/> that contains the number of elements to search, beginning with <paramref name="startIndex"/> . </param>
\r
3128 <para>A <see cref="T:System.Int32"/> containing the index of the last occurrence of <paramref name="value"/> in
\r
3129 <paramref name="array"/>, within the range <paramref name="startIndex"/> through
\r
3130 <paramref name="startIndex"/> - <paramref name="count"/> + 1, if found; otherwise,
\r
3131 <paramref name="array"/>.GetLowerBound(0) - 1.
\r
3132 <block subset="none" type="note"> For a vector, if <paramref name="value"/> is not
\r
3133 found, the return value will be -1. This provides the caller with a standard code for the failed search.</block>
\r
3136 <exception cref="T:System.ArgumentNullException">
\r
3138 <paramref name="array"/> is <see langword="null"/>.</para>
\r
3140 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3142 <paramref name="startIndex"/> is outside the range of valid indices for <paramref name="array"/>.</para>
\r
3145 <paramref name="count"/> < 0.</para>
\r
3148 <paramref name="count"/> is greater than <paramref name="startIndex"/> + 1.</para>
\r
3150 <exception cref="T:System.RankException">
\r
3151 <paramref name="array"/> has more than one dimension.</exception>
\r
3153 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>.</para>
\r
3156 <Excluded>0</Excluded>
\r
3158 <Member MemberName="LastIndexOf">
\r
3159 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 LastIndexOf(class System.Array array, object value, int32 startIndex)"/>
\r
3160 <MemberSignature Language="C#" Value="public static int LastIndexOf(Array array, object value, int startIndex);"/>
\r
3161 <MemberType>Method</MemberType>
\r
3163 <ReturnType>System.Int32</ReturnType>
\r
3166 <Parameter Name="array" Type="System.Array"/>
\r
3167 <Parameter Name="value" Type="System.Object"/>
\r
3168 <Parameter Name="startIndex" Type="System.Int32"/>
\r
3172 <para> Searches the specified one-dimensional <see cref="T:System.Array"/>, returning the index of the last
\r
3173 occurrence of the specified <see cref="T:System.Object"/> between the specified index and the first element.</para>
\r
3175 <param name="array">A one-dimensional <see cref="T:System.Array"/> to search.</param>
\r
3176 <param name="value">A <see cref="T:System.Object"/> to locate in <paramref name="array"/>.</param>
\r
3177 <param name="startIndex">A <see cref="T:System.Int32"/> that contains the index at which searching starts.</param>
\r
3179 <para>A <see cref="T:System.Int32"/> containing the index of the last occurrence of <paramref name="value"/> in the range
\r
3180 <paramref name="startIndex"/> through the lower bound of <paramref name="array"/>, if found; otherwise,
\r
3181 <paramref name="array"/>.GetLowerBound(0) - 1. <block subset="none" type="note"> For a vector, if <paramref name="value"/> is not found, the return value will
\r
3182 be -1. This provides the caller with a standard code for the failed
\r
3186 <exception cref="T:System.ArgumentNullException">
\r
3188 <paramref name="array"/> is <see langword="null"/>.</para>
\r
3190 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3192 <paramref name="startIndex"/> is outside the range of valid indices for <paramref name="array"/>.</para>
\r
3194 <exception cref="T:System.RankException">
\r
3195 <paramref name="array"/> has more than one dimension.</exception>
\r
3197 <para>This version of <see cref="M:System.Array.LastIndexOf(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.LastIndexOf(System.Array,System.Object)"/>( <paramref name="array"/>, <paramref name="value"/>, <paramref name="startIndex"/>,<paramref name="startIndex"/>+ 1 -<paramref name="array"/>.GetLowerBound(0)).</para>
\r
3198 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>.</para>
\r
3201 <Excluded>0</Excluded>
\r
3203 <Member MemberName="LastIndexOf">
\r
3204 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 LastIndexOf(class System.Array array, object value)"/>
\r
3205 <MemberSignature Language="C#" Value="public static int LastIndexOf(Array array, object value);"/>
\r
3206 <MemberType>Method</MemberType>
\r
3208 <ReturnType>System.Int32</ReturnType>
\r
3211 <Parameter Name="array" Type="System.Array"/>
\r
3212 <Parameter Name="value" Type="System.Object"/>
\r
3216 <para> Searches the specified one-dimensional <see cref="T:System.Array"/>, returning the index of the last
\r
3217 occurrence of the specified <see cref="T:System.Object"/>.</para>
\r
3219 <param name="array">A one-dimensional <see cref="T:System.Array"/> to search.</param>
\r
3220 <param name="value">A <see cref="T:System.Object"/> to locate in <paramref name="array"/>.</param>
\r
3222 <para>A <see cref="T:System.Int32"/> containing the index of the last occurrence in <paramref name="array"/> of
\r
3223 <paramref name="value"/>, if found; otherwise,
\r
3224 <paramref name="array"/>.GetLowerBound(0) - 1.
\r
3225 <block subset="none" type="note"> For a vector, if <paramref name="value"/> is not
\r
3226 found, the return value will be -1. This provides the caller with a standard code for the failed search.</block>
\r
3229 <exception cref="T:System.ArgumentNullException">
\r
3230 <paramref name="array"/> is <see langword="null"/> . </exception>
\r
3231 <exception cref="T:System.RankException">
\r
3232 <paramref name="array"/> has more than one dimension.</exception>
\r
3234 <para>This version of <see cref="M:System.Array.LastIndexOf(System.Array,System.Object)"/> is equivalent to <see cref="M:System.Array.LastIndexOf(System.Array,System.Object)"/>(<paramref name="array"/>, <paramref name="value"/>, (<paramref name="array"/>.GetLowerBound(0) + <paramref name="array"/>.Length - 1), <paramref name="array"/>.Length).</para>
\r
3235 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>.</para>
\r
3238 <para>The following example demonstrates the <see cref="M:System.Array.LastIndexOf(System.Array,System.Object)"/> method.</para>
\r
3239 <code lang="C#">using System;
\r
3241 public class ArrayLastIndexOfExample {
\r
3243 public static void Main() {
\r
3244 int[] intAry = { 0, 1, 2, 0, 1 };
\r
3245 Console.Write( "The values of the array are: ");
\r
3246 foreach( int i in intAry )
\r
3247 Console.Write( "{0,5}", i );
\r
3248 Console.WriteLine();
\r
3249 int j = Array.LastIndexOf( intAry, 1 );
\r
3250 Console.WriteLine( "The last occurrence of 1 is at index {0}", j );
\r
3254 <para> The output is</para>
\r
3256 <para>The values of the array are: 0 1 2 0 1</para>
\r
3257 <para>The last occurrence of 1 is at index 4</para>
\r
3261 <Excluded>0</Excluded>
\r
3263 <Member MemberName="LastIndexOf<T>">
\r
3264 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 LastIndexOf<T>(!!0[] array, !!0 value, int32 startIndex, int32 count)"/>
\r
3265 <MemberSignature Language="C#" Value="public static int LastIndexOf<T>(T[] array, T value, int startIndex, int count)"/>
\r
3266 <MemberType>Method</MemberType>
\r
3268 <ReturnType>System.Int32</ReturnType>
\r
3271 <Parameter Name="array" Type="T[]"/>
\r
3272 <Parameter Name="value" Type="T"/>
\r
3273 <Parameter Name="startIndex" Type="System.Int32"/>
\r
3274 <Parameter Name="count" Type="System.Int32"/>
\r
3278 <para>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.</para>
\r
3280 <param name="array">The array to search.</param>
\r
3281 <param name="value">The value to locate.</param>
\r
3282 <param name="startIndex">The zero-based starting index of the search.</param>
\r
3283 <param name="count">The number of consecutive elements to search.</param>
\r
3285 <para>The zero-based index of the last occurrence of <paramref name="value"/> within the range of elements in
\r
3286 <paramref name="array"/> that ends at
\r
3287 <paramref name="startIndex"/> and contains the number of elements specified in <paramref name="count"/>
\r
3288 , if found; otherwise, -1.</para>
\r
3290 <exception cref="T:System.ArgumentNullException">
\r
3292 <paramref name="array"/> is <see langword="null"/>.</para>
\r
3294 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3296 <paramref name="startIndex"/> is outside the range of valid indices for <paramref name="array"/>.</para>
\r
3299 <paramref name="count"/> is less than zero.</para>
\r
3302 <paramref name="count"/> is greater than <paramref name="startIndex"/> + 1.</para>
\r
3305 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>. The array is searched backward starting at <paramref name="startIndex"/> and going for count elements. Processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
3308 <Excluded>0</Excluded>
\r
3310 <Member MemberName="LastIndexOf<T>">
\r
3311 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 LastIndexOf<T>(!!0[] array, !!0 value, int32 startIndex)"/>
\r
3312 <MemberSignature Language="C#" Value="public static int LastIndexOf<T>(T[] array, T value, int startIndex)"/>
\r
3313 <MemberType>Method</MemberType>
\r
3315 <ReturnType>System.Int32</ReturnType>
\r
3318 <Parameter Name="array" Type="T[]"/>
\r
3319 <Parameter Name="value" Type="T"/>
\r
3320 <Parameter Name="startIndex" Type="System.Int32"/>
\r
3324 <para>Searches the specified array backwards, returning the index of the last occurrence of the specified array, starting at the specified index.</para>
\r
3326 <param name="array">The array to search.</param>
\r
3327 <param name="value">The value to locate.</param>
\r
3328 <param name="startIndex">The zero-based starting index of the search.</param>
\r
3330 <para>The zero-based index of the last occurrence of <paramref name="value"/> within the range of elements in
\r
3331 <paramref name="array"/> that extends from
\r
3332 <paramref name="startIndex"/> to the first element, if found; otherwise, -1.</para>
\r
3334 <exception cref="T:System.ArgumentNullException">
\r
3336 <paramref name="array"/> is <see langword="null"/>.</para>
\r
3338 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3340 <paramref name="startIndex"/> is outside the range of valid indices for <paramref name="array"/>.</para>
\r
3343 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>. The array is searched backward starting at <paramref name="startIndex"/> and ending at the first element. Processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
3346 <Excluded>0</Excluded>
\r
3348 <Member MemberName="LastIndexOf<T>">
\r
3349 <MemberSignature Language="ILAsm" Value=".method public hidebysig static int32 LastIndexOf<T>(!!0[] array, !!0 value)"/>
\r
3350 <MemberSignature Language="C#" Value="public static int LastIndexOf<T>(T[] array, T value)"/>
\r
3351 <MemberType>Method</MemberType>
\r
3353 <ReturnType>System.Int32</ReturnType>
\r
3356 <Parameter Name="array" Type="T[]"/>
\r
3357 <Parameter Name="value" Type="T"/>
\r
3361 <para>Searches the specified array, returning the index of the last occurrence of the specified value.</para>
\r
3363 <param name="array">The array to search.</param>
\r
3364 <param name="value">The value to locate.</param>
\r
3366 <para>The zero-based index of the last occurrence of <paramref name="value"/> in
\r
3367 <paramref name="array"/>, if found; otherwise, - 1.</para>
\r
3369 <exception cref="T:System.ArgumentNullException">
\r
3371 <paramref name="array"/> is <see langword="null"/>.</para>
\r
3374 <para>The elements are compared using <see cref="M:System.Object.Equals(System.Object)"/>. The array is searched backward starting at the last element and ending at the first element. Processing is stopped when the predicate returns <see langword="true"/>.</para>
\r
3377 <Excluded>0</Excluded>
\r
3379 <Member MemberName="Length">
\r
3380 <MemberSignature Language="ILAsm" Value=".property int32 Length { public hidebysig specialname instance int32 get_Length() }"/>
\r
3381 <MemberSignature Language="C#" Value="public int Length { get; }"/>
\r
3382 <MemberType>Property</MemberType>
\r
3384 <ReturnType>System.Int32</ReturnType>
\r
3389 <para>Gets the total number of elements in all the dimensions
\r
3390 of the current instance.</para>
\r
3393 <para>A <see cref="T:System.Int32"/> that contains the total number of elements in all the dimensions of
\r
3394 the current instance.</para>
\r
3397 <para>This property is read-only.</para>
\r
3400 <Excluded>0</Excluded>
\r
3402 <Member MemberName="LongLength">
\r
3403 <MemberSignature Language="ILAsm" Value=".property int64 Length { public hidebysig specialname instance int64 get_LongLength() }"/>
\r
3404 <MemberSignature Language="C#" Value="public long LongLength {get;}"/>
\r
3405 <MemberType>Property</MemberType>
\r
3407 <ReturnType>System.Int64</ReturnType>
\r
3412 <para>Gets the total number of elements in all the dimensions of the current instance.</para>
\r
3415 <para>A <see cref="T:System.Int64"/> value containing the length of the array.</para>
\r
3418 <para>This property is read-only.</para>
\r
3421 <Excluded>0</Excluded>
\r
3423 <Member MemberName="Rank">
\r
3424 <MemberSignature Language="ILAsm" Value=".property int32 Rank { public hidebysig specialname instance int32 get_Rank() }"/>
\r
3425 <MemberSignature Language="C#" Value="public int Rank { get; }"/>
\r
3426 <MemberType>Property</MemberType>
\r
3428 <ReturnType>System.Int32</ReturnType>
\r
3433 <para>Gets the rank (number of dimensions) of the current instance.</para>
\r
3436 <para>A <see cref="T:System.Int32"/> that contains the rank (number of dimensions) of the current instance.</para>
\r
3439 <para>This property is read-only.</para>
\r
3442 <Excluded>0</Excluded>
\r
3444 <Member MemberName="Resize<T>">
\r
3445 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Resize<T>(!!0[]& array, int32 newSize)"/>
\r
3446 <MemberSignature Language="C#" Value="public static void Resize<T>(ref T[] array, int newSize)"/>
\r
3447 <MemberType>Method</MemberType>
\r
3449 <ReturnType>System.Void</ReturnType>
\r
3452 <Parameter Name="array" Type="T[]"/>
\r
3453 <Parameter Name="newSize" Type="System.Int32"/>
\r
3457 <para>Changes the size of an array to the specified new size.</para>
\r
3459 <param name="array">
\r
3460 <para>The array to resize.</para>
\r
3463 <see langword="null"/> to create a new array with the specified size.</para>
\r
3465 <param name="newSize">The size of the new array.</param>
\r
3466 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3468 <paramref name="newSize"/> is less than zero.</para>
\r
3471 <para>If array is <see langword="null"/>, this method creates a new array with the specified size.</para>
\r
3472 <para>If array is not <see langword="null"/>, then if <paramref name="newSize"/> is equal to <see cref="P:System.Array.Length"/> of the old array, this method does nothing. Otherwise, this method allocates a new array with the specified size, copies elements from the old array to the new one, and then assigns the new array reference to the array parameter. If <paramref name="newSize"/> is greater than <see cref="P:System.Array.Length"/> of the old array, a new array is allocated and all the elements are copied from the old array to the new one. If <paramref name="newSize"/> is less than <see cref="P:System.Array.Length"/> of the old array, a new array is allocated and elements are copied from the old array to the new one until the new one is filled; the rest of the elements in the old array are ignored.</para>
\r
3475 <Excluded>0</Excluded>
\r
3477 <Member MemberName="Reverse">
\r
3478 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Reverse(class System.Array array, int32 index, int32 length)"/>
\r
3479 <MemberSignature Language="C#" Value="public static void Reverse(Array array, int index, int length);"/>
\r
3480 <MemberType>Method</MemberType>
\r
3482 <ReturnType>System.Void</ReturnType>
\r
3485 <Parameter Name="array" Type="System.Array"/>
\r
3486 <Parameter Name="index" Type="System.Int32"/>
\r
3487 <Parameter Name="length" Type="System.Int32"/>
\r
3491 <para>Reverses the sequence of the elements in the specified
\r
3492 range of the specified one-dimensional <see cref="T:System.Array"/>.</para>
\r
3494 <param name="array">The one-dimensional <see cref="T:System.Array"/> to reverse.</param>
\r
3495 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which reversing starts.</param>
\r
3496 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to reverse.</param>
\r
3497 <exception cref="T:System.ArgumentNullException">
\r
3498 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
3499 <exception cref="T:System.RankException">
\r
3500 <paramref name="array"/> is multidimensional.</exception>
\r
3501 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3503 <paramref name="index"/> < <paramref name="array"/>.GetLowerBound(0).</para>
\r
3505 <paramref name="length"/> < 0.</para>
\r
3507 <exception cref="T:System.ArgumentException">
\r
3508 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/> (i.e. <paramref name="index"/> + <paramref name="length"/> > <paramref name="array"/>.GetLowerBound(0) + <paramref name="array"/>.Length).</exception>
\r
3510 <para>The following example demonstrates the <see cref="M:System.Array.Reverse(System.Array)"/> method.</para>
\r
3511 <code lang="C#">using System;
\r
3512 public class ArrayReverseExample {
\r
3513 public static void Main() {
\r
3514 string[] strAry = { "one", "two", "three" };
\r
3515 Console.Write( "The elements of the array are:");
\r
3516 foreach( string str in strAry )
\r
3517 Console.Write( " {0}", str );
\r
3518 Array.Reverse( strAry );
\r
3519 Console.WriteLine();
\r
3520 Console.WriteLine( "After reversing the array," );
\r
3521 Console.Write( "the elements of the array are:");
\r
3522 foreach( string str in strAry )
\r
3523 Console.Write( " {0}", str );
\r
3527 <para>The output is</para>
\r
3529 <para>The elements of the array are: one two three</para>
\r
3530 <para>After reversing the array,</para>
\r
3531 <para>the elements of the array are: three two one</para>
\r
3535 <Excluded>0</Excluded>
\r
3537 <Member MemberName="Reverse">
\r
3538 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Reverse(class System.Array array)"/>
\r
3539 <MemberSignature Language="C#" Value="public static void Reverse(Array array);"/>
\r
3540 <MemberType>Method</MemberType>
\r
3542 <ReturnType>System.Void</ReturnType>
\r
3545 <Parameter Name="array" Type="System.Array"/>
\r
3549 <para>Reverses the sequence of the elements in the specified one-dimensional
\r
3550 <see cref="T:System.Array"/>.</para>
\r
3552 <param name="array">The one-dimensional <see cref="T:System.Array"/> to reverse.</param>
\r
3553 <exception cref="T:System.ArgumentNullException">
\r
3554 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
3555 <exception cref="T:System.RankException">
\r
3556 <paramref name="array"/> has more than one dimension.</exception>
\r
3558 <para>This version of <see cref="M:System.Array.Reverse(System.Array)"/> is equivalent to <see cref="M:System.Array.Reverse(System.Array)"/>(<paramref name="array"/>, <paramref name="array"/>.GetLowerBound(0),
\r
3559 <paramref name="array"/>.Length).</para>
\r
3562 <Excluded>0</Excluded>
\r
3564 <Member MemberName="SetValue">
\r
3565 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetValue(object value, int32 index)"/>
\r
3566 <MemberSignature Language="C#" Value="public void SetValue(object value, int index);"/>
\r
3567 <MemberType>Method</MemberType>
\r
3569 <ReturnType>System.Void</ReturnType>
\r
3572 <Parameter Name="value" Type="System.Object"/>
\r
3573 <Parameter Name="index" Type="System.Int32"/>
\r
3577 <para> Sets the value of the element at the specified position
\r
3578 in the current one-dimensional instance.</para>
\r
3580 <param name="value">A <see cref="T:System.Object"/> that contains the new value for the specified element.</param>
\r
3581 <param name="index">A <see cref="T:System.Int32"/> that contains the index of the element whose value is to be set.</param>
\r
3582 <exception cref="T:System.ArgumentException">
\r
3583 <para>The current instance has more than one dimension.</para>
\r
3585 <exception cref="T:System.IndexOutOfRangeException">
\r
3587 <paramref name="index"/> is outside the range of valid indices for the current instance.</para>
\r
3589 <exception cref="T:System.InvalidCastException">
\r
3591 <paramref name="value"/> is not assignment-compatible with the element type of the current instance.</para>
\r
3594 <block subset="none" type="note">
\r
3595 <para>Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine whether
\r
3596 <paramref name="index"/> is out of bounds.</para>
\r
3598 information regarding valid conversions that will be performed by this method,
\r
3599 see <see cref="T:System.Convert"/>.</para>
\r
3603 <Excluded>0</Excluded>
\r
3605 <Member MemberName="SetValue">
\r
3606 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetValue(object value, int32 index1, int32 index2)"/>
\r
3607 <MemberSignature Language="C#" Value="public void SetValue(object value, int index1, int index2);"/>
\r
3608 <MemberType>Method</MemberType>
\r
3610 <ReturnType>System.Void</ReturnType>
\r
3613 <Parameter Name="value" Type="System.Object"/>
\r
3614 <Parameter Name="index1" Type="System.Int32"/>
\r
3615 <Parameter Name="index2" Type="System.Int32"/>
\r
3619 <para> Sets the value of the element at the specified position
\r
3620 in the current two-dimensional instance.</para>
\r
3622 <param name="value">A <see cref="T:System.Object"/> that contains the new value for the specified element.</param>
\r
3623 <param name="index1">A <see cref="T:System.Int32"/> that contains the first-dimension index of the element in the current instance to set. </param>
\r
3624 <param name="index2">A <see cref="T:System.Int32"/> that contains the second-dimension index of the element in the current instance to set. </param>
\r
3625 <exception cref="T:System.ArgumentException">
\r
3626 <para>The current instance does not have exactly two dimensions.</para>
\r
3628 <exception cref="T:System.IndexOutOfRangeException">At least one of <paramref name="index1"/> or <paramref name="index2"/> is outside the range of valid indices for the corresponding dimension of the current instance.</exception>
\r
3629 <exception cref="T:System.InvalidCastException">
\r
3631 <paramref name="value"/> is not assignment-compatible with the element type of the current instance.</para>
\r
3634 <block subset="none" type="note">
\r
3635 <para>For more information regarding valid conversions that will be performed by
\r
3636 this method, see <see cref="T:System.Convert"/>.</para>
\r
3637 <para>Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine whether any of the indices
\r
3638 are out of bounds.</para>
\r
3642 <Excluded>1</Excluded>
\r
3643 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
3645 <Member MemberName="SetValue">
\r
3646 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetValue(object value, int32 index1, int32 index2, int32 index3)"/>
\r
3647 <MemberSignature Language="C#" Value="public void SetValue(object value, int index1, int index2, int index3);"/>
\r
3648 <MemberType>Method</MemberType>
\r
3650 <ReturnType>System.Void</ReturnType>
\r
3653 <Parameter Name="value" Type="System.Object"/>
\r
3654 <Parameter Name="index1" Type="System.Int32"/>
\r
3655 <Parameter Name="index2" Type="System.Int32"/>
\r
3656 <Parameter Name="index3" Type="System.Int32"/>
\r
3660 <para> Sets the value of the element at the
\r
3661 specified position in the current three-dimensional instance.</para>
\r
3663 <param name="value">A <see cref="T:System.Object"/> that contains the new value for the specified element. </param>
\r
3664 <param name="index1">A <see cref="T:System.Int32"/> that contains the first-dimension index of the element in the current instance to set. </param>
\r
3665 <param name="index2">A <see cref="T:System.Int32"/> that contains the second-dimension index of the element in the current instance to set. </param>
\r
3666 <param name="index3">A <see cref="T:System.Int32"/> that contains the third-dimension index of the element in the current instance to set. </param>
\r
3667 <exception cref="T:System.ArgumentException">
\r
3668 <para>The current instance does not have exactly three dimensions.</para>
\r
3670 <exception cref="T:System.IndexOutOfRangeException">At least one of <paramref name="index1"/>, <paramref name="index2"/>, or <paramref name="index3"/> is outside the range of valid indices for the corresponding dimension of the current instance.</exception>
\r
3671 <exception cref="T:System.InvalidCastException">
\r
3673 <paramref name="value"/> is not assignment-compatible with the element type of the current instance.</para>
\r
3676 <block subset="none" type="note">
\r
3677 <para>For more information regarding valid conversions that will be performed by
\r
3678 this method, see <see cref="T:System.Convert"/>.</para>
\r
3679 <para>Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and
\r
3680 <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine whether any of the indices
\r
3681 are out of bounds.</para>
\r
3685 <Excluded>1</Excluded>
\r
3686 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
3688 <Member MemberName="SetValue">
\r
3689 <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void SetValue(object value, int32[] indices)"/>
\r
3690 <MemberSignature Language="C#" Value="public void SetValue(object value, int[] indices);"/>
\r
3691 <MemberType>Method</MemberType>
\r
3693 <ReturnType>System.Void</ReturnType>
\r
3696 <Parameter Name="value" Type="System.Object"/>
\r
3697 <Parameter Name="indices" Type="System.Int32[]"/>
\r
3701 <para>Sets the value of the element at the specified position in
\r
3702 the current multidimensional instance.</para>
\r
3704 <param name="value">A <see cref="T:System.Object"/> that contains the new value for the specified element. </param>
\r
3705 <param name="indices">A one-dimensional array of <see cref="T:System.Int32"/> objects that contains the indices that specify the position of the element in the current instance to set. </param>
\r
3706 <exception cref="T:System.ArgumentNullException">
\r
3707 <paramref name="indices"/> is <see langword="null"/>.</exception>
\r
3708 <exception cref="T:System.ArgumentException">
\r
3709 <para>The number of dimensions in the current instance is not equal to the number of elements in <paramref name="indices"/>. </para>
\r
3711 <exception cref="T:System.IndexOutOfRangeException">
\r
3712 <para>At least one element in <paramref name="indices"/> is outside the range of valid indices for the corresponding dimension of the current instance.</para>
\r
3714 <exception cref="T:System.InvalidCastException">
\r
3716 <paramref name="value"/> is not assignment-compatible with the element type of the current instance.</para>
\r
3719 <para>The number of elements in <paramref name="indices"/> is required to be equal to the number of
\r
3720 dimensions in the current instance. All elements in <paramref name="indices"/> collectively specify the position of the
\r
3721 desired element in the current instance.</para>
\r
3722 <block subset="none" type="note">
\r
3723 <para>For more information regarding valid conversions that will be performed by
\r
3724 this method, see <see cref="T:System.Convert"/>.</para>
\r
3725 <para>Use the <see cref="M:System.Array.GetLowerBound(System.Int32)"/> and <see cref="M:System.Array.GetUpperBound(System.Int32)"/> methods to determine whether any
\r
3726 of the values in <paramref name="indices"/> is out of bounds.</para>
\r
3730 <Excluded>1</Excluded>
\r
3731 <ExcludedLibrary>ExtendedArray</ExcludedLibrary>
\r
3733 <Member MemberName="Sort">
\r
3734 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array keys, class System.Array items, int32 index, int32 length, class System.Collections.IComparer comparer)"/>
\r
3735 <MemberSignature Language="C#" Value="public static void Sort(Array keys, Array items, int index, int length, IComparer comparer);"/>
\r
3736 <MemberType>Method</MemberType>
\r
3738 <ReturnType>System.Void</ReturnType>
\r
3741 <Parameter Name="keys" Type="System.Array"/>
\r
3742 <Parameter Name="items" Type="System.Array"/>
\r
3743 <Parameter Name="index" Type="System.Int32"/>
\r
3744 <Parameter Name="length" Type="System.Int32"/>
\r
3745 <Parameter Name="comparer" Type="System.Collections.IComparer"/>
\r
3749 <para>Sorts the specified range of the specified pair of one-dimensional <see cref="T:System.Array"/> objects (one
\r
3750 containing a set of keys and the other containing corresponding items) based on
\r
3751 the keys in the first specified <see cref="T:System.Array"/> using the specified <see cref="T:System.Collections.IComparer"/>
\r
3752 implementation.</para>
\r
3754 <param name="keys">A one-dimensional <see cref="T:System.Array"/> that contains the keys to sort.</param>
\r
3755 <param name="items">
\r
3756 <para>A one-dimensional <see cref="T:System.Array"/> that contains the items that correspond to each element of <paramref name="keys"/>. Specify a null reference to sort only <paramref name="keys"/>.</para>
\r
3758 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which sorting starts.</param>
\r
3759 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to sort.</param>
\r
3760 <param name="comparer">
\r
3761 <para>The <see cref="T:System.Collections.IComparer"/> implementation to use when comparing elements. Specify a null reference to use the <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
3763 <exception cref="T:System.ArgumentNullException">
\r
3765 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
3767 <exception cref="T:System.RankException">
\r
3769 <paramref name="keys"/> has more than one dimension.</para>
\r
3772 <paramref name="items"/> is not a null reference and has more than one dimension.</para>
\r
3774 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3776 <paramref name="index"/> < <paramref name="keys"/>.GetLowerBound(0).</para>
\r
3779 <paramref name="length"/> < 0.</para>
\r
3781 <exception cref="T:System.ArgumentException">
\r
3783 <paramref name="items"/> is not a null reference, and <paramref name="keys"/>.GetLowerBound(0) does not equal <paramref name="items"/>.GetLowerBound(0). </para>
\r
3784 <para>-or- </para>
\r
3786 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="key"/>. </para>
\r
3787 <para>-or- </para>
\r
3789 <paramref name="items"/> is not a null reference, and <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="items"/>. </para>
\r
3791 <exception cref="T:System.InvalidOperationException">
\r
3793 <paramref name="comparer"/> is <see langword="null"/>, and one or more elements in <paramref name="keys"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface. </para>
\r
3796 <para> Each key in <paramref name="keys"/> is required to have
\r
3797 a corresponding item in <paramref name="items"/>. The sort is performed according to the
\r
3798 order of <paramref name="keys"/>. After a key is repositioned during the sort,
\r
3799 the corresponding item in <paramref name="items"/> is similarly repositioned. Only
\r
3800 <paramref name="keys"/>.Length elements of <paramref name="items"/> will be sorted. Therefore,
\r
3801 <paramref name="items"/> is sorted according to the arrangement of
\r
3802 the corresponding keys in <paramref name="keys"/>. If the sort is not successfully
\r
3803 completed, the results are undefined.</para>
\r
3804 <para>If <paramref name="comparer"/> is a null reference, each element
\r
3805 of <paramref name="keys"/> is required to implement the <see cref="T:System.IComparable"/> interface to be capable of comparisons
\r
3806 with every other element in <paramref name="keys"/>.</para>
\r
3809 <Excluded>0</Excluded>
\r
3811 <Member MemberName="Sort">
\r
3812 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array array, int32 index, int32 length, class System.Collections.IComparer comparer)"/>
\r
3813 <MemberSignature Language="C#" Value="public static void Sort(Array array, int index, int length, IComparer comparer);"/>
\r
3814 <MemberType>Method</MemberType>
\r
3816 <ReturnType>System.Void</ReturnType>
\r
3819 <Parameter Name="array" Type="System.Array"/>
\r
3820 <Parameter Name="index" Type="System.Int32"/>
\r
3821 <Parameter Name="length" Type="System.Int32"/>
\r
3822 <Parameter Name="comparer" Type="System.Collections.IComparer"/>
\r
3826 <para>Sorts the elements in the specified section of the
\r
3827 specified one-dimensional <see cref="T:System.Array"/>
\r
3828 using the specified <see cref="T:System.Collections.IComparer"/>
\r
3829 implementation.</para>
\r
3831 <param name="array">A one-dimensional <see cref="T:System.Array"/> to sort.</param>
\r
3832 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which sorting starts.</param>
\r
3833 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to sort.</param>
\r
3834 <param name="comparer">
\r
3835 <para>The <see cref="T:System.Collections.IComparer"/> implementation to use when comparing elements. Specify a null reference to use the <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
3837 <exception cref="T:System.ArgumentNullException">
\r
3838 <paramref name="array"/> is <see langword="null"/>. </exception>
\r
3839 <exception cref="T:System.RankException">
\r
3840 <paramref name="array"/> has more than one dimension. </exception>
\r
3841 <exception cref="T:System.ArgumentOutOfRangeException">
\r
3843 <paramref name="index"/> < <paramref name="array"/>.GetLowerBound(0).</para>
\r
3846 <paramref name="length"/> < 0.</para>
\r
3848 <exception cref="T:System.ArgumentException">
\r
3850 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/>.</para>
\r
3852 <exception cref="T:System.InvalidOperationException">
\r
3854 <paramref name="comparer"/> is <see langword="null"/>, and one or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface. </para>
\r
3857 <para>This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="array"/>, <see langword="null"/>, <paramref name="index"/>, <paramref name="length"/>, <paramref name="comparer"/>).</para>
\r
3858 <para>If <paramref name="comparer"/> is a null reference, each element
\r
3859 of <paramref name="array"/> is required to implement the <see cref="T:System.IComparable"/> interface to be capable of comparisons
\r
3860 with every other element in <paramref name="array"/>. If the sort is not successfully
\r
3861 completed, the results are unspecified.</para>
\r
3864 <Excluded>0</Excluded>
\r
3866 <Member MemberName="Sort">
\r
3867 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array keys, class System.Array items, class System.Collections.IComparer comparer)"/>
\r
3868 <MemberSignature Language="C#" Value="public static void Sort(Array keys, Array items, IComparer comparer);"/>
\r
3869 <MemberType>Method</MemberType>
\r
3871 <ReturnType>System.Void</ReturnType>
\r
3874 <Parameter Name="keys" Type="System.Array"/>
\r
3875 <Parameter Name="items" Type="System.Array"/>
\r
3876 <Parameter Name="comparer" Type="System.Collections.IComparer"/>
\r
3880 <para>Sorts the specified pair of one-dimensional
\r
3881 <see cref="T:System.Array"/> objects (one
\r
3882 containing a set of keys and the other containing corresponding items) based on
\r
3883 the keys in the first specified <see cref="T:System.Array"/> using the specified <see cref="T:System.Collections.IComparer"/> implementation.</para>
\r
3885 <param name="keys">A one-dimensional <see cref="T:System.Array"/> that contains the keys to sort.</param>
\r
3886 <param name="items">
\r
3887 <para>A one-dimensional <see cref="T:System.Array"/> that contains the items that correspond to each element in <paramref name="keys"/>. Specify a null reference to sort only <paramref name="keys"/>.</para>
\r
3889 <param name="comparer">
\r
3890 <para>The <see cref="T:System.Collections.IComparer"/> implementation to use when comparing elements. Specify a null reference to use the <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
3892 <exception cref="T:System.ArgumentNullException">
\r
3894 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
3896 <exception cref="T:System.RankException">
\r
3898 <paramref name="keys"/> has more than one dimension.</para>
\r
3901 <paramref name="items"/> is not a null reference and has more than one dimension.</para>
\r
3903 <exception cref="T:System.ArgumentException">
\r
3905 <paramref name="items"/> is not a null reference, and <paramref name="keys"/>.GetLowerBound(0) does not equal <paramref name="items"/>.GetLowerBound(0). </para>
\r
3908 <paramref name="items"/> is not a null reference, and <paramref name="keys"/>.Length > <paramref name="items"/>.Length.</para>
\r
3910 <exception cref="T:System.InvalidOperationException">
\r
3912 <paramref name="comparer"/> is a <see langword="null"/>, and one or more elements in <paramref name="keys"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface. </para>
\r
3915 <para>This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="keys"/>, <paramref name="items"/>, <paramref name="keys"/>.GetLowerBound(0), <paramref name="keys"/>.Length, <paramref name="comparer"/>).</para>
\r
3916 <para> Each key in <paramref name="keys"/> is required to have
\r
3917 a corresponding item in <paramref name="items"/>. The sort is performed according to the order of
\r
3918 <paramref name="keys"/> . After a key is repositioned during the sort, the
\r
3919 corresponding item in <paramref name="items"/> is similarly repositioned. Only
\r
3920 <paramref name="keys"/>.Length elements of <paramref name="items"/> are sorted. Therefore,
\r
3921 <paramref name="items"/>
\r
3922 is sorted according to the arrangement of the corresponding keys in
\r
3923 <paramref name="keys"/>. If
\r
3924 the sort is not successfully completed, the results are unspecified.</para>
\r
3925 <para>If <paramref name="comparer"/> is a null reference, each element
\r
3926 of <paramref name="keys"/> is required to implement the <see cref="T:System.IComparable"/> interface to be capable of comparisons
\r
3927 with every other element in <paramref name="keys"/>.</para>
\r
3930 <Excluded>0</Excluded>
\r
3932 <Member MemberName="Sort">
\r
3933 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array array, class System.Collections.IComparer comparer)"/>
\r
3934 <MemberSignature Language="C#" Value="public static void Sort(Array array, IComparer comparer);"/>
\r
3935 <MemberType>Method</MemberType>
\r
3937 <ReturnType>System.Void</ReturnType>
\r
3940 <Parameter Name="array" Type="System.Array"/>
\r
3941 <Parameter Name="comparer" Type="System.Collections.IComparer"/>
\r
3945 <para>Sorts the elements in the specified one-dimensional <see cref="T:System.Array"/> using the
\r
3946 specified <see cref="T:System.Collections.IComparer"/> implementation.</para>
\r
3948 <param name="array">The one-dimensional <see cref="T:System.Array"/> to sort.</param>
\r
3949 <param name="comparer">
\r
3950 <para>The <see cref="T:System.Collections.IComparer"/> implementation to use when comparing elements. Specify a null reference to use the <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
3952 <exception cref="T:System.ArgumentNullException">
\r
3953 <paramref name="array"/> is <see langword="null"/>. </exception>
\r
3954 <exception cref="T:System.RankException">
\r
3955 <paramref name="array"/> has more than one dimension. </exception>
\r
3956 <exception cref="T:System.InvalidOperationException">
\r
3957 <paramref name="comparer"/> is a null reference, and one or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface.</exception>
\r
3959 <para>This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="array"/>, <see langword="null"/>, <paramref name="array"/>.GetLowerBound(0), <paramref name="array"/>.Length,
\r
3960 <paramref name="comparer"/>).</para>
\r
3961 <para>If <paramref name="comparer"/> is a null reference, each element
\r
3962 of <paramref name="array"/> is required to implement the <see cref="T:System.IComparable"/> interface to be capable of comparisons
\r
3963 with every other element in <paramref name="array"/>. If the sort is not successfully
\r
3964 completed, the results are unspecified.</para>
\r
3967 <Excluded>0</Excluded>
\r
3969 <Member MemberName="Sort">
\r
3970 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array keys, class System.Array items, int32 index, int32 length)"/>
\r
3971 <MemberSignature Language="C#" Value="public static void Sort(Array keys, Array items, int index, int length);"/>
\r
3972 <MemberType>Method</MemberType>
\r
3974 <ReturnType>System.Void</ReturnType>
\r
3977 <Parameter Name="keys" Type="System.Array"/>
\r
3978 <Parameter Name="items" Type="System.Array"/>
\r
3979 <Parameter Name="index" Type="System.Int32"/>
\r
3980 <Parameter Name="length" Type="System.Int32"/>
\r
3984 <para>Sorts the specified ranges of the specified pair of
\r
3985 one-dimensional <see cref="T:System.Array"/>
\r
3986 objects (one containing a set of keys and the other containing corresponding
\r
3987 items) based on the keys in the first specified <see cref="T:System.Array"/>.</para>
\r
3989 <param name="keys">A one-dimensional <see cref="T:System.Array"/> that contains the keys to sort.</param>
\r
3990 <param name="items">A one-dimensional <see cref="T:System.Array"/> that contains the items that correspond to each element in <paramref name="keys"/>. Specify a null reference to sort only <paramref name="keys"/>.</param>
\r
3991 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which sort begins.</param>
\r
3992 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to sort.</param>
\r
3993 <exception cref="T:System.ArgumentNullException">
\r
3995 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
3997 <exception cref="T:System.RankException">
\r
3999 <paramref name="keys"/> has more than one dimension.</para>
\r
4000 <para> -or-</para>
\r
4002 <paramref name="items"/> is not a null reference and has more than one dimension.</para>
\r
4004 <exception cref="T:System.ArgumentOutOfRangeException">
\r
4006 <paramref name="index"/> < <paramref name="keys"/>.GetLowerBound(0).</para>
\r
4009 <paramref name="length"/> < 0.</para>
\r
4011 <exception cref="T:System.ArgumentException">
\r
4013 <paramref name="items"/> is not a null reference, and <paramref name="keys"/>.GetLowerBound(0) does not equal <paramref name="items"/>.GetLowerBound(0). </para>
\r
4014 <para>-or- </para>
\r
4016 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="keys"/>. </para>
\r
4017 <para>-or- </para>
\r
4019 <paramref name="items"/> is not a null reference, and <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="items"/>. </para>
\r
4021 <exception cref="T:System.InvalidOperationException">
\r
4022 <para>One or more elements in <paramref name="keys"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface.</para>
\r
4025 <para>This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="keys"/>, <paramref name="items"/>, <paramref name="index"/>, <paramref name="length"/>, <see langword="null"/>).</para>
\r
4026 <para> Each key in <paramref name="keys"/> is
\r
4028 a corresponding item in <paramref name="items"/>. The sort is performed according to the
\r
4029 order of <paramref name="keys"/> . After a key is repositioned during the sort,
\r
4030 the corresponding item in <paramref name="items"/> is similarly
\r
4031 repositioned. Therefore, <paramref name="items"/> is sorted according to the arrangement of
\r
4032 the corresponding keys in <paramref name="keys"/>. If the sort is not successfully
\r
4033 completed, the results are undefined.</para>
\r
4034 <para>Each element of <paramref name="keys"/> is
\r
4035 required to implement the <see cref="T:System.IComparable"/> interface to
\r
4036 be capable of comparisons with every other element in <paramref name="keys"/>.</para>
\r
4039 <Excluded>0</Excluded>
\r
4041 <Member MemberName="Sort">
\r
4042 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array array)"/>
\r
4043 <MemberSignature Language="C#" Value="public static void Sort(Array array);"/>
\r
4044 <MemberType>Method</MemberType>
\r
4046 <ReturnType>System.Void</ReturnType>
\r
4049 <Parameter Name="array" Type="System.Array"/>
\r
4053 <para>Sorts the elements of the specified one-dimensional <see cref="T:System.Array"/>.</para>
\r
4055 <param name="array">A one-dimensional <see cref="T:System.Array"/> to sort.</param>
\r
4056 <exception cref="T:System.ArgumentNullException">
\r
4057 <paramref name="array"/> is <see langword="null"/>.</exception>
\r
4058 <exception cref="T:System.RankException">
\r
4059 <paramref name="array"/> has more than one dimension.</exception>
\r
4060 <exception cref="T:System.InvalidOperationException">One or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface.</exception>
\r
4062 <para>This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="array"/>, <see langword="null"/>, <paramref name="array"/>.GetLowerBound(0),
\r
4063 <paramref name="array"/>.Length, <see langword="null"/>).</para>
\r
4064 <para>Each element of <paramref name="array"/> is
\r
4065 required to implement
\r
4066 the <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other
\r
4067 element in array.</para>
\r
4070 <para>This example demonstrates the <see cref="M:System.Array.Sort(System.Array)"/> method.</para>
\r
4071 <code lang="C#">using System;
\r
4072 public class ArraySortExample {
\r
4073 public static void Main() {
\r
4074 string[] strAry = { "All's", "well", "that", "ends", "well" };
\r
4075 Console.Write( "The original string array is: " );
\r
4076 foreach ( String str in strAry )
\r
4077 Console.Write( str + " " );
\r
4078 Console.WriteLine();
\r
4079 Array.Sort( strAry );
\r
4080 Console.Write( "The sorted string array is: " );
\r
4081 foreach ( string str in strAry )
\r
4082 Console.Write( str + " " );
\r
4086 <para>The output is</para>
\r
4088 <para>The original string array is: All's well that ends well</para>
\r
4089 <para>The sorted string array is: All's ends that well well</para>
\r
4093 <Excluded>0</Excluded>
\r
4095 <Member MemberName="Sort">
\r
4096 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array keys, class System.Array items)"/>
\r
4097 <MemberSignature Language="C#" Value="public static void Sort(Array keys, Array items);"/>
\r
4098 <MemberType>Method</MemberType>
\r
4100 <ReturnType>System.Void</ReturnType>
\r
4103 <Parameter Name="keys" Type="System.Array"/>
\r
4104 <Parameter Name="items" Type="System.Array"/>
\r
4108 <para>Sorts the specified pair of one-dimensional <see cref="T:System.Array"/> objects (one
\r
4109 containing a set of keys and the other containing corresponding items) based on
\r
4110 the keys in the first specified <see cref="T:System.Array"/>.</para>
\r
4112 <param name="keys">A one-dimensional <see cref="T:System.Array"/> that contains the keys to sort.</param>
\r
4113 <param name="items">
\r
4114 <para>A one-dimensional <see cref="T:System.Array"/> that contains the items that correspond to each of element of <paramref name="keys"/>. Specify a null reference to sort only <paramref name="keys"/>.</para>
\r
4116 <exception cref="T:System.ArgumentNullException">
\r
4118 <paramref name="keys"/> is <see langword="null"/>. </para>
\r
4120 <exception cref="T:System.RankException">
\r
4122 <paramref name="keys"/> has more than one dimension.</para>
\r
4125 <paramref name="items"/> is not a null reference and has more than one dimension.</para>
\r
4127 <exception cref="T:System.ArgumentException">
\r
4129 <paramref name="items"/> is not a null reference, and <paramref name="keys"/>.GetLowerBound(0) does not equal <paramref name="items"/>.GetLowerBound(0).</para>
\r
4132 <paramref name="items"/> is not a null reference, and <paramref name="keys"/>.Length > <paramref name="items"/>.Length.</para>
\r
4134 <exception cref="T:System.InvalidOperationException">
\r
4135 <para>One or more elements in <paramref name="keys"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface.</para>
\r
4138 <para> This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="keys"/>, <paramref name="items"/>, <paramref name="keys"/>.GetLowerBound(0), <paramref name="keys"/>.Length, <see langword="null"/>).</para>
\r
4139 <para> Each key in <paramref name="keys"/> is required to have
\r
4140 a corresponding item in <paramref name="items"/>. The sort is performed according to the
\r
4141 order of <paramref name="keys"/> . After a key is repositioned during the sort,
\r
4142 the corresponding item in <paramref name="items"/> is similarly repositioned. Only
\r
4143 <paramref name="keys"/>.Length elements of
\r
4144 <paramref name="items"/> are sorted. Therefore,
\r
4145 <paramref name="items"/>
\r
4146 is sorted according to the arrangement of the corresponding keys in
\r
4147 <paramref name="keys"/>. If
\r
4148 the sort is not successfully completed, the results are unspecified.</para>
\r
4149 <para>Each element of <paramref name="keys"/> is
\r
4150 required to implement
\r
4151 the <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other
\r
4152 element in <paramref name="keys"/>.</para>
\r
4155 <para>This example demonstrates the <see cref="M:System.Array.Sort(System.Array)"/> method.</para>
\r
4156 <code lang="C#">using System;
\r
4157 public class ArraySortExample {
\r
4158 public static void Main() {
\r
4159 string[] strAry = { "All's", "well", "that", "ends", "well" };
\r
4160 int[] intAry = { 3, 4, 0, 1, 2 };
\r
4161 Console.Write( "The original string array is: " );
\r
4162 foreach ( string str in strAry )
\r
4163 Console.Write( str + " " );
\r
4164 Console.WriteLine();
\r
4165 Console.Write( "The key array is: " );
\r
4166 foreach ( int i in intAry )
\r
4167 Console.Write( i + " " );
\r
4168 Console.WriteLine();
\r
4169 Array.Sort( intAry, strAry );
\r
4170 Console.Write( "The sorted string array is: " );
\r
4171 foreach ( string str in strAry )
\r
4172 Console.Write( str + " " );
\r
4176 <para>The output is</para>
\r
4178 <para>The original string array is: All's well that ends well</para>
\r
4179 <para>The key array is: 3 4 0 1 2</para>
\r
4180 <para>The sorted string array is: that ends well All's well</para>
\r
4184 <Excluded>0</Excluded>
\r
4186 <Member MemberName="Sort">
\r
4187 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort(class System.Array array, int32 index, int32 length)"/>
\r
4188 <MemberSignature Language="C#" Value="public static void Sort(Array array, int index, int length);"/>
\r
4189 <MemberType>Method</MemberType>
\r
4191 <ReturnType>System.Void</ReturnType>
\r
4194 <Parameter Name="array" Type="System.Array"/>
\r
4195 <Parameter Name="index" Type="System.Int32"/>
\r
4196 <Parameter Name="length" Type="System.Int32"/>
\r
4200 <para>Sorts the elements in the specified range of the
\r
4201 specified one-dimensional <see cref="T:System.Array"/>.</para>
\r
4203 <param name="array">A one-dimensional <see cref="T:System.Array"/> to sort.</param>
\r
4204 <param name="index">A <see cref="T:System.Int32"/> that contains the index at which sorting starts.</param>
\r
4205 <param name="length">A <see cref="T:System.Int32"/> that contains the number of elements to sort.</param>
\r
4206 <exception cref="T:System.ArgumentNullException">
\r
4207 <paramref name="array"/> is <see langword="null"/>. </exception>
\r
4208 <exception cref="T:System.RankException">
\r
4209 <paramref name="array"/> has more than one dimension. </exception>
\r
4210 <exception cref="T:System.ArgumentOutOfRangeException">
\r
4212 <paramref name="index"/> < <paramref name="array"/>.GetLowerBound(0).</para>
\r
4215 <paramref name="length"/> < 0.</para>
\r
4217 <exception cref="T:System.ArgumentException">
\r
4219 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/>.</para>
\r
4221 <exception cref="T:System.InvalidOperationException">
\r
4222 <para>One or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable"/> interface.</para>
\r
4225 <para>This version of <see cref="M:System.Array.Sort(System.Array)"/> is equivalent to <see cref="M:System.Array.Sort(System.Array)"/>(<paramref name="array"/>,
\r
4226 <see langword="null"/> , <paramref name="index"/>, <paramref name="length"/>,
\r
4227 <see langword="null"/>).</para>
\r
4228 <para>Each element of <paramref name="array"/> is
\r
4229 required to implement
\r
4230 the <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other
\r
4231 element in <paramref name="array"/>. If the sort is not successfully completed, the
\r
4232 results are unspecified.</para>
\r
4235 <Excluded>0</Excluded>
\r
4237 <Member MemberName="Sort<K,V>">
\r
4238 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<K,V>(!!0[] keys, !!1[] items, int32 index, int32 length, class System.Collections.Generic.IComparer`1<!!0> comparer)"/>
\r
4239 <MemberSignature Language="C#" Value="public static void Sort<K,V>(K[] keys, V[] items, int index, int length, IComparer<K> comparer)"/>
\r
4240 <MemberType>Method</MemberType>
\r
4242 <ReturnType>System.Void</ReturnType>
\r
4245 <Parameter Name="keys" Type="K[]"/>
\r
4246 <Parameter Name="items" Type="V[]"/>
\r
4247 <Parameter Name="index" Type="System.Int32"/>
\r
4248 <Parameter Name="length" Type="System.Int32"/>
\r
4249 <Parameter Name="comparer" Type="System.Collections.Generic.IComparer<K>"/>
\r
4253 <para>Sorts a range of elements in a pair of arrays based on the keys in the first array using the specified <see cref="T:System.Collections.Generic.IComparer<K>"/>.</para>
\r
4255 <param name="keys">
\r
4256 <para>The array that contains the keys to sort.</para>
\r
4258 <param name="items">
\r
4259 <para>The array that contains the items that correspond to each of the keys in <paramref name="keys"/>.</para>
\r
4262 <see langword="null"/> to sort only the <paramref name="keys"/> array.</para>
\r
4264 <param name="index">The starting index of the range to sort.</param>
\r
4265 <param name="length">The number of elements in the range to sort.</param>
\r
4266 <param name="comparer">
\r
4267 <para>The <see cref="T:System.Collections.Generic.IComparer<K>"/> implementation to use when comparing elements.</para>
\r
4270 <see langword="null"/> to use the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
4272 <exception cref="T:System.ArgumentException">
\r
4274 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="keys"/>. </para>
\r
4275 <para>-or- </para>
\r
4277 <paramref name="items"/> is not <see langword="null"/>, and <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="items"/>.</para>
\r
4279 <exception cref="T:System.ArgumentNullException">
\r
4281 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
4283 <exception cref="T:System.ArgumentOutOfRangeException">
\r
4285 <paramref name="index"/> is less than zero.</para>
\r
4288 <paramref name="length"/> is less than zero.</para>
\r
4290 <exception cref="T:System.InvalidOperationException">
\r
4292 <paramref name="comparer"/> is <see langword="null"/>, and one or more elements in <paramref name="keys"/> that are used in a comparison do not implement the <see cref="T:System.IComparable<K>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4295 <para>If <paramref name="items"/> is non-null, each key in <paramref name="keys"/> is required to have
\r
4296 a corresponding item in <paramref name="items"/>. The sort is performed according to the
\r
4297 order of <paramref name="keys"/>. After a key is repositioned during the sort,
\r
4298 the corresponding item in <paramref name="items"/> is similarly repositioned. Only
\r
4299 <paramref name="keys"/>.Length elements of <paramref name="items"/> will be sorted. Therefore,
\r
4300 <paramref name="items"/> is sorted according to the arrangement of
\r
4301 the corresponding keys in <paramref name="keys"/>. If the sort is not successfully
\r
4302 completed, the results are undefined.</para>
\r
4303 <para>If <paramref name="comparer"/> is a null reference, each element of <paramref name="keys"/> is required to implement the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons
\r
4304 with every other element in <paramref name="keys"/>.</para>
\r
4307 <Excluded>0</Excluded>
\r
4309 <Member MemberName="Sort<K,V>">
\r
4310 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<K,V>(!!0[] keys, !!1[] items, class System.Collections.Generic.IComparer`1<!!0> comparer)"/>
\r
4311 <MemberSignature Language="C#" Value="public static void Sort<K,V>(K[] keys, V[] items, IComparer<K> comparer)"/>
\r
4312 <MemberType>Method</MemberType>
\r
4314 <ReturnType>System.Void</ReturnType>
\r
4317 <Parameter Name="keys" Type="K[]"/>
\r
4318 <Parameter Name="items" Type="V[]"/>
\r
4319 <Parameter Name="comparer" Type="System.Collections.Generic.IComparer<K>"/>
\r
4323 <para>Sorts a pair of arrays based on the keys in the first array, using the specified <see cref="T:System.Collections.Generic.IComparer"/>.</para>
\r
4325 <param name="keys">
\r
4326 <para>The array that contains the keys to sort.</para>
\r
4328 <param name="items">
\r
4329 <para>The array that contains the items that correspond to each of the keys in <paramref name="keys"/>.</para>
\r
4332 <see langword="null"/> to sort only the <paramref name="keys"/> array.</para>
\r
4334 <param name="comparer">
\r
4335 <para>The <see cref="T:System.Collections.Generic.IComparer<K>"/> implementation to use when comparing elements.</para>
\r
4338 <see langword="null"/> to use the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
4340 <exception cref="T:System.ArgumentNullException">
\r
4342 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
4344 <exception cref="T:System.ArgumentException">
\r
4346 <paramref name="items"/> is not <see langword="null"/>, and the length of <paramref name="keys"/> does not match the length of <paramref name="items"/>.</para>
\r
4348 <exception cref="T:System.InvalidOperationException">
\r
4350 <paramref name="comparer"/> is <see langword="null"/>, and one or more elements in <paramref name="keys"/> that are used in a comparison do not implement the <see cref="T:System.IComparable<K>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4353 <para>This version of <see cref="M:System.Array.Sort"/> is equivalent to <see cref="M:System.Array.Sort<K,V>"/>
\r
4354 <see langword="("/>
\r
4355 <paramref name="keys"/>
\r
4356 <see langword=", "/>
\r
4357 <paramref name="items"/>
\r
4358 <see langword=", "/>
\r
4359 <see langword="0, "/>
\r
4360 <paramref name="keys"/>
\r
4361 <see langword=".Length"/>
\r
4362 <see langword=", "/>
\r
4363 <paramref name="comparer"/>
\r
4364 <see langword=")"/>.</para>
\r
4365 <para>If <paramref name="items"/> is non-null, each key in <paramref name="keys"/> is required to have
\r
4366 a corresponding item in <paramref name="items"/>. The sort is performed according to the
\r
4367 order of <paramref name="keys"/>. After a key is repositioned during the sort,
\r
4368 the corresponding item in <paramref name="items"/> is similarly repositioned. Only
\r
4369 <paramref name="keys"/>.Length elements of <paramref name="items"/> will be sorted. Therefore,
\r
4370 <paramref name="items"/> is sorted according to the arrangement of
\r
4371 the corresponding keys in <paramref name="keys"/>. If the sort is not successfully
\r
4372 completed, the results are unspecified.</para>
\r
4373 <para>If <paramref name="comparer"/> is a null reference, each element of <paramref name="keys"/> is required to implement the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons
\r
4374 with every other element in <paramref name="keys"/>.</para>
\r
4377 <Excluded>0</Excluded>
\r
4379 <Member MemberName="Sort<K,V>">
\r
4380 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<K,V>(!!0[] keys, !!1[] items, int32 index, int32 length)"/>
\r
4381 <MemberSignature Language="C#" Value="public static void Sort<K,V>(K[] keys, V[] items, int index, int length)"/>
\r
4382 <MemberType>Method</MemberType>
\r
4384 <ReturnType>System.Void</ReturnType>
\r
4387 <Parameter Name="keys" Type="K[]"/>
\r
4388 <Parameter Name="items" Type="V[]"/>
\r
4389 <Parameter Name="index" Type="System.Int32"/>
\r
4390 <Parameter Name="length" Type="System.Int32"/>
\r
4394 <para>Sorts a range of elements in a pair of arrays based on the keys in the first array, using the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> implementation of each key.</para>
\r
4396 <param name="keys">
\r
4397 <para>The array that contains the keys to sort.</para>
\r
4399 <param name="items">
\r
4400 <para>The array that contains the items that correspond to each of the keys in <paramref name="keys"/>.</para>
\r
4403 <see langword="null"/> to sort only the <paramref name="keys"/> array.</para>
\r
4405 <param name="index">The starting index of the range to sort.</param>
\r
4406 <param name="length">The number of elements in the range to sort.</param>
\r
4407 <exception cref="T:System.ArgumentException">
\r
4409 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="keys"/>. </para>
\r
4410 <para>-or- </para>
\r
4412 <paramref name="items"/> is not <see langword="null"/>, and <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="items"/>.</para>
\r
4414 <exception cref="T:System.ArgumentNullException">
\r
4416 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
4418 <exception cref="T:System.ArgumentOutOfRangeException">
\r
4420 <paramref name="index"/> is less than zero.</para>
\r
4423 <paramref name="length"/> is less than zero.</para>
\r
4425 <exception cref="T:System.InvalidOperationException">
\r
4426 <para>One or more elements in <paramref name="keys"/> that are used in a comparison are the null reference or do not implement the <see cref="T:System.IComparable<K>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4429 <para>If <paramref name="items"/> is non-null, each key in <paramref name="keys"/> is required to have
\r
4430 a corresponding item in <paramref name="items"/>. When a key is repositioned during the sorting,
\r
4431 the corresponding item in <paramref name="items"/> is similarly repositioned. Therefore, <paramref name="items"/> is sorted according to the arrangement of
\r
4432 the corresponding keys in <paramref name="keys"/>. </para>
\r
4433 <para>If the sort is not successfully completed, the results are unspecified.</para>
\r
4434 <para>Each key within the specified range of elements in <paramref name="keys"/> must implement the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other key.</para>
\r
4435 <para>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.</para>
\r
4438 <Excluded>0</Excluded>
\r
4440 <Member MemberName="Sort<K,V>">
\r
4441 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<K,V>(!!0[] keys, !!1[] items)"/>
\r
4442 <MemberSignature Language="C#" Value="public static void Sort<K,V>(K[] keys, V[] items)"/>
\r
4443 <MemberType>Method</MemberType>
\r
4445 <ReturnType>System.Void</ReturnType>
\r
4448 <Parameter Name="keys" Type="K[]"/>
\r
4449 <Parameter Name="items" Type="V[]"/>
\r
4453 <para>Sorts a pair of arrays based on the keys in the first array using the <see cref="T:System.IComparable"/> implementation of each key.</para>
\r
4455 <param name="keys">
\r
4456 <para>The array that contains the keys to sort.</para>
\r
4458 <param name="items">
\r
4459 <para>The array that contains the items that correspond to each of the keys in <paramref name="keys"/>.</para>
\r
4462 <see langword="null"/> to sort only the <paramref name="keys"/> array.</para>
\r
4464 <exception cref="T:System.ArgumentException">
\r
4466 <paramref name="items"/> is not <see langword="null"/>, and the length of <paramref name="keys"/> does not equal the length of <paramref name="items"/>.</para>
\r
4468 <exception cref="T:System.ArgumentNullException">
\r
4470 <paramref name="keys"/> is <see langword="null"/>.</para>
\r
4472 <exception cref="T:System.InvalidOperationException">
\r
4473 <para>One or more elements in <paramref name="keys"/> that are used in a comparison are the null reference or do not implement the <see cref="T:System.IComparable<K>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4476 <para>If <paramref name="items"/> is non-null, each key in <paramref name="keys"/> is required to have
\r
4477 a corresponding item in <paramref name="items"/>. When a key is repositioned during the sorting,
\r
4478 the corresponding item in <paramref name="items"/> is similarly repositioned. Therefore, <paramref name="items"/> is sorted according to the arrangement of
\r
4479 the corresponding keys in <paramref name="keys"/>. </para>
\r
4480 <para>Each key in <paramref name="keys"/> must implement the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other key.</para>
\r
4481 <para>If the sort is not successfully completed, the results are undefined.</para>
\r
4482 <para>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.</para>
\r
4485 <Excluded>0</Excluded>
\r
4487 <Member MemberName="Sort<T>">
\r
4488 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<T>(!!0[] array, int32 index, int32 length, class System.Collections.Generic.IComparer`1<!!0> comparer)"/>
\r
4489 <MemberSignature Language="C#" Value="public static void Sort<T>(T[] array, int index, int length, IComparer<T> comparer)"/>
\r
4490 <MemberType>Method</MemberType>
\r
4492 <ReturnType>System.Void</ReturnType>
\r
4495 <Parameter Name="array" Type="T[]"/>
\r
4496 <Parameter Name="index" Type="System.Int32"/>
\r
4497 <Parameter Name="length" Type="System.Int32"/>
\r
4498 <Parameter Name="comparer" Type="System.Collections.Generic.IComparer<T>"/>
\r
4502 <para>Sorts the elements in a range of elements in an array using the specified comparer.</para>
\r
4504 <param name="array">
\r
4505 <para>The array to sort.</para>
\r
4507 <param name="index">The starting index of the range to sort.</param>
\r
4508 <param name="length">The number of elements in the range to sort.</param>
\r
4509 <param name="comparer">
\r
4510 <para>The <see cref="T:System.Collections.Generic.IComparer<K>"/> implementation to use when comparing elements.</para>
\r
4513 <see langword="null"/> to use the <see cref="T:System.IComparable<K>"/> or <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
4515 <exception cref="T:System.ArgumentNullException">
\r
4517 <paramref name="array"/> is <see langword="null"/>.</para>
\r
4519 <exception cref="T:System.ArgumentOutOfRangeException">
\r
4521 <paramref name="index"/> is less than zero.</para>
\r
4524 <paramref name="length"/> is less than zero.</para>
\r
4526 <exception cref="T:System.ArgumentException">
\r
4528 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/>. </para>
\r
4530 <exception cref="T:System.InvalidOperationException">
\r
4532 <paramref name="comparer"/> is <see langword="null"/>, and one or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable<K>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4535 <para>If <paramref name="comparer"/> is null, each element within the specified range of elements in <paramref name="array"/> must implement the <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other element in <paramref name="array"/>.</para>
\r
4536 <para>If the sort is not successfully completed, the results are undefined.</para>
\r
4537 <para>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.</para>
\r
4540 <Excluded>0</Excluded>
\r
4542 <Member MemberName="Sort<T>">
\r
4543 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<T>(!!0[] array, class System.Collections.Generic.IComparer`1<!!0> comparer)"/>
\r
4544 <MemberSignature Language="C#" Value="public static void Sort<T>(T[] array, IComparer<T> comparer)"/>
\r
4545 <MemberType>Method</MemberType>
\r
4547 <ReturnType>System.Void</ReturnType>
\r
4550 <Parameter Name="array" Type="T[]"/>
\r
4551 <Parameter Name="comparer" Type="System.Collections.Generic.IComparer<T>"/>
\r
4555 <para>Sorts the elements in an array using the specified comparer.</para>
\r
4557 <param name="array">
\r
4558 <para>The array to sort.</para>
\r
4560 <param name="comparer">
\r
4561 <para>The <see cref="T:System.Collections.Generic.IComparer<T>"/> implementation to use when comparing elements.</para>
\r
4564 <see langword="null"/> to use the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation of each element.</para>
\r
4566 <exception cref="T:System.ArgumentNullException">
\r
4568 <paramref name="array"/> is <see langword="null"/>.</para>
\r
4570 <exception cref="T:System.InvalidOperationException">
\r
4572 <paramref name="comparer"/> is <see langword="null"/>, and one or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable<T>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4575 <para>If <paramref name="comparer"/> is null, each element of <paramref name="array"/> must implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other element in <paramref name="array"/>.</para>
\r
4576 <para>If the sort is not successfully completed, the results are undefined.</para>
\r
4577 <para>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.</para>
\r
4580 <Excluded>0</Excluded>
\r
4582 <Member MemberName="Sort<T>">
\r
4583 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<T>(!!0[] array, class System.Comparison`1<!!0> comparison)"/>
\r
4584 <MemberSignature Language="C#" Value="public static void Sort<T>(T[] array, Comparison<T> comparison)"/>
\r
4585 <MemberType>Method</MemberType>
\r
4587 <ReturnType>System.Void</ReturnType>
\r
4590 <Parameter Name="array" Type="T[]"/>
\r
4591 <Parameter Name="comparison" Type="System.Comparison<T>"/>
\r
4595 <para>Sorts the elements in an array using the specified comparison.</para>
\r
4597 <param name="array">
\r
4598 <para>The array to sort.</para>
\r
4600 <param name="comparison">
\r
4601 <para>The <see cref="T:System.Comparison<T>"/> to use when comparing elements.</para>
\r
4603 <exception cref="T:System.ArgumentNullException">
\r
4605 <paramref name="array"/> is <see langword="null"/>.</para>
\r
4608 <paramref name="comparison"/> is <see langword="null"/>.</para>
\r
4611 <para>If the sort is not successfully completed, the results are undefined.</para>
\r
4612 <para>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.</para>
\r
4615 <Excluded>0</Excluded>
\r
4617 <Member MemberName="Sort<T>">
\r
4618 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<T>(!!0[] array)"/>
\r
4619 <MemberSignature Language="C#" Value="public static void Sort<T>(T[] array)"/>
\r
4620 <MemberType>Method</MemberType>
\r
4622 <ReturnType>System.Void</ReturnType>
\r
4625 <Parameter Name="array" Type="T[]"/>
\r
4629 <para>Sorts the elements in an entire array using the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation of each element of that array.</para>
\r
4631 <param name="array">
\r
4632 <para>The array to sort.</para>
\r
4634 <exception cref="T:System.ArgumentNullException">
\r
4636 <paramref name="array"/> is <see langword="null"/>.</para>
\r
4638 <exception cref="T:System.InvalidOperationException">
\r
4639 <para>One or more elements in <paramref name="array"/> that are used in a comparison are the null reference or do not implement the <see cref="T:System.IComparable<T>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4642 <para>Each element of <paramref name="array"/> is required to implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other element in <paramref name="array"/>.</para>
\r
4643 <para>If the sort is not successfully completed, the results are undefined.</para>
\r
4644 <para>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.</para>
\r
4647 <Excluded>0</Excluded>
\r
4649 <Member MemberName="Sort<T>">
\r
4650 <MemberSignature Language="ILAsm" Value=".method public hidebysig static void Sort<T>(!!0[] array, int32 index, int32 length)"/>
\r
4651 <MemberSignature Language="C#" Value="public static void Sort<T>(T[] array, int index, int length)"/>
\r
4652 <MemberType>Method</MemberType>
\r
4654 <ReturnType>System.Void</ReturnType>
\r
4657 <Parameter Name="array" Type="T[]"/>
\r
4658 <Parameter Name="index" Type="System.Int32"/>
\r
4659 <Parameter Name="length" Type="System.Int32"/>
\r
4663 <para>Sorts an array using the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> implementation of each element of that array.</para>
\r
4665 <param name="array">
\r
4666 <para>The array to sort.</para>
\r
4668 <param name="index">The starting index of the range to sort.</param>
\r
4669 <param name="length">The number of elements in the range to sort.</param>
\r
4670 <exception cref="T:System.ArgumentException">
\r
4672 <paramref name="index"/> and <paramref name="length"/> do not specify a valid range in <paramref name="array"/>. </para>
\r
4674 <exception cref="T:System.ArgumentNullException">
\r
4676 <paramref name="array"/> is <see langword="null"/>.</para>
\r
4678 <exception cref="T:System.ArgumentOutOfRangeException">
\r
4680 <paramref name="index"/> is less than zero.</para>
\r
4683 <paramref name="length"/> is less than zero.</para>
\r
4685 <exception cref="T:System.InvalidOperationException">
\r
4686 <para>One or more elements in <paramref name="array"/> that are used in a comparison do not implement the <see cref="T:System.IComparable<T>"/> or <see cref="T: System.IComparable"/> interface.</para>
\r
4689 <para>Each element within the specified range of elements in <paramref name="array"/> must implement the <see cref="T:System.IComparable<T>"/> or <see cref="T:System.IComparable"/> interface to be capable of comparisons with every other element in <paramref name="array"/>.</para>
\r
4690 <para>If the sort is not successfully completed, the results are undefined.</para>
\r
4691 <para>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.</para>
\r
4694 <Excluded>0</Excluded>
\r
4696 <Member MemberName="SyncRoot">
\r
4697 <MemberSignature Language="ILAsm" Value=".property public object SyncRoot { public hidebysig virtual abstract specialname object get_SyncRoot() }"/>
\r
4698 <MemberSignature Language="C#" Value="public object SyncRoot { get; }"/>
\r
4699 <MemberType>Property</MemberType>
\r
4701 <ReturnType>System.Object</ReturnType>
\r
4705 <summary>Implemented to support the <see cref="T:System.Collections.ICollection"/> interface. [Note: For more information, see <see cref="M:System.Collections.ICollection.SyncRoot"/>.]</summary>
\r
4707 <Excluded>0</Excluded>
\r
4709 <Member MemberName="System.Collections.ICollection.Count">
\r
4710 <MemberSignature Language="ILAsm" Value=".property int32 ICollection.Count { public hidebysig virtual abstract specialname int32 get_ICollection.Count() }"/>
\r
4711 <MemberSignature Language="C#" Value="int ICollection.Count { get; }"/>
\r
4712 <MemberType>Property</MemberType>
\r
4714 <ReturnType>System.Int32</ReturnType>
\r
4718 <summary>Implemented to support the <see cref="T:System.Collections.ICollection"/> interface. [Note: For more information, see <see cref="M:System.Collections.ICollection.Count"/>.]</summary>
\r
4720 <Excluded>0</Excluded>
\r
4722 <Member MemberName="System.Collections.IList.Add">
\r
4723 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual int32 System.Collections.IList.Add(object value)"/>
\r
4724 <MemberSignature Language="C#" Value="int IList.Add(object value);"/>
\r
4725 <MemberType>Method</MemberType>
\r
4727 <ReturnType>System.Int32</ReturnType>
\r
4730 <Parameter Name="value" Type="System.Object"/>
\r
4733 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.Add"/>.]</summary>
\r
4735 <Excluded>0</Excluded>
\r
4737 <Member MemberName="System.Collections.IList.Clear">
\r
4738 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual void System.Collections.IList.Clear()"/>
\r
4739 <MemberSignature Language="C#" Value="void IList.Clear();"/>
\r
4740 <MemberType>Method</MemberType>
\r
4742 <ReturnType>System.Void</ReturnType>
\r
4746 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.Clear"/>.]</summary>
\r
4748 <Excluded>0</Excluded>
\r
4750 <Member MemberName="System.Collections.IList.Contains">
\r
4751 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual bool System.Collections.IList.Contains(object value)"/>
\r
4752 <MemberSignature Language="C#" Value="bool IList.Contains(object value);"/>
\r
4753 <MemberType>Method</MemberType>
\r
4755 <ReturnType>System.Boolean</ReturnType>
\r
4758 <Parameter Name="value" Type="System.Object"/>
\r
4761 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.Contains"/>.]</summary>
\r
4763 <Excluded>0</Excluded>
\r
4765 <Member MemberName="System.Collections.IList.IndexOf">
\r
4766 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual int32 System.Collections.IList.IndexOf(object value)"/>
\r
4767 <MemberSignature Language="C#" Value="int IList.IndexOf(object value);"/>
\r
4768 <MemberType>Method</MemberType>
\r
4770 <ReturnType>System.Int32</ReturnType>
\r
4773 <Parameter Name="value" Type="System.Object"/>
\r
4776 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.IndexOf"/>.]</summary>
\r
4778 <Excluded>0</Excluded>
\r
4780 <Member MemberName="System.Collections.IList.Insert">
\r
4781 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual void System.Collections.IList.Insert(int32 index, object value)"/>
\r
4782 <MemberSignature Language="C#" Value="void IList.Insert(int index, object value);"/>
\r
4783 <MemberType>Method</MemberType>
\r
4785 <ReturnType>System.Void</ReturnType>
\r
4788 <Parameter Name="index" Type="System.Int32"/>
\r
4789 <Parameter Name="value" Type="System.Object"/>
\r
4792 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.Insert"/>.]</summary>
\r
4794 <Excluded>0</Excluded>
\r
4796 <Member MemberName="System.Collections.IList.Item">
\r
4797 <MemberSignature Language="ILAsm" Value=".property object IList.Item[int32 index] { public hidebysig virtual abstract specialname object get_IList.Item(int32 index) public hidebysig virtual abstract specialname void set_IList.Item(int32 index, object value) }"/>
\r
4798 <MemberSignature Language="C#" Value="public virtual object this[int index] { get; set; }"/>
\r
4799 <MemberType>Property</MemberType>
\r
4801 <ReturnType>System.Object</ReturnType>
\r
4804 <Parameter Name="index" Type="System.Int32"/>
\r
4807 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.Item"/>.]</summary>
\r
4809 <Excluded>0</Excluded>
\r
4811 <Member MemberName="System.Collections.IList.Remove">
\r
4812 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual void System.Collections.IList.Remove(object value)"/>
\r
4813 <MemberSignature Language="C#" Value="void IList.Remove(object value);"/>
\r
4814 <MemberType>Method</MemberType>
\r
4816 <ReturnType>System.Void</ReturnType>
\r
4819 <Parameter Name="value" Type="System.Object"/>
\r
4822 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.Remove"/>.]</summary>
\r
4824 <Excluded>0</Excluded>
\r
4826 <Member MemberName="System.Collections.IList.RemoveAt">
\r
4827 <MemberSignature Language="ILAsm" Value=".method private final hidebysig virtual void System.Collections.IList.RemoveAt(int32 index)"/>
\r
4828 <MemberSignature Language="C#" Value="void IList.RemoveAt(int index);"/>
\r
4829 <MemberType>Method</MemberType>
\r
4831 <ReturnType>System.Void</ReturnType>
\r
4834 <Parameter Name="index" Type="System.Int32"/>
\r
4837 <summary>Implemented to support the <see cref="T:System.Collections.IList"/> interface. [Note: For more information, see <see cref="M:System.Collections.IList.RemoveAt"/>.]</summary>
\r
4839 <Excluded>0</Excluded>
\r
4841 <Member MemberName="TrueForAll<T>">
\r
4842 <MemberSignature Language="ILAsm" Value=".method public hidebysig static bool TrueForAll<T>(!!0[] array, class System.Predicate`1<!!0> match)"/>
\r
4843 <MemberSignature Language="C#" Value="public static bool TrueForAll<T>(T[] array, Predicate<T> match)"/>
\r
4844 <MemberType>Method</MemberType>
\r
4846 <ReturnType>System.Boolean</ReturnType>
\r
4849 <Parameter Name="array" Type="T[]"/>
\r
4850 <Parameter Name="match" Type="System.Predicate<T>"/>
\r
4854 <para>Determines whether every element in the array matches the predicate.</para>
\r
4856 <param name="array">The array to check against the conditions.</param>
\r
4857 <param name="match">
\r
4858 <para>The predicate against which the elements are checked..</para>
\r
4862 <see langword="true"/>, if every element in <paramref name="array"/> matches the specified predicate; otherwise, <see langword="false"/>.</para>
\r
4864 <exception cref="T:System.ArgumentNullException">
\r
4865 <paramref name="array"/> or <paramref name="match"/> is <see langword="null"/>.</exception>
\r
4867 <para>The predicate returns <see langword="true"/> if the object passed to it matches the delegate. The elements of <paramref name="array"/> are individually passed to the predicate, and processing is stopped when the delegate returns <see langword="false"/> for any element.</para>
\r
4870 <Excluded>0</Excluded>
\r
4873 <TypeExcluded>0</TypeExcluded>
\r
projects / mono.git / blob