Array Array Array Array Class

Definice

Poskytuje metody pro vytváření, manipulaci, vyhledávání a řazení polí, což slouží jako základní třída pro všechna pole v modulu CLR (Common Language Runtime).Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Dědičnost
ArrayArrayArrayArray
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje, jak Array.Copy kopíruje prvky mezi polem typu Integer a polem typu Object.The following code example shows how Array.Copy copies elements between an array of type integer and an array of type Object.

using namespace System;

void PrintValues(array<Object^>^myArr);
void PrintValues(array<int>^myArr);
void main()
{
	// Creates and initializes a new int array and a new Object array.
	array<int>^myIntArray = { 1,2,3,4,5 };
	array<Object^>^myObjArray = { 26,27,28,29,30 };

	// Prints the initial values of both arrays.
	Console::WriteLine("Initially:");
	Console::Write("int array:   ");
	PrintValues(myIntArray);
	Console::Write("Object array:");
	PrintValues(myObjArray);

	// Copies the first two elements from the int array to the Object array.
	System::Array::Copy(myIntArray, myObjArray, 2);

	// Prints the values of the modified arrays.
	Console::WriteLine("\nAfter copying the first two elements of the int array to the Object array:");
	Console::Write("int array:   ");
	PrintValues(myIntArray);
	Console::Write("Object array:");
	PrintValues(myObjArray);

	// Copies the last two elements from the Object array to the int array.
	System::Array::Copy(myObjArray, myObjArray->GetUpperBound(0) - 1, myIntArray, myIntArray->GetUpperBound(0) - 1, 2);

	// Prints the values of the modified arrays.
	Console::WriteLine("\nAfter copying the last two elements of the Object array to the int array:");
	Console::Write("int array:   ");
	PrintValues(myIntArray);
	Console::Write("Object array:");
	PrintValues(myObjArray);
}

void PrintValues(array<Object^>^myArr)
{
	for (int i = 0; i < myArr->Length; i++)
	{
		Console::Write("\t{0}", myArr[i]);

	}
	Console::WriteLine();
}

void PrintValues(array<int>^myArr)
{
	for (int i = 0; i < myArr->Length; i++)
	{
		Console::Write("\t{0}", myArr[i]);

	}
	Console::WriteLine();
}


/*
This code produces the following output.

Initially:
int array:       1    2    3    4    5
Object array:    26    27    28    29    30
After copying the first two elements of the int array to the Object array:
int array:       1    2    3    4    5
Object array:    1    2    28    29    30
After copying the last two elements of the Object array to the int array:
int array:       1    2    3    29    30
Object array:    1    2    28    29    30
*/
using System;
public class SamplesArray
{

    public static void Main()
    {

        // Creates and initializes a new integer array and a new Object array.
        int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
        Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };

        // Prints the initial values of both arrays.
        Console.WriteLine("Initially,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);

        // Copies the first two elements from the integer array to the Object array.
        System.Array.Copy(myIntArray, myObjArray, 2);

        // Prints the values of the modified arrays.
        Console.WriteLine("\nAfter copying the first two elements of the integer array to the Object array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);

        // Copies the last two elements from the Object array to the integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2);

        // Prints the values of the modified arrays.
        Console.WriteLine("\nAfter copying the last two elements of the Object array to the integer array,");
        Console.Write("integer array:");
        PrintValues(myIntArray);
        Console.Write("Object array: ");
        PrintValues(myObjArray);
    }


    public static void PrintValues(Object[] myArr)
    {
        foreach (Object i in myArr)
        {
            Console.Write("\t{0}", i);
        }
        Console.WriteLine();
    }

    public static void PrintValues(int[] myArr)
    {
        foreach (int i in myArr)
        {
            Console.Write("\t{0}", i);
        }
        Console.WriteLine();
    }
}
/* 
This code produces the following output.

Initially,
integer array:  1       2       3       4       5
Object array:   26      27      28      29      30

After copying the first two elements of the integer array to the Object array,
integer array:  1       2       3       4       5
Object array:   1       2       28      29      30

After copying the last two elements of the Object array to the integer array,
integer array:  1       2       3       29      30
Object array:   1       2       28      29      30
*/
Public Class SamplesArray

    Public Shared Sub Main()

        ' Creates and initializes a new integer array and a new Object array.
        Dim myIntArray() As Integer = {1, 2, 3, 4, 5}
        Dim myObjArray() As Object = {26, 27, 28, 29, 30}

        ' Prints the initial values of both arrays.
        Console.WriteLine("Initially:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the first two elements from the integer array to the Object array.
        System.Array.Copy(myIntArray, myObjArray, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the first two" _
           + " elements of the integer array to the Object array:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the last two elements from the Object array to the integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray,
           myIntArray.GetUpperBound(0) - 1, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the last two" _
           + " elements of the Object array to the integer array:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)
    End Sub

    Public Overloads Shared Sub PrintValues(myArr() As Object)
        Dim i As Object
        For Each i In myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub

    Public Overloads Shared Sub PrintValues(myArr() As Integer)
        Dim i As Integer
        For Each i In myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Initially:
' integer array:  1       2       3       4       5
' Object array:   26      27      28      29      30
' 
' After copying the first two elements of the integer array to the Object array:
' integer array:  1       2       3       4       5
' Object array:   1       2       28      29      30
' 
' After copying the last two elements of the Object array to the integer array:
' integer array:  1       2       3       29      30
' Object array:   1       2       28      29      30

Následující příklad kódu vytvoří a inicializuje Array a zobrazí jeho vlastnosti a prvky.The following code example creates and initializes an Array and displays its properties and its elements.

using namespace System;
void PrintValues(Array^ myArr);
void main()
{
   // Creates and initializes a new three-dimensional Array instance of type Int32.
   Array^ myArr = Array::CreateInstance( Int32::typeid, 2, 3, 4 );
   for ( int i = myArr->GetLowerBound( 0 ); i <= myArr->GetUpperBound( 0 ); i++ )
   {
      for ( int j = myArr->GetLowerBound( 1 ); j <= myArr->GetUpperBound( 1 ); j++ )
      {
         for ( int k = myArr->GetLowerBound( 2 ); k <= myArr->GetUpperBound( 2 ); k++ )
            myArr->SetValue( (i * 100) + (j * 10) + k, i, j, k );

      }
   }
   
   // Displays the properties of the Array.
   Console::WriteLine(  "The Array instance has {0} dimension(s) and a total of {1} elements.", myArr->Rank, myArr->Length );
   Console::WriteLine(  "\tLength\tLower\tUpper" );
   for ( int i = 0; i < myArr->Rank; i++ )
   {
      Console::Write(  "{0}:\t{1}", i, myArr->GetLength( i ) );
      Console::WriteLine(  "\t{0}\t{1}", myArr->GetLowerBound( i ), myArr->GetUpperBound( i ) );

   }
   Console::WriteLine(  "The Array instance contains the following values:" );
   PrintValues( myArr );
}

void PrintValues( Array^ myArr )
{
   System::Collections::IEnumerator^ myEnumerator = myArr->GetEnumerator();
   int i = 0;
   int cols = myArr->GetLength( myArr->Rank - 1 );
   while ( myEnumerator->MoveNext() )
   {
      if ( i < cols )
            i++;
      else
      {
         Console::WriteLine();
         i = 1;
      }

      Console::Write(  "\t{0}", myEnumerator->Current );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 The Array instance has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array instance contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */
using System;

public class SamplesArray2
{
    public static void Main()
    {
        // Creates and initializes a new three-dimensional Array of type Int32.
        Array myArr = Array.CreateInstance(typeof(Int32), 2, 3, 4);
        for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++)
        {
            for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++)
            {
                for (int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++)
                {
                    myArr.SetValue((i * 100) + (j * 10) + k, i, j, k);
                }
            }
        }

        // Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length);
        Console.WriteLine("\tLength\tLower\tUpper");
        for (int i = 0; i < myArr.Rank; i++)
        {
            Console.Write("{0}:\t{1}", i, myArr.GetLength(i));
            Console.WriteLine("\t{0}\t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i));
        }

        // Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:");
        PrintValues(myArr);
    }


    public static void PrintValues(Array myArr)
    {
        System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
        int i = 0;
        int cols = myArr.GetLength(myArr.Rank - 1);
        while (myEnumerator.MoveNext())
        {
            if (i < cols)
            {
                i++;
            }
            else
            {
                Console.WriteLine();
                i = 1;
            }
            Console.Write("\t{0}", myEnumerator.Current);
        }
        Console.WriteLine();
    }
}
/* 
This code produces the following output.

The Array has 3 dimension(s) and a total of 24 elements.
    Length    Lower    Upper
0:    2    0    1
1:    3    0    2
2:    4    0    3
The Array contains the following values:
    0    1    2    3
    10    11    12    13
    20    21    22    23
    100    101    102    103
    110    111    112    113
    120    121    122    123
*/
Public Class SamplesArray2

    Public Shared Sub Main()

        ' Creates and initializes a new three-dimensional Array of
        ' type Int32.
        Dim myArr As Array = Array.CreateInstance(GetType(Int32), 2, 3, 4)
        Dim i As Integer
        For i = myArr.GetLowerBound(0) To myArr.GetUpperBound(0)
            Dim j As Integer
            For j = myArr.GetLowerBound(1) To myArr.GetUpperBound(1)
                Dim k As Integer
                For k = myArr.GetLowerBound(2) To myArr.GetUpperBound(2)
                    myArr.SetValue(i * 100 + j * 10 + k, i, j, k)
                Next k
            Next j
        Next i ' Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a " _
           + "total of {1} elements.", myArr.Rank, myArr.Length)
        Console.WriteLine(ControlChars.Tab + "Length" + ControlChars.Tab _
           + "Lower" + ControlChars.Tab + "Upper")
        For i = 0 To myArr.Rank - 1
            Console.Write("{0}:" + ControlChars.Tab + "{1}", i,
               myArr.GetLength(i))
            Console.WriteLine(ControlChars.Tab + "{0}" + ControlChars.Tab _
               + "{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i))
        Next i

        ' Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintValues(myArr)
    End Sub

    Public Shared Sub PrintValues(myArr As Array)
        Dim myEnumerator As System.Collections.IEnumerator =
           myArr.GetEnumerator()
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
        While myEnumerator.MoveNext()
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' The Array has 3 dimension(s) and a total of 24 elements.
'     Length    Lower    Upper
' 0:    2    0    1
' 1:    3    0    2
' 2:    4    0    3
' The Array contains the following values:
'     0    1    2    3
'     10    11    12    13
'     20    21    22    23
'     100    101    102    103
'     110    111    112    113
'     120    121    122    123 

Poznámky

Třída není součástí System.Collections oborů názvů. ArrayThe Array class is not part of the System.Collections namespaces. Je však stále považována za kolekci, protože je založena na IList rozhraní.However, it is still considered a collection because it is based on the IList interface.

Array Třída je základní třídou pro jazykové implementace, které podporují pole.The Array class is the base class for language implementations that support arrays. Pouze systém a kompilátory však mohou být odvozeny explicitně od Array třídy.However, only the system and compilers can derive explicitly from the Array class. Uživatelé by měli používat konstrukce pole poskytované jazykem.Users should employ the array constructs provided by the language.

Element je hodnota v Array.An element is a value in an Array. Délka Array je celkový počet prvků, které může obsahovat.The length of an Array is the total number of elements it can contain. Dolní mez Array prvku je index jeho prvního prvku.The lower bound of an Array is the index of its first element. Objekt Array může mít dolní mez, ale ve výchozím nastavení má dolní mez nula.An Array can have any lower bound, but it has a lower bound of zero by default. Při vytváření instance Array třídy pomocí CreateInstanceje možné definovat jinou dolní mez. Multidimenzionální Array výraz může mít různé meze pro každou dimenzi.A different lower bound can be defined when creating an instance of the Array class using CreateInstance.A multidimensional Array can have different bounds for each dimension. Pole může mít maximálně 32 dimenzí.An array can have a maximum of 32 dimensions.

Na rozdíl od tříd v System.Collections Array oborech názvů má pevnou kapacitu.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. Chcete-li zvýšit kapacitu, je nutné vytvořit nový Array objekt s požadovanou kapacitou, zkopírovat prvky z původního Array objektu do nového a odstranit starou Array.To increase the capacity, you must create a new Array object with the required capacity, copy the elements from the old Array object to the new one, and delete the old Array.

Velikost pole je omezená na celkem 4 000 000 000 prvků a maximálního indexu 0X7FEFFFFF v jakékoli dané dimenzi (0X7FFFFFC7 pro pole bajtů a pole jednobajtových struktur).The array size is limited to a total of 4 billion elements, and to a maximum index of 0X7FEFFFFF in any given dimension (0X7FFFFFC7 for byte arrays and arrays of single-byte structures).

Pouze .NET Framework: Ve výchozím nastavení Array je maximální velikost velikosti 2 gigabajty (GB)..NET Framework only: By default, the maximum size of an Array is 2 gigabytes (GB). V 64ovém prostředí se můžete vyhnout omezení enabled velikosti nastavením atributu gcAllowVeryLargeObjects konfiguračního elementu na true v běhovém prostředí.In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment.

Jednorozměrná System.Collections.Generic.IList<T>pole implementují System.Collections.Generic.IEnumerable<T> System.Collections.Generic.ICollection<T> ObecnáSystem.Collections.Generic.IReadOnlyCollection<T> rozhraní,, System.Collections.Generic.IReadOnlyList<T> a.Single-dimensional arrays implement the System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> and System.Collections.Generic.IReadOnlyCollection<T> generic interfaces. Implementace jsou k dispozici pro pole za běhu a v důsledku toho se obecná rozhraní nezobrazí v syntaxi deklarace pro Array třídu.The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class. Kromě toho neexistují žádná referenční témata pro členy rozhraní, které jsou přístupné pouze přetypováním pole na typ obecného rozhraní (implementace explicitního rozhraní).In addition, there are no reference topics for interface members that are accessible only by casting an array to the generic interface type (explicit interface implementations). Klíčovým aspektem, který je třeba znát při přetypování pole do jednoho z těchto rozhraní, je, že členy, které přidávají, vkládají NotSupportedExceptionnebo odebírají elementy throw.The key thing to be aware of when you cast an array to one of these interfaces is that members which add, insert, or remove elements throw NotSupportedException.

Typeobjekty poskytují informace o deklaracích typu pole.Type objects provide information about array type declarations. Arrayobjekty se stejným typem pole sdílejí stejný Type objekt.Array objects with the same array type share the same Type object.

Type.IsArraya Type.GetElementType nemusí vracet očekávané Array výsledky, protože pokud je pole přetypování na typ Array, výsledkem je objekt, nikoli pole.Type.IsArray and Type.GetElementType might not return the expected results with Array because if an array is cast to the type Array, the result is an object, not an array. To znamená, typeof(System.Array).IsArray vrátí falsea typeof(System.Array).GetElementType vrátí. nullThat is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

Array.Copy Metoda kopíruje prvky nejen mezi poli stejného typu, ale také mezi standardními poli různých typů. zpracovává automatické přetypování typu.The Array.Copy method copies elements not only between arrays of the same type but also between standard arrays of different types; it handles type casting automatically.

CreateInstanceNěkteré metody, jako například CopyTo, Copy GetValue,, a SetValue, poskytují přetížení, která přijímají 64 celá čísla jako parametry pro přizpůsobení velkých polí kapacity.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLengtha GetLongLength vracejí 64 bitů celých čísel, která označují délku pole.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

Array Není zaručeno řazení.The Array is not guaranteed to be sorted. Array Před prováděním operací ( BinarySearchnapříklad), které vyžadují Array , aby bylo možné řadit, je nutné provést řazení.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

Použití objektu ukazatelů v nativním kódu není podporováno a NotSupportedException vyvolá pro několik metod. ArrayUsing an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Vlastnosti

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Načte hodnotu, která označuje, Array zda má pevnou velikost.Gets a value indicating whether the Array has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Načte hodnotu, která označuje, Array jestli je jen pro čtení.Gets a value indicating whether the Array is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Načte hodnotu, která označuje, jestli se Array má synchronizovat přístup k aplikaci (bezpečné pro přístup z více vláken).Gets a value indicating whether access to the Array is synchronized (thread safe).

Length Length Length Length

Získá celkový počet prvků ve všech dimenzích Array.Gets the total number of elements in all the dimensions of the Array.

LongLength LongLength LongLength LongLength

Získá 64 celé číslo, které představuje celkový počet prvků ve všech dimenzích Array.Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank Rank Rank Rank

Získá pořadí (počet rozměrů) Arraypro.Gets the rank (number of dimensions) of the Array. Například jednorozměrné pole vrátí 1, dvourozměrné pole vrátí 2 atd.For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot SyncRoot SyncRoot SyncRoot

Získává objekt, který lze použít k synchronizaci přístupu k Array.Gets an object that can be used to synchronize access to the Array.

Metody

AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[])

Vrátí obálku určenou jen pro čtení pro zadané pole.Returns a read-only wrapper for the specified array.

BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object)

Vyhledá v řadě prvků v jednorozměrném poli pro hodnotu pomocí IComparable rozhraní implementovaného jednotlivými prvky pole a zadanou hodnotou.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value.

BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer)

Vyhledá v řadě prvků v jednorozměrném poli pro hodnotu pomocí zadaného IComparer rozhraní.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

BinarySearch(Array, Object) BinarySearch(Array, Object) BinarySearch(Array, Object) BinarySearch(Array, Object)

Vyhledá celé jednorozměrné pole seřazené pro konkrétní element pomocí IComparable rozhraní implementovaného jednotlivými prvky pole a zadaným objektem.Searches an entire one-dimensional sorted array for a specific element, using the IComparable interface implemented by each element of the array and by the specified object.

BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer)

Vyhledá v celém jednorozměrném poli hodnotu pomocí zadaného IComparer rozhraní.Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T) BinarySearch<T>(T[], Int32, Int32, T)

Vyhledá v řadě prvků v jednorozměrném poli pro hodnotu pomocí IComparable<T> obecného rozhraní implementovaného jednotlivými prvky Array a zadanou hodnotou.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable<T> generic interface implemented by each element of the Array and by the specified value.

BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)

Vyhledá v řadě prvků v jednorozměrném poli pro hodnotu pomocí zadaného IComparer<T> obecného rozhraní.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer<T> generic interface.

BinarySearch<T>(T[], T) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T)

Vyhledá celé jednorozměrné pole seřazené pro konkrétní element pomocí IComparable<T> obecného rozhraní implementovaného jednotlivými prvky Array a zadaným objektem.Searches an entire one-dimensional sorted array for a specific element, using the IComparable<T> generic interface implemented by each element of the Array and by the specified object.

BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>)

Vyhledá v celém jednorozměrném poli hodnotu pomocí zadaného IComparer<T> obecného rozhraní.Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32)

Nastaví rozsah prvků v poli na výchozí hodnotu každého typu elementu.Sets a range of elements in an array to the default value of each element type.

Clone() Clone() Clone() Clone()

Vytvoří kopii v Arraychráněném umístění.Creates a shallow copy of the Array.

ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32)

Zkopíruje rozsah prvků od Array začátku v zadaném zdrojovém indexu a vloží je do jiného Array počínaje zadaným cílovým indexem.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Garantuje, že všechny změny jsou vráceny, pokud kopie není zcela úspěšná.Guarantees that all changes are undone if the copy does not succeed completely.

ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)

Převede pole jednoho typu na pole jiného typu.Converts an array of one type to an array of another type.

Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32)

Zkopíruje rozsah prvků od Array začátku prvního prvku a vloží je do jiného Array počínaje prvním prvkem.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Délka je určena jako 32 celé číslo.The length is specified as a 32-bit integer.

Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64)

Zkopíruje rozsah prvků od Array začátku prvního prvku a vloží je do jiného Array počínaje prvním prvkem.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. Délka je určena jako 64 celé číslo.The length is specified as a 64-bit integer.

Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32)

Zkopíruje rozsah prvků od Array začátku v zadaném zdrojovém indexu a vloží je do jiného Array počínaje zadaným cílovým indexem.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Délka a indexy jsou zadány jako čísla 32 bitů.The length and the indexes are specified as 32-bit integers.

Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64)

Zkopíruje rozsah prvků od Array začátku v zadaném zdrojovém indexu a vloží je do jiného Array počínaje zadaným cílovým indexem.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Délka a indexy jsou zadány jako čísla 64 bitů.The length and the indexes are specified as 64-bit integers.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Zkopíruje všechny prvky aktuálního jednorozměrného pole do určeného jednorozměrného pole začínajícího v zadaném indexu pole cíle.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. Index je zadaný jako 32 celé číslo.The index is specified as a 32-bit integer.

CopyTo(Array, Int64) CopyTo(Array, Int64) CopyTo(Array, Int64) CopyTo(Array, Int64)

Zkopíruje všechny prvky aktuálního jednorozměrného pole do určeného jednorozměrného pole začínajícího v zadaném indexu pole cíle.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. Index je zadaný jako 64 celé číslo.The index is specified as a 64-bit integer.

CreateInstance(Type, Int32) CreateInstance(Type, Int32) CreateInstance(Type, Int32) CreateInstance(Type, Int32)

Vytvoří jednorozměrné zadání Type a délku s nulovým indexováním. ArrayCreates a one-dimensional Array of the specified Type and length, with zero-based indexing.

CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32)

Vytvoří dvojrozměrné Array hodnoty z určených Type hodnot a délkových dimenzí s nulovým indexováním.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32)

Vytvoří trojrozměrného Array typu Type a délky dimenzí s nulovým indexováním.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[])

Vytvoří multidimenzionální Array hodnotu z určeného Type a kótovacích délek s nulovým indexováním.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Délky dimenzí jsou určeny v poli 32 celých čísel.The dimension lengths are specified in an array of 32-bit integers.

CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[])

Vytvoří multidimenzionální Array hodnotu z určeného Type a délky dimenzí se zadanými dolními mezemi.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[])

Vytvoří multidimenzionální Array hodnotu z určeného Type a kótovacích délek s nulovým indexováním.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Délky dimenzí jsou určeny v poli 64 celých čísel.The dimension lengths are specified in an array of 64-bit integers.

Empty<T>() Empty<T>() Empty<T>() Empty<T>()

Vrátí prázdné pole.Returns an empty array.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>)

Určuje, zda zadané pole obsahuje prvky, které odpovídají podmínkám definovaným zadaným predikátem.Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T)
Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32)
Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí první výskyt v celém Array.Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>)

Načte všechny prvky, které splňují podmínky definované zadaným predikátem.Retrieves all the elements that match the conditions defined by the specified predicate.

FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaných zadaným predikátem, a vrátí index začínající nulou prvního výskytu v rámci rozsahu prvků v Array prvku, který začíná zadaným indexem a obsahuje zadané číslo. prvků.Searches for an element that matches the conditions defined by the specified 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.

FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaných zadaným predikátem, a vrátí index s hodnotou nula prvního výskytu v rámci rozsahu prvků v Array objektu, který sahá od zadaného indexu k poslednímu prvku.Searches for an element that matches the conditions defined by the specified 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.

FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaných zadaným predikátem, a vrátí index prvního výskytu prvního výskytu v rámci celého Arrayprvku.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire Array.

FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaných zadaným predikátem, a vrátí poslední výskyt v rámci celého Arrayprvku.Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire Array.

FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí index posledního výskytu od nuly v rámci rozsahu prvků v Array prvku, který obsahuje zadaný počet prvků a končí na zadaný index.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaných zadaným predikátem, a vrátí index posledního výskytu od nuly v rámci rozsahu prvků v Array objektu, který se rozšíří od prvního prvku na zadaný index.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>)

Vyhledá prvek, který odpovídá podmínkám definovaným pomocí zadaného predikátu, a vrátí index posledního výskytu posledního výskytu v rámci celého Arrayobjektu.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire Array.

ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>)

Provede zadanou akci pro každý prvek určeného pole.Performs the specified action on each element of the specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

IEnumerator VrátíArraypro.Returns an IEnumerator for the Array.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Inherited from Object)
GetLength(Int32) GetLength(Int32) GetLength(Int32) GetLength(Int32)

Získá 32 celé číslo, které představuje počet prvků v zadané dimenzi Array.Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

GetLongLength(Int32) GetLongLength(Int32) GetLongLength(Int32) GetLongLength(Int32)

Získá 64 celé číslo, které představuje počet prvků v zadané dimenzi Array.Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

GetLowerBound(Int32) GetLowerBound(Int32) GetLowerBound(Int32) GetLowerBound(Int32)

Získá index prvního prvku zadané dimenze v poli.Gets the index of the first element of the specified dimension in the array.

GetType() GetType() GetType() GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Inherited from Object)
GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32)

Získá index posledního prvku zadané dimenze v poli.Gets the index of the last element of the specified dimension in the array.

GetValue(Int32) GetValue(Int32) GetValue(Int32) GetValue(Int32)

Získá hodnotu na určené pozici v Arrayjednorozměrném poli.Gets the value at the specified position in the one-dimensional Array. Index je zadaný jako 32 celé číslo.The index is specified as a 32-bit integer.

GetValue(Int32, Int32) GetValue(Int32, Int32) GetValue(Int32, Int32) GetValue(Int32, Int32)

Získá hodnotu na určené pozici v dvojrozměrném Arrayumístění.Gets the value at the specified position in the two-dimensional Array. Indexy jsou udávány jako 32bitová celá čísla.The indexes are specified as 32-bit integers.

GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32)

Získá hodnotu na zadané pozici v trojrozměrném Arrayumístění.Gets the value at the specified position in the three-dimensional Array. Indexy jsou udávány jako 32bitová celá čísla.The indexes are specified as 32-bit integers.

GetValue(Int32[]) GetValue(Int32[]) GetValue(Int32[]) GetValue(Int32[])

Získá hodnotu na určené pozici multidimenzionálního Arrayrozhraní.Gets the value at the specified position in the multidimensional Array. Indexy jsou zadány jako pole s 32 celými čísly.The indexes are specified as an array of 32-bit integers.

GetValue(Int64) GetValue(Int64) GetValue(Int64) GetValue(Int64)

Získá hodnotu na určené pozici v Arrayjednorozměrném poli.Gets the value at the specified position in the one-dimensional Array. Index je zadaný jako 64 celé číslo.The index is specified as a 64-bit integer.

GetValue(Int64, Int64) GetValue(Int64, Int64) GetValue(Int64, Int64) GetValue(Int64, Int64)

Získá hodnotu na určené pozici v dvojrozměrném Arrayumístění.Gets the value at the specified position in the two-dimensional Array. Indexy jsou udávány jako 64bitová celá čísla.The indexes are specified as 64-bit integers.

GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64)

Získá hodnotu na zadané pozici v trojrozměrném Arrayumístění.Gets the value at the specified position in the three-dimensional Array. Indexy jsou udávány jako 64bitová celá čísla.The indexes are specified as 64-bit integers.

GetValue(Int64[]) GetValue(Int64[]) GetValue(Int64[]) GetValue(Int64[])

Získá hodnotu na určené pozici multidimenzionálního Arrayrozhraní.Gets the value at the specified position in the multidimensional Array. Indexy jsou zadány jako pole s 64 celými čísly.The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

Vyhledá zadaný objekt a vrátí index jeho prvního výskytu v jednorozměrném poli.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32)

Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index jeho prvního výskytu.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Rozsah se rozšíří od zadaného indexu až po konec pole.The range extends from a specified index to the end of the array.

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32)

Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index IFS prvního výskytu.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. Rozsah se rozšiřuje od zadaného indexu pro zadaný počet prvků.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

Vyhledá zadaný objekt a vrátí index jeho prvního výskytu v jednorozměrném poli.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32) IndexOf<T>(T[], T, Int32)

Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index jeho prvního výskytu.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. Rozsah se rozšíří od zadaného indexu až po konec pole.The range extends from a specified index to the end of the array.

IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32) IndexOf<T>(T[], T, Int32, Int32)

Vyhledá zadaný objekt v rozsahu prvků jednorozměrného pole a vrátí index jeho prvního výskytu.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. Rozsah se rozšiřuje od zadaného indexu pro zadaný počet prvků.The range extends from a specified index for a specified number of elements.

Initialize() Initialize() Initialize() Initialize()

Inicializuje všechny prvky typu Array hodnoty voláním konstruktoru bez parametrů typu hodnoty.Initializes every element of the value-type Array by calling the parameterless constructor of the value type.

LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object)

Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci celého jednorozměrného Arrayobjektu.Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32)

Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci rozsahu prvků v jednorozměrném Array prvku, který se rozšíří od prvního prvku na zadaný index.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that extends from the first element to the specified index.

LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32)

Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci rozsahu prvků v jednorozměrném Array prvku, který obsahuje zadaný počet prvků a končí v zadaném indexu.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that contains the specified number of elements and ends at the specified index.

LastIndexOf<T>(T[], T) LastIndexOf<T>(T[], T) LastIndexOf<T>(T[], T) LastIndexOf<T>(T[], T)

Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci celého Arrayobjektu.Searches for the specified object and returns the index of the last occurrence within the entire Array.

LastIndexOf<T>(T[], T, Int32) LastIndexOf<T>(T[], T, Int32) LastIndexOf<T>(T[], T, Int32) LastIndexOf<T>(T[], T, Int32)

Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci rozsahu prvků v Array objektu, který se rozšíří od prvního prvku na zadaný index.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

LastIndexOf<T>(T[], T, Int32, Int32) LastIndexOf<T>(T[], T, Int32, Int32) LastIndexOf<T>(T[], T, Int32, Int32) LastIndexOf<T>(T[], T, Int32, Int32)

Vyhledá zadaný objekt a vrátí index posledního výskytu v rámci rozsahu prvků v Array prvku, který obsahuje zadaný počet prvků a končí v zadaném indexu.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Vytvoří Mělkou kopii aktuální Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32)

Změní počet prvků jednorozměrného pole na určenou novou velikost.Changes the number of elements of a one-dimensional array to the specified new size.

Reverse(Array) Reverse(Array) Reverse(Array) Reverse(Array)

Obrátí sekvenci prvků v celém Arrayjednorozměrném prvku.Reverses the sequence of the elements in the entire one-dimensional Array.

Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32)

Obrátí sekvenci prvků v rozsahu prvků Arrayjednorozměrného.Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

Reverse<T>(T[]) Reverse<T>(T[]) Reverse<T>(T[]) Reverse<T>(T[])
Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32)
SetValue(Object, Int32) SetValue(Object, Int32) SetValue(Object, Int32) SetValue(Object, Int32)

Nastaví hodnotu na prvek na zadané pozici v Arrayjednorozměrném.Sets a value to the element at the specified position in the one-dimensional Array. Index je zadaný jako 32 celé číslo.The index is specified as a 32-bit integer.

SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32)

Nastaví hodnotu na prvek na zadané pozici v dvojrozměrné Array.Sets a value to the element at the specified position in the two-dimensional Array. Indexy jsou udávány jako 32bitová celá čísla.The indexes are specified as 32-bit integers.

SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32)

Nastaví hodnotu na prvek na zadané pozici v trojrozměrném Arrayumístění.Sets a value to the element at the specified position in the three-dimensional Array. Indexy jsou udávány jako 32bitová celá čísla.The indexes are specified as 32-bit integers.

SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[])

Nastaví hodnotu na prvek na zadané pozici v multidimenzionálním Arrayelementu.Sets a value to the element at the specified position in the multidimensional Array. Indexy jsou zadány jako pole s 32 celými čísly.The indexes are specified as an array of 32-bit integers.

SetValue(Object, Int64) SetValue(Object, Int64) SetValue(Object, Int64) SetValue(Object, Int64)

Nastaví hodnotu na prvek na zadané pozici v Arrayjednorozměrném.Sets a value to the element at the specified position in the one-dimensional Array. Index je zadaný jako 64 celé číslo.The index is specified as a 64-bit integer.

SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64)

Nastaví hodnotu na prvek na zadané pozici v dvojrozměrné Array.Sets a value to the element at the specified position in the two-dimensional Array. Indexy jsou udávány jako 64bitová celá čísla.The indexes are specified as 64-bit integers.

SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64)

Nastaví hodnotu na prvek na zadané pozici v trojrozměrném Arrayumístění.Sets a value to the element at the specified position in the three-dimensional Array. Indexy jsou udávány jako 64bitová celá čísla.The indexes are specified as 64-bit integers.

SetValue(Object, Int64[]) SetValue(Object, Int64[]) SetValue(Object, Int64[]) SetValue(Object, Int64[])

Nastaví hodnotu na prvek na zadané pozici v multidimenzionálním Arrayelementu.Sets a value to the element at the specified position in the multidimensional Array. Indexy jsou zadány jako pole s 64 celými čísly.The indexes are specified as an array of 64-bit integers.

Sort(Array) Sort(Array) Sort(Array) Sort(Array)

Seřadí prvky v celém Array jednorozměrném prvku IComparable pomocí implementace každého elementu Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Seřadí dvojici Array jednorozměrného objektu (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable implementace každého klíče.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Seřadí dvojici Array jednorozměrného objektu (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32)

Seřadí rozsah prvků ve dvojici jednorozměrného Array objektu (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable implementace každého klíče.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer)

Seřadí rozsah prvků ve dvojici jednorozměrného Array objektu (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Seřadí prvky v jednorozměrném Array formátu pomocí zadaného IComparerprvku.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Seřadí prvky v rozsahu prvků Array jednorozměrném IComparable pomocí implementace každého elementu Array.Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Seřadí prvky v rozsahu prvků Array jednorozměrném pomocí určeného IComparertypu.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[])

Seřadí prvky v rámci celého Array IComparable<T> pomocí implementace obecného rozhraní každého elementu Array.Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Seřadí prvky v Array zadaném Comparison<T>formátu.Sorts the elements in an Array using the specified Comparison<T>.

Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>)

Seřadí prvky v rámci Array pomocí zadaného IComparer<T> obecného rozhraní.Sorts the elements in an Array using the specified IComparer<T> generic interface.

Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32) Sort<T>(T[], Int32, Int32)

Seřadí prvky v rozsahu prvků v Array rámci IComparable<T> pomocí implementace obecného rozhraní každého elementu Array.Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Seřadí prvky v rozsahu prvků v Array rámci pomocí zadaného IComparer<T> obecného rozhraní.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Seřadí dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable<T> implementace obecného rozhraní každého klíče.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Seřadí dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer<T> obecného rozhraní.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Seřadí rozsah prvků ve dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí IComparable<T> implementace obecného rozhraní každého klíče.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Seřadí rozsah prvků ve dvojici Array objektů (jeden obsahuje klíče a druhý obsahuje odpovídající položky) na základě klíčů v prvním Array pomocí zadaného IComparer<T> obecného rozhraní.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

ToString() ToString() ToString() ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Inherited from Object)
TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>)

Určuje, zda každý prvek v poli odpovídá podmínkám definovaným zadaným predikátem.Determines whether every element in the array matches the conditions defined by the specified predicate.

Explicitní implementace rozhraní

ICollection.Count ICollection.Count ICollection.Count ICollection.Count

Získá počet prvků obsažených v Array.Gets the number of elements contained in the Array.

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

Získá hodnotu, která označuje, zda je přístup Array k aplikaci synchronizován (bezpečné pro přístup z více vláken).Gets a value that indicates whether access to the Array is synchronized (thread safe).

ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

Získává objekt, který lze použít k synchronizaci přístupu k Array.Gets an object that can be used to synchronize access to the Array.

IList.Add(Object) IList.Add(Object) IList.Add(Object) IList.Add(Object)

Volání této metody vždy vyvolá NotSupportedException výjimku.Calling this method always throws a NotSupportedException exception.

IList.Clear() IList.Clear() IList.Clear() IList.Clear()

Odebere všechny položky z IList.Removes all items from the IList.

IList.Contains(Object) IList.Contains(Object) IList.Contains(Object) IList.Contains(Object)

Určuje, zda je element v IList.Determines whether an element is in the IList.

IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object)

Určuje index konkrétní položky v IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object)

Vloží položku na IList zadaný index.Inserts an item to the IList at the specified index.

IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize

Získá hodnotu, která označuje, zda Array má pevnou velikost.Gets a value that indicates whether the Array has a fixed size.

IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly

Získá hodnotu, která označuje, zda Array je pouze pro čtení.Gets a value that indicates whether the Array is read-only.

IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] IList.Item[Int32]

Získá nebo nastaví prvek na zadaný index.Gets or sets the element at the specified index.

IList.Remove(Object) IList.Remove(Object) IList.Remove(Object) IList.Remove(Object)

Odebere první výskyt konkrétního objektu z IList.Removes the first occurrence of a specific object from the IList.

IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32)

IList Odebere položku na zadaném indexu.Removes the IList item at the specified index.

IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer)

Určuje, zda aktuální objekt kolekce předchází, probíhá ve stejné pozici jako nebo následuje za jiným objektem v pořadí řazení.Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.

IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer)

Určuje, zda je objekt stejný jako aktuální instance.Determines whether an object is equal to the current instance.

IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer)

Vrátí kód hodnoty hash aktuální instance.Returns a hash code for the current instance.

Metody rozšíření

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

IEnumerable PřevedeIQueryablena.Converts an IEnumerable to an IQueryable.

Platí pro

Bezpečný přístup z více vláken

Veřejné statické (Shared v Visual Basic) členy tohoto typu jsou bezpečné pro přístup z více vláken.Public static (Shared in Visual Basic) members of this type are thread safe. Není zaručeno, že členy instancí jsou bezpečné pro přístup z více vláken.Any instance members are not guaranteed to be thread safe.

Tato implementace neposkytuje synchronizovanou obálku (bezpečnou pro přístup z více Arrayvláken) pro třídu, ale .NET Framework Array třídy založené na poskytnutí vlastní synchronizované verze kolekce pomocí SyncRoot vlastnosti.This implementation does not provide a synchronized (thread safe) wrapper for an Array; however, .NET Framework classes based on Array provide their own synchronized version of the collection using the SyncRoot property.

Výčet prostřednictvím kolekce nemůže být procedurou bezpečnou pro přístup z více vláken.Enumerating through a collection is intrinsically not a thread-safe procedure. I v případě, že jde o synchronizovanou kolekci, mohou úpravy provádět i ostatní vlákna, což způsobuje vyvolání výjimky enumerátorem.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. K zaručení bezpečnosti přístupu z více vláken můžete buďto zamknout kolekci na celou dobu práce s výčtem, nebo zachycovat výjimky vzniklé v důsledku změn prováděných ostatními vlákny.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Viz také