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.CopyObject示しています。

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. an Array の長さは、含めることができる要素の合計数です。 a Array の下限は、最初の要素のインデックスです。 An 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.IReadOnlyCollection<T>実装 System.Collections.Generic.IReadOnlyList<T> System.Collections.Generic.IList<T>System.Collections.Generic.ICollection<T>System.Collections.Generic.IEnumerable<T>します。 実装は実行時に配列に提供され、その結果、ジェネリック インターフェイスはクラスの宣言構文 Array には表示されません。 さらに、ジェネリック インターフェイス型 (明示的なインターフェイス実装) に配列をキャストすることによってのみアクセスできるインターフェイス メンバーの参照トピックはありません。 これらのインターフェイスのいずれかに配列をキャストする際に注意すべき重要な点は、要素を追加、挿入、または削除するメンバーがスロー NotSupportedExceptionされることです。

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

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

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

CopyCopyToGetValueSetValue、などの一部のメソッドは、CreateInstance大容量配列に対応するためのパラメーターとして 64 ビット整数を受け取るオーバーロードを提供します。 LongLength 配列の GetLongLength 長さを示す 64 ビット整数を返します。

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

Arrayネイティブ コードでポインターのオブジェクトを使用することはサポートされておらず、いくつかのメソッドに対して a 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 独自の同期バージョンのコレクションを提供します。

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

こちらもご覧ください