Array 클래스

정의

배열을 만들고, 조작하고, 검색 및 정렬하여 공용 언어 런타임에서 모든 배열의 기본 클래스 역할을 수행하도록 하는 메서드를 제공합니다.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
상속
Array
특성
구현

예제

다음 코드 예제에서는 정수 형식의 배열과 Object형식의 배열 사이에 Array.Copy 요소를 복사 하는 방법을 보여 줍니다.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

다음 코드 예제에서는 Array을 만들어 초기화 하 고 해당 속성 및 해당 요소를 표시 합니다.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 

설명

Array 클래스는 System.Collections 네임 스페이스의 일부가 아닙니다.The Array class is not part of the System.Collections namespaces. 그러나 IList 인터페이스를 기반으로 하기 때문에 컬렉션으로 간주 됩니다.However, it is still considered a collection because it is based on the IList interface.

Array 클래스는 배열을 지 원하는 언어 구현에 대 한 기본 클래스입니다.The Array class is the base class for language implementations that support arrays. 그러나 시스템 및 컴파일러는 Array 클래스에서 명시적으로 파생 될 수 있습니다.However, only the system and compilers can derive explicitly from the Array class. 사용자는 언어에서 제공 하는 배열 구문을 사용 해야 합니다.Users should employ the array constructs provided by the language.

요소는 Array의 값입니다.An element is a value in an Array. Array 길이는 포함 될 수 있는 요소의 총 수입니다.The length of an Array is the total number of elements it can contain. Array의 하 한은 첫 번째 요소의 인덱스입니다.The lower bound of an Array is the index of its first element. Array은 하 한을 포함할 수 있지만 기본적으로 하 한이 0입니다.An Array can have any lower bound, but it has a lower bound of zero by default. CreateInstance를 사용 하 여 Array 클래스의 인스턴스를 만들 때 다른 하 한을 정의할 수 있습니다. 다차원 Array는 각 차원에 대해 서로 다른 범위를 사용할 수 있습니다.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. 배열의 최대 크기는 32이 될 수 있습니다.An array can have a maximum of 32 dimensions.

System.Collections 네임 스페이스의 클래스와 달리 Array에는 고정 용량이 있습니다.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. 용량을 늘리려면 필요한 용량을 사용 하 여 새 Array 개체를 만들고 이전 Array 개체의 요소를 새 개체에 복사 하 고 이전 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.

배열 크기는 총 40억 개 요소로 제한 되며 지정 된 차원에서 0X7FEFFFFF의 최대 인덱스 (바이트 배열 및 싱글바이트 구조체의 배열)로 제한 됩니다.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).

.NET Framework에만 해당: 기본적으로 Array의 최대 크기는 2gb입니다..NET Framework only: By default, the maximum size of an Array is 2 gigabytes (GB). 64 비트 환경에서는 런타임 환경에서 gcallowverylargeobjects> 구성 요소의 enabled 특성을 true로 설정 하 여 크기 제한을 방지할 수 있습니다.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.

1 차원 배열은 System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T>System.Collections.Generic.IReadOnlyCollection<T> 제네릭 인터페이스를 구현 합니다.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. 구현은 런타임에 배열에 제공 되며, 따라서 제네릭 인터페이스는 Array 클래스의 선언 구문에 표시 되지 않습니다.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. 또한 배열을 제네릭 인터페이스 형식으로 캐스팅 (명시적 인터페이스 구현) 하 여 액세스할 수 있는 인터페이스 멤버에 대 한 참조 항목이 없습니다.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). 배열을 이러한 인터페이스 중 하나로 캐스팅할 때 알아야 할 주요 사항은 요소를 추가, 삽입 또는 제거 하는 멤버가 NotSupportedExceptionthrow 하는 것입니다.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.

Type 개체는 배열 형식 선언에 대 한 정보를 제공 합니다.Type objects provide information about array type declarations. 배열 형식이 같은 Array 개체가 동일한 Type 개체를 공유 합니다.Array objects with the same array type share the same Type object.

배열이 Array형식으로 캐스팅 된 경우에는 Type.IsArrayType.GetElementType에서 예상한 Array 결과가 반환 되지 않을 수 있습니다. 결과는 배열이 아니라 개체입니다.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. 즉, typeof(System.Array).IsArrayfalse을 반환 하 고, typeof(System.Array).GetElementTypenull을 반환 합니다.That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

Array.Copy 메서드는 동일한 형식의 배열 사이 뿐만 아니라 다른 형식의 표준 배열 사이에 있는 요소를 복사 합니다. 형식 캐스팅을 자동으로 처리 합니다.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.

CreateInstance, Copy, CopyTo, GetValue, SetValue등의 일부 메서드는 대용량 배열을 수용 하기 위해 64 비트 정수를 매개 변수로 허용 하는 오버 로드를 제공 합니다.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLengthGetLongLength은 배열의 길이를 나타내는 64 비트 정수를 반환 합니다.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

Array은 정렬 되지 않을 수도 있습니다.The Array is not guaranteed to be sorted. Array를 정렬 해야 하는 작업 (예: BinarySearch)을 수행 하기 전에 Array를 정렬 해야 합니다.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

네이티브 코드에서 Array 개체의 포인터를 사용 하는 것은 지원 되지 않으며 여러 메서드에 대해 NotSupportedException이 throw 됩니다.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

속성

IsFixedSize

Array의 크기가 고정되어 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the Array has a fixed size.

IsReadOnly

Array가 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the Array is read-only.

IsSynchronized

Array에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지를 나타내는 값을 가져옵니다.Gets a value indicating whether access to the Array is synchronized (thread safe).

Length

모든 차원의 Array에서 요소의 총수를 가져옵니다.Gets the total number of elements in all the dimensions of the Array.

LongLength

Array의 모든 차원에 있는 요소의 총 수를 나타내는 64비트 정수를 가져옵니다.Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank

Array의 순위(차원 수)를 가져옵니다.Gets the rank (number of dimensions) of the Array. 예를 들어, 1차원 배열은 1을 반환하고, 2차원 배열은 2를 반환하는 방식입니다.For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot

Array에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the Array.

메서드

AsReadOnly<T>(T[])

지정한 배열의 읽기 전용 래퍼를 반환합니다.Returns a read-only wrapper for the specified array.

BinarySearch(Array, Int32, Int32, Object)

배열의 각 요소 및 지정한 값에서 구현되는 IComparable 인터페이스를 사용하여 1차원으로 정렬된 배열의 요소 범위에서 값을 검색합니다.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)

지정한 IComparer 인터페이스를 사용하여 1차원으로 정렬된 배열의 요소 범위에서 값을 검색합니다.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

BinarySearch(Array, Object)

배열의 각 요소 및 지정한 개체에서 구현되는 IComparable 인터페이스를 사용하여 1차원으로 정렬된 배열에서 특정 요소를 검색합니다.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)

지정한 IComparer 인터페이스를 사용하여 1차원으로 정렬된 전체 배열에서 값을 검색합니다.Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

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

Array의 각 요소 및 지정한 값에서 구현되는 IComparable<T> 제네릭 인터페이스를 사용하여 1차원으로 정렬된 배열의 요소 범위에서 값을 검색합니다.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>)

지정한 IComparer<T> 제네릭 인터페이스를 사용하여 1차원으로 정렬된 배열의 요소 범위에서 값을 검색합니다.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)

Array의 각 요소 및 지정한 개체에서 구현되는 IComparable<T> 제네릭 인터페이스를 사용하여 1차원으로 정렬된 전체 배열에서 특정 요소를 검색합니다.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>)

지정한 IComparer<T> 제네릭 인터페이스를 사용하여 1차원으로 정렬된 전체 배열에서 값을 검색합니다.Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

Clear(Array, Int32, Int32)

배열의 각 요소 형식의 기본값으로 요소의 범위를 설정합니다.Sets a range of elements in an array to the default value of each element type.

Clone()

Array의 부분 복사본을 만듭니다.Creates a shallow copy of the Array.

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

Array의 요소 범위를 지정한 소스 인덱스부터 복사하여 지정된 대상 인덱스부터 시작하는 다른 Array에 붙여 넣습니다.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. 복사가 완료되지 않으면 모든 변경 내용이 취소되도록 합니다.Guarantees that all changes are undone if the copy does not succeed completely.

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

한 형식의 배열을 다른 형식의 배열로 변환합니다.Converts an array of one type to an array of another type.

Copy(Array, Array, Int32)

Array의 요소 범위를 첫 번째 요소부터 복사하여 다른 Array에 첫 번째 요소부터 붙여넣습니다.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. 길이가 32비트 정수로 지정되어 있습니다.The length is specified as a 32-bit integer.

Copy(Array, Array, Int64)

Array의 요소 범위를 첫 번째 요소부터 복사하여 다른 Array에 첫 번째 요소부터 붙여넣습니다.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. 길이가 64비트 정수로 지정되어 있습니다.The length is specified as a 64-bit integer.

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

Array의 요소 범위를 지정한 소스 인덱스부터 복사하여 지정된 대상 인덱스부터 시작하는 다른 Array에 붙여 넣습니다.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. 길이와 인덱스가 32비트 정수로 지정되어 있습니다.The length and the indexes are specified as 32-bit integers.

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

Array의 요소 범위를 지정한 소스 인덱스부터 복사하여 지정된 대상 인덱스부터 시작하는 다른 Array에 붙여 넣습니다.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. 길이와 인덱스가 64비트 정수로 지정되어 있습니다.The length and the indexes are specified as 64-bit integers.

CopyTo(Array, Int32)

현재 1차원 배열의 모든 요소를 지정된 대상 배열 인덱스부터 시작하여 지정된 1차원 배열에 복사합니다.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. 인덱스가 32비트 정수로 지정되어 있습니다.The index is specified as a 32-bit integer.

CopyTo(Array, Int64)

현재 1차원 배열의 모든 요소를 지정된 대상 배열 인덱스부터 시작하여 지정된 1차원 배열에 복사합니다.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. 인덱스가 64비트 정수로 지정되어 있습니다.The index is specified as a 64-bit integer.

CreateInstance(Type, Int32)

지정한 Type 및 길이를 가진 인덱스가 0부터 시작하는 1차원 Array를 만듭니다.Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

CreateInstance(Type, Int32, Int32)

0부터 시작하는 인덱스를 사용하여 지정된 Type 및 차원 길이의 2차원 Array를 만듭니다.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32, Int32, Int32)

지정한 Type 및 차원 길이를 가진 인덱스가 0부터 시작하는 삼차원 Array를 만듭니다.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32[])

지정한 Type 및 차원 길이를 가진 인덱스가 0부터 시작하는 다차원 Array를 만듭니다.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. 차원 길이가 32비트 정수 배열로 지정되어 있습니다.The dimension lengths are specified in an array of 32-bit integers.

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

지정한 하한을 가진 지정한 Array 및 차원 길이의 다차원 Type를 만듭니다.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

CreateInstance(Type, Int64[])

지정한 Type 및 차원 길이를 가진 인덱스가 0부터 시작하는 다차원 Array를 만듭니다.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. 차원 길이가 64비트 정수 배열로 지정되어 있습니다.The dimension lengths are specified in an array of 64-bit integers.

Empty<T>()

빈 배열을 반환합니다.Returns an empty array.

Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(다음에서 상속됨 Object)
Exists<T>(T[], Predicate<T>)

지정한 배열에 지정한 조건자에 정의된 조건과 일치하는 요소가 포함되어 있는지 여부를 확인합니다.Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

Fill<T>(T[], T)

지정된 array의 각 요소에 T 형식의 지정된 value을 할당합니다.Assigns the given value of type T to each element of the specified array.

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

다음 count 수와 startIndex 범위 내에 있는 지정된 array 요소에 T 형식의 지정된 value을 할당합니다.Assigns the given value of type T to the elements of the specified array which are within the range of startIndex (inclusive) and the next count number of indices.

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

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하고 전체 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>)

지정한 조건자에 정의된 조건과 일치하는 모든 요소를 검색합니다.Retrieves all the elements that match the conditions defined by the specified predicate.

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

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하고 지정된 인덱스부터 시작하여 지정된 수의 요소를 포함하는 Array의 요소 범위에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.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>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 지정된 인덱스에서 마지막 요소로 확장하는 Array의 요소 범위에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.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>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 전체 Array에서 일치하는 요소 중 첫 번째 요소의 인덱스(0부터 시작)를 반환합니다.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>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하고 전체 Array에서 마지막으로 검색한 요소를 반환합니다.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>)

지정한 조건자에 정의된 조건과 일치하는 요소를 검색하여 지정한 수의 요소가 들어 있고 지정한 인덱스에서 끝나는 Array의 요소 범위에서 일치하는 요소 중 마지막 요소의 인덱스(0부터 시작)를 반환합니다.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>)

지정된 조건자에 정의된 조건과 일치하는 요소를 검색하여 첫 번째 요소에서 지정된 인덱스로 확장하는 Array의 요소 범위에서 일치하는 요소 중 마지막 요소의 인덱스(0부터 시작)를 반환합니다.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>)

지정한 조건자에 정의된 조건과 일치하는 요소를 검색하여 전체 Array에서 일치하는 요소 중 마지막 요소의 인덱스(0부터 시작)를 반환합니다.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>)

지정한 배열의 각 요소에서 지정한 동작을 수행합니다.Performs the specified action on each element of the specified array.

GetEnumerator()

IEnumerator 에 대한 Array를 반환합니다.Returns an IEnumerator for the Array.

GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(다음에서 상속됨 Object)
GetLength(Int32)

지정된 차원의 Array에 있는 요소의 수를 나타내는 32비트 정수를 가져옵니다.Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

GetLongLength(Int32)

지정된 차원의 Array에 있는 요소의 수를 나타내는 64비트 정수를 가져옵니다.Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

GetLowerBound(Int32)

배열에서 지정된 차원의 첫 번째 요소의 인덱스를 가져옵니다.Gets the index of the first element of the specified dimension in the array.

GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(다음에서 상속됨 Object)
GetUpperBound(Int32)

배열에서 지정된 차원의 마지막 요소의 인덱스를 가져옵니다.Gets the index of the last element of the specified dimension in the array.

GetValue(Int32)

1차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the one-dimensional Array. 인덱스가 32비트 정수로 지정되어 있습니다.The index is specified as a 32-bit integer.

GetValue(Int32, Int32)

이차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the two-dimensional Array. 인덱스가 32비트 정수로 지정되어 있습니다.The indexes are specified as 32-bit integers.

GetValue(Int32, Int32, Int32)

삼차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the three-dimensional Array. 인덱스가 32비트 정수로 지정되어 있습니다.The indexes are specified as 32-bit integers.

GetValue(Int32[])

다차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the multidimensional Array. 인덱스가 32비트 정수 배열로 지정되어 있습니다.The indexes are specified as an array of 32-bit integers.

GetValue(Int64)

1차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the one-dimensional Array. 인덱스가 64비트 정수로 지정되어 있습니다.The index is specified as a 64-bit integer.

GetValue(Int64, Int64)

이차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the two-dimensional Array. 인덱스가 64비트 정수로 지정되어 있습니다.The indexes are specified as 64-bit integers.

GetValue(Int64, Int64, Int64)

삼차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the three-dimensional Array. 인덱스가 64비트 정수로 지정되어 있습니다.The indexes are specified as 64-bit integers.

GetValue(Int64[])

다차원 Array의 지정한 위치에서 값을 가져옵니다.Gets the value at the specified position in the multidimensional Array. 인덱스가 64비트 정수 배열로 지정되어 있습니다.The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object)

지정한 개체를 검색하여 1차원 배열에서 처음 검색된 개체의 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. 범위는 지정한 인덱스에서 배열의 끝까지 확장됩니다.The range extends from a specified index to the end of the array.

IndexOf(Array, Object, Int32, Int32)

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. 범위는 지정한 요소 수에 대해 지정한 인덱스에서 확장됩니다.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T)

지정한 개체를 검색하여 1차원 배열에서 처음 검색된 개체의 인덱스를 반환합니다.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

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

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. 범위는 지정한 인덱스에서 배열의 끝까지 확장됩니다.The range extends from a specified index to the end of the array.

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

1차원 배열의 요소 범위에서 지정한 개체를 검색하여 처음으로 일치하는 인덱스를 반환합니다.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. 범위는 지정한 요소 수에 대해 지정한 인덱스에서 확장됩니다.The range extends from a specified index for a specified number of elements.

Initialize()

해당 값 형식의 매개 변수가 없는 생성자를 호출하여 값 형식 Array의 모든 요소를 초기화합니다.Initializes every element of the value-type Array by calling the parameterless constructor of the value type.

LastIndexOf(Array, Object)

지정한 개체를 검색하여 1차원 Array 전체에서 마지막으로 일치하는 요소의 인덱스를 반환합니다.Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

LastIndexOf(Array, Object, Int32)

지정한 개체를 검색하여 첫 번째 요소에서 지정한 인덱스로 확장하는 1차원 Array의 요소 범위에서 마지막으로 검색된 요소의 인덱스를 반환합니다.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)

지정한 개체를 검색하여 지정한 수의 요소를 포함하고 지정한 인덱스에서 끝나는 1차원 Array의 요소 범위에서 마지막으로 검색된 요소의 인덱스를 반환합니다.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)

지정한 개체를 검색하여 전체 Array에서 마지막으로 검색된 요소의 인덱스를 반환합니다.Searches for the specified object and returns the index of the last occurrence within the entire Array.

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

지정한 개체를 검색하여 첫 번째 요소에서 지정한 인덱스로 확장하는 Array의 요소 범위에서 마지막으로 검색된 요소의 인덱스를 반환합니다.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)

지정한 개체를 검색하여 지정한 수의 요소를 포함하고 지정한 인덱스에서 끝나는 Array의 요소 범위에서 마지막으로 검색된 요소의 인덱스를 반환합니다.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()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(다음에서 상속됨 Object)
Resize<T>(T[], Int32)

1차원 배열의 요소 수를 지정된 새로운 크기로 변경합니다.Changes the number of elements of a one-dimensional array to the specified new size.

Reverse(Array)

1차원 Array 전체에 있는 요소의 시퀀스를 역순으로 설정합니다.Reverses the sequence of the elements in the entire one-dimensional Array.

Reverse(Array, Int32, Int32)

1차원 Array의 요소 범위에 있는 요소의 시퀀스를 역순으로 설정합니다.Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

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

값을 1차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the one-dimensional Array. 인덱스가 32비트 정수로 지정되어 있습니다.The index is specified as a 32-bit integer.

SetValue(Object, Int32, Int32)

값을 이차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the two-dimensional Array. 인덱스가 32비트 정수로 지정되어 있습니다.The indexes are specified as 32-bit integers.

SetValue(Object, Int32, Int32, Int32)

값을 삼차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the three-dimensional Array. 인덱스가 32비트 정수로 지정되어 있습니다.The indexes are specified as 32-bit integers.

SetValue(Object, Int32[])

값을 다차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the multidimensional Array. 인덱스가 32비트 정수 배열로 지정되어 있습니다.The indexes are specified as an array of 32-bit integers.

SetValue(Object, Int64)

값을 1차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the one-dimensional Array. 인덱스가 64비트 정수로 지정되어 있습니다.The index is specified as a 64-bit integer.

SetValue(Object, Int64, Int64)

값을 이차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the two-dimensional Array. 인덱스가 64비트 정수로 지정되어 있습니다.The indexes are specified as 64-bit integers.

SetValue(Object, Int64, Int64, Int64)

값을 삼차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the three-dimensional Array. 인덱스가 64비트 정수로 지정되어 있습니다.The indexes are specified as 64-bit integers.

SetValue(Object, Int64[])

값을 다차원 Array에 있는 지정한 위치의 요소로 설정합니다.Sets a value to the element at the specified position in the multidimensional Array. 인덱스가 64비트 정수 배열로 지정되어 있습니다.The indexes are specified as an array of 64-bit integers.

Sort(Array)

Array에 있는 각 요소의 IComparable 구현을 사용하여 1차원 Array 전체의 요소를 정렬합니다.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Array)

각 키의 Array 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 IComparable 개체(키를 포함하는 개체와 해당 항목을 포함하는 개체)를 정렬합니다.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)

지정한 Array를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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)

각 키의 Array 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 IComparable 개체(키를 포함하는 개체와 해당 항목을 포함하는 개체)의 요소 범위를 정렬합니다.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)

지정한 Array를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 1차원 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)

지정한 Array를 사용하여 1차원 IComparer의 요소를 정렬합니다.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Int32, Int32)

Array에 있는 각 요소의 IComparable 구현을 사용하여 1차원 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)

지정한 Array를 사용하여 1차원 IComparer의 요소 범위에 있는 요소를 정렬합니다.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

Sort<T>(T[])

Array에 있는 각 요소의 IComparable<T> 제네릭 인터페이스 구현을 사용하여 전체 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>)

지정한 Array을 사용하여 Comparison<T>의 요소를 정렬합니다.Sorts the elements in an Array using the specified Comparison<T>.

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

지정한 Array 제네릭 인터페이스를 사용하여 IComparer<T>의 요소를 정렬합니다.Sorts the elements in an Array using the specified IComparer<T> generic interface.

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

Array에 있는 각 요소의 IComparable<T> 제네릭 인터페이스 구현을 사용하여 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>)

지정한 Array 제네릭 인터페이스를 사용하여 IComparer<T>의 요소 범위에 있는 요소를 정렬합니다.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

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

각 키의 Array 제네릭 인터페이스 구현을 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 IComparable<T> 개체(키를 포함하는 개체와 해당 항목을 포함하는 개체)를 정렬합니다.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>)

지정한 Array 제네릭 인터페이스를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 IComparer<T> 개체(키를 포함하는 개체와 해당 항목을 포함하는 개체)를 정렬합니다.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)

각 키에서 구현하는 Array 제네릭 인터페이스를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 IComparable<T> 개체(키를 포함하는 개체와 해당 항목을 포함하는 개체)의 요소 범위를 정렬합니다.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>)

지정한 Array 제네릭 인터페이스를 사용하여 첫 번째 Array에 있는 키를 기반으로 하는 한 쌍의 IComparer<T> 개체(키를 포함하는 개체와 해당 항목을 포함하는 개체)의 요소 범위를 정렬합니다.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()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(다음에서 상속됨 Object)
TrueForAll<T>(T[], Predicate<T>)

배열의 모든 요소가 지정한 조건자에 정의된 조건과 일치하는지 여부를 확인합니다.Determines whether every element in the array matches the conditions defined by the specified predicate.

명시적 인터페이스 구현

ICollection.Count

Array에 포함된 요소 수를 가져옵니다.Gets the number of elements contained in the Array.

ICollection.IsSynchronized

Array에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether access to the Array is synchronized (thread safe).

ICollection.SyncRoot

Array에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the Array.

IList.Add(Object)

이 메서드를 호출하면 NotSupportedException 예외가 항상 throw됩니다.Calling this method always throws a NotSupportedException exception.

IList.Clear()

IList에서 항목을 모두 제거합니다.Removes all items from the IList.

IList.Contains(Object)

IList에 요소가 있는지 여부를 확인합니다.Determines whether an element is in the IList.

IList.IndexOf(Object)

IList에서 특정 항목의 인덱스를 결정합니다.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object)

항목을 IList의 지정된 인덱스에 삽입합니다.Inserts an item to the IList at the specified index.

IList.IsFixedSize

Array의 크기가 고정되어 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the Array has a fixed size.

IList.IsReadOnly

Array이 읽기 전용인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the Array is read-only.

IList.Item[Int32]

지정한 인덱스에 있는 요소를 가져오거나 설정합니다.Gets or sets the element at the specified index.

IList.Remove(Object)

IList에서 맨 처음 발견되는 특정 개체를 제거합니다.Removes the first occurrence of a specific object from the IList.

IList.RemoveAt(Int32)

지정한 인덱스에서 IList 항목을 제거합니다.Removes the IList item at the specified index.

IStructuralComparable.CompareTo(Object, IComparer)

정렬 순서에서 현재 컬렉션 개체의 위치가 다른 개체보다 앞인지, 뒤인지 또는 동일한지를 확인합니다.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)

개체가 현재 인스턴스와 같은지 여부를 확인합니다.Determines whether an object is equal to the current instance.

IStructuralEquatable.GetHashCode(IEqualityComparer)

현재 인스턴스의 해시 코드를 반환합니다.Returns a hash code for the current instance.

확장 메서드

Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

쿼리를 병렬화할 수 있도록 합니다.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerableIQueryable로 변환합니다.Converts an IEnumerable to an IQueryable.

적용 대상

스레드 보안

공용 정적 (Shared Visual Basic의)이 형식의 멤버는 스레드로부터 안전 합니다.Public static (Shared in Visual Basic) members of this type are thread safe. 인터페이스 멤버는 스레드로부터 안전하지 않습니다.Any instance members are not guaranteed to be thread safe.

이 구현에서는 Array에 대해 동기화 되어 스레드로부터 안전 하 게 보호 되는 래퍼를 제공 하지 않습니다. 그러나 Array 기반 .NET Framework 클래스는 SyncRoot 속성을 사용 하 여 컬렉션의 동기화 된 버전을 제공 합니다.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.

컬렉션 전체를 열거하는 프로시저는 기본적으로 스레드로부터 안전하지 않습니다.Enumerating through a collection is intrinsically not a thread-safe procedure. 컬렉션이 동기화되어 있을 때 다른 스레드에서 해당 컬렉션을 수정할 수 있으므로 이렇게 되면 열거자에서 예외가 throw됩니다.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 열거하는 동안 스레드로부터 안전을 보장하려면 전체 열거를 수행하는 동안 컬렉션을 잠그거나 다른 스레드에서 변경된 내용으로 인해 발생한 예외를 catch하면 됩니다.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.

추가 정보