Array クラス

定義

配列の作成、操作、検索、および並べ替えを行うメソッドを提供します。これにより、共通言語ランタイムのすべての配列の基本クラスとして機能します。

public ref class Array abstract : System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
public ref class Array abstract : ICloneable, System::Collections::IList
public abstract class Array : System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Array : ICloneable, System.Collections.IList
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Array = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface IStructuralComparable
    interface IStructuralEquatable
type Array = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface IStructuralComparable
    interface IStructuralEquatable
    interface ICloneable
[<System.Serializable>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
type Array = class
    interface IList
    interface ICollection
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements IList, IStructuralComparable, IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList
継承
Array
属性
実装

次のコード例では、 Array.Copy が整数型の配列と型の配列の間で要素をコピーする方法を示し 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 そのプロパティとその要素を表示するコード例を次に示します。

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
 */
// Creates and initializes a new three-dimensional Array of type int.
Array myArr = Array.CreateInstance(typeof(int), 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);

void PrintValues(Array myArray)
{
    System.Collections.IEnumerator myEnumerator = myArray.GetEnumerator();
    int i = 0;
    int cols = myArray.GetLength(myArray.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 。 ただし、このインターフェイスはインターフェイスに基づいているため、引き続きコレクションと見なされ IList ます。

クラスは、 Array 配列をサポートする言語実装の基本クラスです。 ただし、システムとコンパイラだけをクラスから明示的に派生させることができ Array ます。 ユーザーは、言語によって提供される配列の構造体を採用する必要があります。

要素は、の値です Array 。 の長さは、 Array 格納できる要素の合計数です。 の下限は、 Array その最初の要素のインデックスです。 は Array 下限を持つことができますが、既定では下限が0になっています。 を使用してクラスのインスタンスを作成する場合は、異なる下限を定義でき Array CreateInstance ます。 多次元は、 Array 次元ごとに異なる境界を持つことができます。 配列には、最大32次元を設定できます。

名前空間のクラスとは異なり System.Collections 、で Array は容量が固定されています。 容量を増やすには、 Array 必要な容量を持つ新しいオブジェクトを作成し、古いオブジェクトの要素 Array を新しいオブジェクトにコピーして、古いを削除する必要があり Array ます。

配列のサイズは、合計で40億の要素に制限され、任意の次元の0X7FEFFFFF の最大インデックス (バイト配列の場合は0X7FFFFFC7、1バイト構造体の配列の場合) に制限されます。

.NET Framework のみ: 既定では、の最大サイズ Array は 2 gb です。 64ビット環境では、 enabled 実行時環境で gcAllowVeryLargeObjects 構成要素の属性をに設定することによって、サイズ制限を回避でき true ます。

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> ます。 実装は実行時に配列に提供されます。そのため、ジェネリックインターフェイスは、クラスの宣言構文には表示されません Array 。 また、配列をジェネリックインターフェイス型 (明示的なインターフェイスの実装) にキャストすることによってのみアクセスできるインターフェイスメンバーに関する参照トピックはありません。 これらのインターフェイスのいずれかに配列をキャストするときに注意すべき重要な点は、要素を追加、挿入、または削除するメンバーがスローすることです NotSupportedException

Type オブジェクトは、配列型の宣言に関する情報を提供します。 Array 同じ配列型のオブジェクトは、同じオブジェクトを共有し Type ます。

Type.IsArrayType.GetElementType Array 配列が型にキャストされる場合、結果は配列ではなくオブジェクトであるため、とでは予期した結果が返されないことがあり Array ます。 つまり、はを返し、はを typeof(System.Array).IsArray false typeof(System.Array).GetElementType 返し null ます。

メソッドは、 Array.Copy 同じ型の配列間だけでなく、異なる型の標準配列間でも要素をコピーします。型キャストを自動的に処理します。

、、、、などの一部のメソッドでは、 CreateInstance Copy CopyTo GetValue SetValue 大容量の配列に対応するために、パラメーターとして64ビットの整数を受け入れるオーバーロードが提供されます。 LongLengthGetLongLength は、配列の長さを示す64ビット整数を返します。

Array 並べ替えは保証されていません。 の並べ替えが Array 必要な操作 (など) を実行する前に、を並べ替える必要があり BinarySearch Array ます。

Arrayネイティブコードでのポインターのオブジェクトの使用はサポートされていない NotSupportedException ため、いくつかのメソッドについてはをスローします。

プロパティ

IsFixedSize

Array が固定サイズかどうかを示す値を取得します。

IsReadOnly

Array が読み取り専用かどうかを示す値を取得します。

IsSynchronized

Array へのアクセスが同期されている (スレッド セーフである) かどうかを示す値を取得します。

Length

Array のすべての次元内の要素の総数を取得します。

LongLength

Array のすべての次元内の要素の総数を表す 64 ビット整数を取得します。

MaxLength

配列に格納できる要素の最大数を取得します。

Rank

Array のランク (次元数) を取得します。 たとえば、1 次元配列は 1 を返し、2 次元配列は 2 を返すなどです。

SyncRoot

Array へのアクセスを同期するために使用できるオブジェクトを取得します。

メソッド

AsReadOnly<T>(T[])

指定した配列をラップする読み取り専用のラッパーを作成します。

BinarySearch(Array, Int32, Int32, Object)

配列の各要素および指定した値によって実装されている IComparable インターフェイスを使用して、1 次元の並べ替え済み配列の要素範囲の中から値を検索します。

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

指定した IComparer インターフェイスを使用して、1 次元の並べ替え済み配列の要素範囲の中から値を検索します。

BinarySearch(Array, Object)

配列の各要素および指定したオブジェクトによって実装されている IComparable インターフェイスを使用して、1 次元の並べ替え済み配列全体の中から特定の要素を検索します。

BinarySearch(Array, Object, IComparer)

指定した IComparer インターフェイスを使用して、1 次元の並べ替え済み配列全体の中から値を検索します。

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

Array の各要素および指定した値によって実装されている IComparable<T> ジェネリック インターフェイスを使用して、1 次元の並べ替え済み配列の要素範囲の中から値を検索します。

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

指定した IComparer<T> ジェネリック インターフェイスを使用して、1 次元の並べ替え済み配列の要素範囲の中から値を検索します。

BinarySearch<T>(T[], T)

Array の各要素および指定したオブジェクトによって実装されている IComparable<T> ジェネリック インターフェイスを使用して、1 次元の並べ替え済み配列全体の中から特定の要素を検索します。

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

指定した IComparer<T> ジェネリック インターフェイスを使用して、1 次元の並べ替え済み配列全体の中から値を検索します。

Clear(Array)

配列の内容をクリアします。

Clear(Array, Int32, Int32)

配列内にある要素の範囲を、各要素の型の既定値に設定します。

Clone()

Array の簡易コピーを作成します。

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

指定したコピー元インデックスを開始位置として Array から要素の範囲をコピーし、指定したコピー先インデックスを開始位置として他の Array にそれらの要素を貼り付けます。 コピーが完全に成功しない限り、変更は一切適用されません。

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

ある型の配列を別の型の配列に変換します。

Copy(Array, Array, Int32)

最初の要素を開始位置として Array から要素の範囲をコピーし、最初の要素を開始位置として他の Array にそれらの要素を貼り付けます。 長さは 32 ビット整数値として指定します。

Copy(Array, Array, Int64)

最初の要素を開始位置として Array から要素の範囲をコピーし、最初の要素を開始位置として他の Array にそれらの要素を貼り付けます。 長さは 64 ビット整数値として指定します。

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

指定したコピー元インデックスを開始位置として Array から要素の範囲をコピーし、指定したコピー先インデックスを開始位置として他の Array にそれらの要素を貼り付けます。 長さとインデックスは、32 ビット整数として指定します。

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

指定したコピー元インデックスを開始位置として Array から要素の範囲をコピーし、指定したコピー先インデックスを開始位置として他の Array にそれらの要素を貼り付けます。 長さとインデックスは、64 ビット整数として指定します。

CopyTo(Array, Int32)

現在の 1 次元配列のすべての要素を、指定したコピー先配列インデックスで開始する指定の 1 次元配列にコピーします。 インデックスは 32 ビット整数値として指定します。

CopyTo(Array, Int64)

現在の 1 次元配列のすべての要素を、指定したコピー先配列インデックスで開始する指定の 1 次元配列にコピーします。 このインデックスは 64 ビット整数値として指定されます。

CreateInstance(Type, Int32)

Type と長さを指定して、0 から始まるインデックス番号を持つ 1 次元の Array を作成します。

CreateInstance(Type, Int32, Int32)

Type と次元の長さを指定して、0 から始まるインデックス番号を持つ 2 次元の Array を作成します。

CreateInstance(Type, Int32, Int32, Int32)

Type と次元の長さを指定して、0 から始まるインデックス番号を持つ 3 次元の Array を作成します。

CreateInstance(Type, Int32[])

Type と次元の長さを指定して、0 から始まるインデックス番号を持つ多次元の Array を作成します。 次元の長さは、32 ビット整数の配列で指定します。

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

指定した Type と次元の長さの、指定した下限を持つ多次元の Array を作成します。

CreateInstance(Type, Int64[])

Type と次元の長さを指定して、0 から始まるインデックス番号を持つ多次元の Array を作成します。 次元の長さは、64 ビット整数の配列で指定します。

Empty<T>()

空の配列を返します。

Equals(Object)

指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判断します。

(継承元 Object)
Exists<T>(T[], Predicate<T>)

指定された配列に、指定された述語によって定義された条件と一致する要素が含まれているかどうかを判断します。

Fill<T>(T[], T)

T 型の指定された value を、指定されたarray の各要素に割り当てます。

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

T 型の指定された value を、指定されたarray の要素に割り当てます。これらの要素は、startIndex (包含) および次の count 個のインデックスの範囲内にあります。

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

指定された述語によって定義された条件と一致する要素を検索し、Array 全体の中で最もインデックス番号の小さい要素を返します。

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

指定された述語によって定義された条件と一致するすべての要素を取得します。

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

Array のうち、指定したインデックスから始まり、指定した要素数が含まれる範囲の中で、指定した述語によって定義される条件に一致する要素を検索し、そのうち最もインデックス番号の小さい要素の 0 から始まるインデックスを返します。

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

Array の指定したインデックスから最後の要素までの範囲内で、指定した述語にで定義される条件に一致する要素を検索し、最初に見つかった 0 から始まるインデックスを返します。

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

Array 全体から、指定した述語によって定義される条件に一致する要素を検索し、最もインデックス番号の小さい要素の 0 から始まるインデックスを返します。

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

指定された述語によって定義された条件と一致する要素を、Array 全体を対象に検索し、最もインデックス番号の大きい要素を返します。

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

Array のうち、指定したインデックスで終わり、指定した要素数が含まれる範囲の中で、指定した述語によって定義される条件に一致する要素を検索し、そのうち最もインデックス番号の大きい要素の 0 から始まるインデックスを返します。

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

Array のうち、先頭の要素から指定したインデックスまでの範囲の中で、指定した述語によって定義される条件に一致する要素を検索し、そのうち最もインデックス番号の大きい要素の 0 から始まるインデックスを返します。

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

Array 全体から、指定した述語によって定義される条件に一致する要素を検索し、最もインデックス番号の大きい要素の 0 から始まるインデックスを返します。

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

指定された配列内の各要素に対して、指定された処理を実行します。

GetEnumerator()

IEnumeratorArray を返します。

GetHashCode()

既定のハッシュ関数として機能します。

(継承元 Object)
GetLength(Int32)

Array の指定した次元にある要素の数を表す 32 ビット整数を取得します。

GetLongLength(Int32)

Array の指定した次元にある要素の数を表す 64 ビット整数を取得します。

GetLowerBound(Int32)

配列内で指定した次元の、最初の要素のインデックスを取得します。

GetType()

現在のインスタンスの Type を取得します。

(継承元 Object)
GetUpperBound(Int32)

配列内で指定した次元の、最後の要素のインデックスを取得します。

GetValue(Int32)

1 次元 Array 内の指定した位置にある値を取得します。 インデックスは 32 ビット整数値として指定します。

GetValue(Int32, Int32)

2 次元 Array 内の指定した位置にある値を取得します。 インデックスは 32 ビット整数値として指定します。

GetValue(Int32, Int32, Int32)

3 次元 Array 内の指定した位置にある値を取得します。 インデックスは 32 ビット整数値として指定します。

GetValue(Int32[])

多次元 Array 内の指定した位置にある値を取得します。 インデックスは 32 ビット整数値の配列として指定します。

GetValue(Int64)

1 次元 Array 内の指定した位置にある値を取得します。 このインデックスは 64 ビット整数値として指定されます。

GetValue(Int64, Int64)

2 次元 Array 内の指定した位置にある値を取得します。 インデックスは 64 ビット整数として指定します。

GetValue(Int64, Int64, Int64)

3 次元 Array 内の指定した位置にある値を取得します。 インデックスは 64 ビット整数として指定します。

GetValue(Int64[])

多次元 Array 内の指定した位置にある値を取得します。 インデックスは 64 ビット整数値の配列として指定します。

IndexOf(Array, Object)

指定したオブジェクトを検索し、1 次元配列でそのオブジェクトが最初に見つかった位置のインデックス番号を返します。

IndexOf(Array, Object, Int32)

指定されたオブジェクトを 1 次元配列の要素範囲内で検索し、最初に見つかったオブジェクトのインデックスを返します。 要素範囲は、指定されたインデックスから、配列の最後までの範囲です。

IndexOf(Array, Object, Int32, Int32)

指定されたオブジェクトを 1 次元配列の要素範囲内で検索し、最初に見つかったオブジェクトのインデックスを返します。 範囲は、指定されたインデックスから始まり、指定された数の要素を含む範囲です。

IndexOf<T>(T[], T)

指定したオブジェクトを検索し、1 次元配列でそのオブジェクトが最初に見つかった位置のインデックス番号を返します。

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

指定されたオブジェクトを 1 次元配列の要素範囲内で検索し、最初に見つかったオブジェクトのインデックスを返します。 要素範囲は、指定されたインデックスから、配列の最後までの範囲です。

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

指定されたオブジェクトを 1 次元配列の要素範囲内で検索し、最初に見つかったオブジェクトのインデックスを返します。 範囲は、指定されたインデックスから始まり、指定された数の要素を含む範囲です。

Initialize()

値型のパラメーターなしのコンストラクターを呼び出すことで、この値型 Array の各要素を初期化します。

LastIndexOf(Array, Object)

指定したオブジェクトを検索し、1 次元の Array 全体でそのオブジェクトが最後に見つかった位置のインデックス番号を返します。

LastIndexOf(Array, Object, Int32)

指定したオブジェクトを、1 次元 Array の先頭の要素から、指定されたインデックス位置までを範囲として検索し、インデックス番号の最も大きい要素のインデックス番号を返します。

LastIndexOf(Array, Object, Int32, Int32)

指定したオブジェクトを、1 次元 Array の指定したインデックス位置から、指定した要素数を範囲として検索し、インデックス番号の最も大きい要素のインデックス番号を返します。

LastIndexOf<T>(T[], T)

指定したオブジェクトを Array 全体を対象に検索し、インデックス番号の最も大きい要素のインデックスを返します。

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

指定したオブジェクトを、Array の先頭の要素から、指定されたインデックス位置までを範囲として検索し、インデックス番号の最も大きい要素のインデックス番号を返します。

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

指定したオブジェクトを、指定した数の要素を含み、かつ指定したインデックスで終了する Array の要素の範囲内で検索し、インデックス番号の最も大きい要素のインデックス番号を返します。

MemberwiseClone()

現在の Object の簡易コピーを作成します。

(継承元 Object)
Resize<T>(T[], Int32)

1 次元配列の要素数を、指定した新しいサイズに変更します。

Reverse(Array)

1 次元の Array 内全体の要素のシーケンスを反転させます。

Reverse(Array, Int32, Int32)

1 次元の Array内の要素のサブセットのシーケンスを反転させます。

Reverse<T>(T[])

1 次元のジェネリック配列内の要素のシーケンスを反転させます。

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

1 次元のジェネリック配列内の要素のサブセットのシーケンスを反転させます。

SetValue(Object, Int32)

1 次元 Array 内の指定した位置にある要素に値を設定します。 インデックスは 32 ビット整数値として指定します。

SetValue(Object, Int32, Int32)

2 次元 Array の指定された位置にある要素に値を設定します。 インデックスは 32 ビット整数値として指定します。

SetValue(Object, Int32, Int32, Int32)

3 次元 Array 内の指定した位置にある要素に値を設定します。 インデックスは 32 ビット整数値として指定します。

SetValue(Object, Int32[])

多次元 Array 内の指定した位置にある要素に値を設定します。 インデックスは 32 ビット整数値の配列として指定します。

SetValue(Object, Int64)

1 次元 Array 内の指定した位置にある要素に値を設定します。 このインデックスは 64 ビット整数値として指定されます。

SetValue(Object, Int64, Int64)

2 次元 Array の指定された位置にある要素に値を設定します。 インデックスは 64 ビット整数として指定します。

SetValue(Object, Int64, Int64, Int64)

3 次元 Array 内の指定した位置にある要素に値を設定します。 インデックスは 64 ビット整数として指定します。

SetValue(Object, Int64[])

多次元 Array 内の指定した位置にある要素に値を設定します。 インデックスは 64 ビット整数値の配列として指定します。

Sort(Array)

Array の各要素の IComparable 実装を使用して、1 次元 Array 全体の要素を並べ替えます。

Sort(Array, Array)

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、各キーによって実装された IComparable を使用して並べ替えます。

Sort(Array, Array, IComparer)

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、指定した IComparer を使用して並べ替えます。

Sort(Array, Array, Int32, Int32)

2 つの 1 次元 Array オブジェクト (一方がキーを格納し、他方が対応する項目を格納する) の要素範囲を、最初の Array 内のキーに基づき、各キーによって実装された IComparable を使用して並べ替えます。

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

2 つの 1 次元 Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) 内の要素範囲を、最初の Array 内のキーに基づき、指定した IComparer を使用して並べ替えます。

Sort(Array, IComparer)

1 次元 Array 内の要素を、指定した IComparer を使用して並べ替えます。

Sort(Array, Int32, Int32)

Array の各要素によって実装された IComparable を使用して、1 次元 Array のうちある要素範囲の要素を並べ替えます。

Sort(Array, Int32, Int32, IComparer)

1 次元 Array の要素の範囲内の要素を、指定した IComparer を使用して並べ替えます。

Sort<T>(T[])

Array の各要素によって実装された IComparable<T> ジェネリック インターフェイスを使用して、Array 全体の要素を並べ替えます。

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

Array 内の要素を、指定した Comparison<T> を使用して並べ替えます。

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

Array 内の要素を、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。

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

Array の各要素の IComparable<T> ジェネリック インターフェイスの実装を使用して、Array の中のある要素範囲の要素を並べ替えます。

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

指定した IComparer<T> ジェネリック インターフェイスを使用して、Array 内の要素の範囲内の要素を並べ替えます。

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、各キーによって実装された IComparable<T> ジェネリック インターフェイスを使用して並べ替えます。

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) を、最初の Array 内のキーに基づき、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) の要素範囲を、最初の Array 内のキーに基づき、各キーによって実装された IComparable<T> ジェネリック インターフェイスを使用して並べ替えます。

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

2 つの Array オブジェクト (一方のオブジェクトがキーを格納し、他方のオブジェクトがそれらに対応する項目を格納する) 内の要素範囲を、最初の Array 内のキーに基づき、指定した IComparer<T> ジェネリック インターフェイスを使用して並べ替えます。

ToString()

現在のオブジェクトを表す文字列を返します。

(継承元 Object)
TrueForAll<T>(T[], Predicate<T>)

配列内のすべての要素が、指定された述語によって定義された条件と一致するかどうかを調べます。

明示的なインターフェイスの実装

ICollection.Count

Array に格納されている要素の数を取得します。

ICollection.IsSynchronized

Array へのアクセスが同期されるかどうか (スレッド セーフかどうか) を示す値を取得します。

ICollection.SyncRoot

Array へのアクセスを同期するために使用できるオブジェクトを取得します。

IList.Add(Object)

このメソッドを呼び出すと、必ず NotSupportedException 例外がスローされます。

IList.Clear()

IList からすべての項目を削除します。

IList.Contains(Object)

ある要素が IList 内に存在するかどうかを判断します。

IList.IndexOf(Object)

IList 内の特定の項目のインデックスを確認します。

IList.Insert(Int32, Object)

指定したインデックスの IList に項目を挿入します。

IList.IsFixedSize

Array が固定サイズかどうかを示す値を取得します。

IList.IsReadOnly

Array が読み取り専用かどうかを示す値を取得します。

IList.Item[Int32]

指定したインデックスにある要素を取得または設定します。

IList.Remove(Object)

特定のオブジェクトが IList 内にあるときに、最初に出現したものを削除します。

IList.RemoveAt(Int32)

指定したインデックスにある IList 項目を削除します。

IStructuralComparable.CompareTo(Object, IComparer)

現在のコレクション オブジェクトの並べ替え順序での位置が、別のオブジェクトと比べて前か、後か、または同じかを判断します。

IStructuralEquatable.Equals(Object, IEqualityComparer)

オブジェクトが現在のインスタンスと等しいかどうかを判断します。

IStructuralEquatable.GetHashCode(IEqualityComparer)

現在のインスタンスのハッシュ コードを返します。

拡張メソッド

Cast<TResult>(IEnumerable)

IEnumerable の要素を、指定した型にキャストします。

OfType<TResult>(IEnumerable)

指定された型に基づいて IEnumerable の要素をフィルター処理します。

AsParallel(IEnumerable)

クエリの並列化を有効にします。

AsQueryable(IEnumerable)

IEnumerableIQueryable に変換します。

適用対象

スレッド セーフ

パブリック静的 (Visual Basic ではShared) なこの型のメンバーはスレッド セーフです インスタンス メンバーの場合は、スレッド セーフであるとは限りません。

この実装は、に対して同期された (スレッドセーフな) ラッパーを提供しません Array 。ただし、に基づく .net クラスは、 Array プロパティを使用して、同期された独自のバージョンのコレクションを提供し SyncRoot ます。

コレクションの列挙処理は、本質的にスレッドセーフな処理ではありません。 コレクションが同期されていても、他のスレッドがコレクションを変更する場合があり、このときは列挙子から例外がスローされます。 列挙処理を確実にスレッド セーフに行うには、列挙中にコレクションをロックするか、他のスレッドによって行われた変更によってスローされる例外をキャッチします。

こちらもご覧ください