Array クラス

定義

名前空間:

System

アセンブリ:

System.Runtime.dll

ソース:

Array.cs

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

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

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
    interface ICloneable

Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable

継承

Object

Array

実装

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

例

次のコード例は、整数型の配列と Object型の配列の間で要素をコピー Array.Copy 方法を示しています。

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
*/

open System

let printValues myArr =
    for i in myArr do
        printf $"\t{i}"
    printfn ""

// Creates and initializes a new integer array and a new Object array.
let myIntArray = [| 1..5 |]
let myObjArray = [| 26..30 |]

// Prints the initial values of both arrays.
printfn "Initially,"
printf "integer array:"
printValues myIntArray
printfn "Object array: "
printValues myObjArray

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

// Prints the values of the modified arrays.
printfn "\nAfter copying the first two elements of the integer array to the Object array,"
printf "integer array:"
printValues myIntArray
printf"Object array: "
printValues myObjArray

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

// Prints the values of the modified arrays.
printfn $"\nAfter copying the last two elements of the Object array to the integer array,"
printf "integer array:"
printValues myIntArray
printf "Object array: "
printValues myObjArray


// 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

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
 */

open System

let printValues (myArray: Array) =
    let mutable i = 0
    let cols = myArray.GetLength(myArray.Rank - 1)
    for item in myArray do
        if i < cols then
            i <- i + 1
        else
            printfn ""
            i <- 1;
        printf $"\t{item}"
    printfn ""

// Creates and initializes a new three-dimensional Array of type int.
let myArr = Array.CreateInstance(typeof<int>, 2, 3, 4)
for i = myArr.GetLowerBound 0 to myArr.GetUpperBound 0 do
    for j = myArr.GetLowerBound 1 to myArr.GetUpperBound 1 do
        for k = myArr.GetLowerBound 2 to myArr.GetUpperBound 2 do
            myArr.SetValue(i * 100 + j * 10 + k, i, j, k)

// Displays the properties of the Array.
printfn $"The Array has {myArr.Rank} dimension(s) and a total of {myArr.Length} elements."
printfn $"\tLength\tLower\tUpper"

for i = 0 to myArr.Rank - 1 do
    printf $"{i}:\t{myArr.GetLength i}"
    printfn $"\t{myArr.GetLowerBound i}\t{myArr.GetUpperBound i}"

// Displays the contents of the Array.
printfn "The Array contains the following values:"
printValues myArr

// 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

// 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 です。 CreateInstanceを使用して Array クラスのインスタンスを作成するときに、別の下限を定義できます。 多次元 Array は、ディメンションごとに異なる境界を持つことができます。 配列には最大 32 個の次元を指定できます。

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

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

.NET Framework のみ : 既定では、Array の最大サイズは 2 ギガバイト (GB) です。 64 ビット環境では、gcAllowVeryLargeObjects 構成要素の enabled 属性を実行時環境で 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 オブジェクトを共有します。

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

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

CreateInstance、Copy、CopyTo、GetValue、SetValueなどの一部のメソッドでは、64 ビット整数をパラメーターとして受け取り、大容量配列に対応するオーバーロードが提供されます。 LongLength と GetLongLength は、配列の長さを示す 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)	0 から始まるインデックスを使用して、指定した Type と長さの 1 次元 Array を作成します。
CreateInstance(Type, Int32, Int32)	0 から始まるインデックスを使用して、指定した Type とディメンションの長さの 2 次元 Array を作成します。
CreateInstance(Type, Int32, Int32, Int32)	0 から始まるインデックスを使用して、指定した Type とディメンションの長さの 3 次元 Array を作成します。
CreateInstance(Type, Int32[])	指定した Type とディメンションの長さの多次元 Array を作成し、0 から始まるインデックスを作成します。 次元の長さは、32 ビット整数の配列で指定されます。
CreateInstance(Type, Int32[], Int32[])	指定した下限を持つ、指定した Type とディメンションの長さの多次元 Array を作成します。
CreateInstance(Type, Int64[])	指定した Type とディメンションの長さの多次元 Array を作成し、0 から始まるインデックスを作成します。 次元の長さは、64 ビット整数の配列で指定されます。
Empty<T>()	空の配列を返します。
Equals(Object)	指定したオブジェクトが現在のオブジェクトと等しいかどうかを判断します。 (継承元 Object)
Exists<T>(T[], Predicate<T>)	指定した配列に、指定した述語で定義された条件に一致する要素が含まれているかどうかを判断します。
Fill<T>(T[], T)	指定した arrayの各要素に T 型の指定された value を割り当てます。
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()	Arrayの IEnumerator を返します。
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 次元配列の要素範囲で指定したオブジェクトを検索し、最初に出現する if のインデックスを返します。 範囲は、指定した数の要素の指定したインデックスから拡張されます。
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)	各キーの IComparable 実装を使用して、最初の Array のキーに基づいて、1 次元の Array オブジェクト (1 つはキーを含み、もう 1 つは対応する項目を含む) のペアを並べ替えます。
Sort(Array, Array, IComparer)	指定した IComparerを使用して、最初の Array のキーに基づいて、1 次元 Array オブジェクトのペア (1 つはキーを含み、もう 1 つは対応する項目を含む) を並べ替えます。
Sort(Array, Array, Int32, Int32)	各キーの IComparable 実装を使用して、最初の Array のキーに基づいて、1 次元の Array オブジェクト (1 つはキーを含み、もう 1 つは対応する項目を含む) のペア内の要素の範囲を並べ替えます。
Sort(Array, Array, Int32, Int32, IComparer)	指定した IComparerを使用して、最初の Array のキーに基づいて、1 次元 Array オブジェクト (一方にはキーを含み、もう 1 つは対応する項目を含む) のペア内の要素の範囲を並べ替えます。
Sort(Array, IComparer)	指定した IComparerを使用して、1 次元 Array 内の要素を並べ替えます。
Sort(Array, Int32, Int32)	Arrayの各要素の IComparable 実装を使用して、1 次元 Array 内の要素の範囲内の要素を並べ替えます。
Sort(Array, Int32, Int32, IComparer)	指定した IComparerを使用して、1 次元 Array 内の要素の範囲内の要素を並べ替えます。
Sort<T>(T[])	Arrayの各要素の IComparable<T> ジェネリック インターフェイス実装を使用して、Array 全体の要素を並べ替えます。
Sort<T>(T[], Comparison<T>)	指定した Comparison<T>を使用して、Array 内の要素を並べ替えます。
Sort<T>(T[], IComparer<T>)	指定した IComparer<T> ジェネリック インターフェイスを使用して、Array 内の要素を並べ替えます。
Sort<T>(T[], Int32, Int32)	Arrayの各要素の IComparable<T> ジェネリック インターフェイス実装を使用して、Array 内の要素の範囲内の要素を並べ替えます。
Sort<T>(T[], Int32, Int32, IComparer<T>)	指定した IComparer<T> ジェネリック インターフェイスを使用して、Array 内の要素の範囲内の要素を並べ替えます。
Sort<TKey,TValue>(TKey[], TValue[])	各キーの IComparable<T> ジェネリック インターフェイス実装を使用して、最初の Array のキーに基づいて、Array オブジェクトのペア (1 つはキーを含み、もう 1 つは対応する項目を含む) を並べ替えます。
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	指定した IComparer<T> ジェネリック インターフェイスを使用して、最初の Array のキーに基づいて、Array オブジェクトのペア (1 つはキーを含み、もう 1 つは対応する項目を含む) を並べ替えます。
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	各キーの IComparable<T> ジェネリック インターフェイス実装を使用して、最初の Array のキーに基づいて、一対の Array オブジェクト (1 つはキーを含み、もう 1 つは対応する項目を含む) 内の要素の範囲を並べ替えます。
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	指定した IComparer<T> ジェネリック インターフェイスを使用して、Array オブジェクトのペア内の要素の範囲を並べ替えます (1 つはキーを含み、もう 1 つは対応する項目を含みます Array)。
ToString()	現在のオブジェクトを表す文字列を返します。 (継承元 Object)
TrueForAll<T>(T[], Predicate<T>)	配列内のすべての要素が、指定した述語によって定義された条件と一致するかどうかを判断します。

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

ICollection.Count	Arrayに含まれる要素の数を取得します。
IList.Add(Object)	このメソッドを呼び出すと、常に NotSupportedException 例外がスローされます。
IList.Clear()	IListからすべての項目を削除します。
IList.Contains(Object)	要素が IList内にあるかどうかを判断します。
IList.IndexOf(Object)	IList内の特定の項目のインデックスを決定します。
IList.Insert(Int32, Object)	指定したインデックス位置にある IList に項目を挿入します。
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)	IEnumerable を IQueryableに変換します。

スレッド セーフ

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

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

コレクションを列挙することは、本質的にスレッド セーフなプロシージャではありません。 コレクションが同期されている場合でも、他のスレッドはコレクションを変更できるため、列挙子は例外をスローします。 列挙中のスレッド セーフを保証するには、列挙全体の間にコレクションをロックするか、他のスレッドによって行われた変更によって発生する例外をキャッチします。

こちらもご覧ください

• Object
• Type
• 配列 での Culture-Insensitive 文字列操作の実行の
• 配列 (C# プログラミング ガイド)
• F# で配列を する
• Visual Basic で配列を する