C#のListを配列に変換する方法｜ToArray()の使い方とエラー対処をサンプルコードで解説

はじめに

C#で開発していると、List<T>で管理しているデータを配列であるT[]に変換したい場面があります。

たとえば、次のようなケースです。

C#
List<int> numbers = new List<int> { 1, 2, 3 };
int[] array = numbers.ToArray();

C#では、Listを配列に変換する場合、基本的にはToArray()メソッドを使います。ToArray()は書き方がシンプルで、List<int>ならint[]、List<string>ならstring[]のように、同じ型の配列へ簡単に変換できます。

この記事では、C#のListを配列に変換する方法を、ToArray()の基本構文から型別のサンプルコード、よくあるエラー、LINQを使った応用例まで解説します。

1. C#でListを配列に変換する基本

C#でListを配列に変換する前に、まずはList<T>と配列T[]の違いを理解しておきましょう。

どちらも複数の値をまとめて扱うための仕組みですが、特徴や使いどころが異なります。

1-1. List<T>と配列T[]の違い

List<T>は、要素数を後から増やしたり減らしたりできるコレクションです。

C#
List<int> numbers = new List<int>();

numbers.Add(10);
numbers.Add(20);
numbers.Add(30);

このように、Add()を使って後から要素を追加できます。

一方、配列T[]は、基本的に作成時に要素数が決まります。

C#
int[] numbers = new int[3];

numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

配列は固定長なので、後から簡単に要素数を増やすことはできません。

主な違いを整理すると、次のようになります。

実務では、データを一時的に集めるときはList<T>を使い、必要に応じて配列に変換することがよくあります。

1-2. Listを配列に変換する主なケース

Listを配列に変換する主なケースには、次のようなものがあります。

外部ライブラリや既存メソッドが配列を引数として要求している場合です。

C#
void PrintNumbers(int[] numbers)
{
    foreach (int number in numbers)
    {
        Console.WriteLine(number);
    }
}

このようなメソッドにList<int>を渡したい場合、ToArray()でint[]に変換します。

C#
List<int> list = new List<int> { 1, 2, 3 };

PrintNumbers(list.ToArray());

また、APIに渡すデータ形式として配列が必要な場合や、データの追加・削除を終えたあとに固定された形で扱いたい場合にも、Listから配列への変換が使われます。

1-3. 結論：List<T>.ToArray()を使うのが基本

C#でList<T>を配列に変換する基本は、ToArray()を使う方法です。

C#
List<string> names = new List<string> { "Alice", "Bob", "Charlie" };

string[] nameArray = names.ToArray();

List<string>に対してToArray()を呼び出すと、string[]が返されます。

同じように、List<int>ならint[]、List<double>ならdouble[]、List<Person>ならPerson[]になります。

C#
List<int> numbers = new List<int> { 10, 20, 30 };

int[] numberArray = numbers.ToArray();

ToArray()はC#で非常によく使われる変換方法なので、まずはこの書き方を覚えておけば問題ありません。

2. ToArray()でListを配列に変換する方法

ここからは、ToArray()を使ってListを配列に変換する具体的な書き方を見ていきます。

2-1. ToArray()の基本構文

ToArray()の基本構文は次のとおりです。

C#
T[] 配列名 = リスト名.ToArray();

たとえば、List<int>をint[]に変換する場合は、次のように書きます。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

ToArray()は、元のListの中身をもとに新しい配列を作成します。

重要なのは、戻り値の型がList<T>ではなくT[]になることです。

C#
List<string> list = new List<string> { "A", "B", "C" };

string[] array = list.ToArray();

この場合、arrayの型はstring[]です。

2-2. int型のListを配列に変換するサンプルコード

まずは、List<int>をint[]に変換する例です。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 10, 20, 30, 40 };

        int[] array = numbers.ToArray();

        foreach (int number in array)
        {
            Console.WriteLine(number);
        }
    }
}

実行結果は次のようになります。

10
20
30
40

numbers.ToArray()によって、List<int>の内容がint[]に変換されています。

2-3. string型のListを配列に変換するサンプルコード

次に、List<string>をstring[]に変換する例です。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> fruits = new List<string>
        {
            "Apple",
            "Banana",
            "Orange"
        };

        string[] fruitArray = fruits.ToArray();

        foreach (string fruit in fruitArray)
        {
            Console.WriteLine(fruit);
        }
    }
}

実行結果は次のとおりです。

Apple
Banana
Orange

List<string>に対してToArray()を使うと、同じ要素を持つstring[]が作成されます。

2-4. 変換後の配列をforeachで確認する方法

ToArray()で変換した配列の中身を確認するには、foreachを使うのが簡単です。

C#
List<int> scores = new List<int> { 80, 90, 75 };

int[] scoreArray = scores.ToArray();

foreach (int score in scoreArray)
{
    Console.WriteLine(score);
}

foreachは、Listにも配列にも使えます。

そのため、変換前のListと変換後の配列の両方で、同じように要素を取り出せます。

C#
foreach (int score in scores)
{
    Console.WriteLine(score);
}

foreach (int score in scoreArray)
{
    Console.WriteLine(score);
}

ただし、scoresはList<int>、scoreArrayはint[]なので、型としては別物です。

3. 型別に見るListから配列への変換サンプル

ToArray()は、さまざまな型のListで使えます。

ここでは、int、string、double、自作クラスの例を見ていきます。

3-1. List<int>をint[]に変換する

数値を扱うList<int>を配列に変換する例です。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> ids = new List<int> { 101, 102, 103 };

        int[] idArray = ids.ToArray();

        foreach (int id in idArray)
        {
            Console.WriteLine(id);
        }
    }
}

List<int>を変換した結果はint[]です。

C#
int[] idArray = ids.ToArray();

変換後の配列は、通常の配列と同じようにインデックスでアクセスできます。

C#
Console.WriteLine(idArray[0]);

3-2. List<string>をstring[]に変換する

文字列を扱うList<string>を配列に変換する例です。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<string> users = new List<string>
        {
            "Tanaka",
            "Suzuki",
            "Sato"
        };

        string[] userArray = users.ToArray();

        Console.WriteLine(userArray[0]);
        Console.WriteLine(userArray[1]);
        Console.WriteLine(userArray[2]);
    }
}

実行結果は次のようになります。

Tanaka
Suzuki
Sato

string[]に変換したあとは、配列として扱えるため、別のメソッドに渡すこともできます。

C#
static void PrintUsers(string[] users)
{
    foreach (string user in users)
    {
        Console.WriteLine(user);
    }
}

呼び出し側では、次のように使えます。

C#
PrintUsers(users.ToArray());

3-3. List<double>をdouble[]に変換する

小数を扱うList<double>も、同じようにdouble[]へ変換できます。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<double> prices = new List<double> { 120.5, 300.0, 450.75 };

        double[] priceArray = prices.ToArray();

        foreach (double price in priceArray)
        {
            Console.WriteLine(price);
        }
    }
}

実行結果は次のとおりです。

120.5
300
450.75

List<double>に対してToArray()を使うと、戻り値はdouble[]になります。

C#
double[] priceArray = prices.ToArray();

型を間違えてint[]に代入しようとすると、コンパイルエラーになります。

C#
// エラーになる例
// int[] priceArray = prices.ToArray();

List<double>はdouble[]に変換する必要があります。

3-4. List<自作クラス>を配列に変換する

ToArray()は、intやstringだけでなく、自作クラスのListにも使えます。

たとえば、Personクラスを作成して、List<Person>をPerson[]に変換してみます。

C#
using System;
using System.Collections.Generic;

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        List<Person> people = new List<Person>
        {
            new Person { Name = "Tanaka", Age = 30 },
            new Person { Name = "Suzuki", Age = 25 },
            new Person { Name = "Sato", Age = 28 }
        };

        Person[] personArray = people.ToArray();

        foreach (Person person in personArray)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
    }
}

実行結果は次のようになります。

Tanaka: 30
Suzuki: 25
Sato: 28

List<Person>をToArray()で変換すると、Person[]が作成されます。

C#
Person[] personArray = people.ToArray();

自作クラスでも、基本的な使い方は組み込み型と同じです。

4. ToArray()を使うときの注意点

ToArray()は便利ですが、いくつか注意点があります。

特に重要なのは、ToArray()が新しい配列を作成するという点です。

4-1. ToArray()は新しい配列を作成する

ToArray()を呼び出すと、元のListとは別の新しい配列が作成されます。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

このとき、listとarrayは別々のオブジェクトです。

そのため、変換後にListを変更しても、基本的には配列の内容は変わりません。

4-2. 変換後にListを変更しても配列には反映されない

次のコードを見てください。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> list = new List<int> { 1, 2, 3 };

        int[] array = list.ToArray();

        list.Add(4);

        Console.WriteLine("List:");
        foreach (int item in list)
        {
            Console.WriteLine(item);
        }

        Console.WriteLine("Array:");
        foreach (int item in array)
        {
            Console.WriteLine(item);
        }
    }
}

実行結果は次のようになります。

List:
1
2
3
4
Array:
1
2
3

list.Add(4)でListには要素が追加されていますが、すでに作成されたarrayには反映されません。

配列にも最新の内容を反映したい場合は、もう一度ToArray()を呼び出す必要があります。

C#
array = list.ToArray();

4-3. 変換後に配列を変更してもListには反映されない

逆に、変換後の配列を変更しても、元のListには反映されません。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> list = new List<int> { 1, 2, 3 };

        int[] array = list.ToArray();

        array[0] = 100;

        Console.WriteLine("List:");
        foreach (int item in list)
        {
            Console.WriteLine(item);
        }

        Console.WriteLine("Array:");
        foreach (int item in array)
        {
            Console.WriteLine(item);
        }
    }
}

実行結果は次のとおりです。

List:
1
2
3
Array:
100
2
3

配列の先頭要素は100に変わっていますが、元のListの先頭要素は1のままです。

ただし、自作クラスなどの参照型を扱う場合は注意が必要です。List<Person>をPerson[]に変換した場合、配列自体は新しく作られますが、中に入っているPersonオブジェクトは同じ参照を持つことがあります。

C#
List<Person> people = new List<Person>
{
    new Person { Name = "Tanaka", Age = 30 }
};

Person[] array = people.ToArray();

array[0].Age = 31;

Console.WriteLine(people[0].Age);

この場合、Personオブジェクトの中身を変更しているため、List側から見てもAgeが変更されたように見えます。

値型のintやdoubleとは挙動が異なるため、参照型を扱う場合は意識しておきましょう。

4-4. 要素数が多い場合のメモリ使用量に注意する

ToArray()は新しい配列を作成するため、要素数が多い場合はメモリ使用量が増えます。

たとえば、非常に大きなList<int>を配列に変換すると、Listのデータに加えて配列分のメモリも必要になります。

C#
List<int> largeList = new List<int>();

for (int i = 0; i < 1000000; i++)
{
    largeList.Add(i);
}

int[] largeArray = largeList.ToArray();

このような処理自体は可能ですが、大量データを扱う場合は、本当に配列化が必要かを検討しましょう。

単に繰り返し処理をしたいだけであれば、Listのままforeachで処理できることも多いです。

C#
foreach (int item in largeList)
{
    Console.WriteLine(item);
}

配列を要求するメソッドに渡す必要がある場合など、明確な理由があるときにToArray()を使うのがよいでしょう。

5. Listを配列に変換するときによくあるエラーと対処法

Listを配列に変換するときは、いくつかのエラーが発生することがあります。

ここでは、初心者が特につまずきやすいエラーと対処法を紹介します。

5-1. NullReferenceExceptionが発生する原因と対処法

Listがnullの状態でToArray()を呼び出すと、NullReferenceExceptionが発生します。

C#
List<int> numbers = null;

int[] array = numbers.ToArray();

このコードは、numbersがnullなのでエラーになります。

対処法は、ToArray()を呼び出す前にnullチェックを行うことです。

C#
List<int> numbers = null;

int[] array;

if (numbers != null)
{
    array = numbers.ToArray();
}
else
{
    array = new int[0];
}

C#では、null合体演算子を使って短く書くこともできます。

C#
List<int> numbers = null;

int[] array = numbers?.ToArray() ?? new int[0];

この書き方では、numbersがnullの場合は空の配列を代入します。

5-2. 型が一致しない場合のコンパイルエラー

ToArray()の戻り値は、元のList<T>の型に対応した配列です。

たとえば、List<string>をToArray()すると、戻り値はstring[]になります。

C#
List<string> names = new List<string> { "A", "B" };

string[] array = names.ToArray();

これは正しい書き方です。

一方、次のように異なる型の配列に代入しようとすると、コンパイルエラーになります。

C#
List<string> names = new List<string> { "A", "B" };

// エラーになる例
// int[] array = names.ToArray();

List<string>はstring[]に変換する必要があります。

数値型でも同じです。

C#
List<double> values = new List<double> { 1.5, 2.5 };

// 正しい
double[] array = values.ToArray();

// エラー
// int[] array = values.ToArray();

型を変換したい場合は、LINQのSelect()などを使って明示的に変換します。

C#
using System;
using System.Collections.Generic;
using System.Linq;

List<double> values = new List<double> { 1.5, 2.5 };

int[] array = values.Select(x => (int)x).ToArray();

5-3. using System.Collections.Generic;が必要なケース

List<T>を使うには、通常、次のusingが必要です。

C#
using System.Collections.Generic;

これがない場合、環境によってはList<>が見つからず、コンパイルエラーになることがあります。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3 };

        int[] array = numbers.ToArray();

        Console.WriteLine(array.Length);
    }
}

List<T>を使うときは、ファイルの先頭にusing System.Collections.Generic;があるか確認しましょう。

最近のC#プロジェクトでは、暗黙的なusingが有効になっている場合もあります。その場合は明示的に書かなくても動作することがありますが、初心者のうちは必要なusingを理解しておくとエラーの原因を見つけやすくなります。

5-4. ToArray()が使えない場合に確認すべきポイント

ToArray()が使えない場合は、次の点を確認しましょう。

まず、対象が本当にList<T>かどうかを確認します。

C#
List<int> numbers = new List<int> { 1, 2, 3 };

int[] array = numbers.ToArray();

List<T>であれば、基本的にToArray()を使用できます。

次に、変数がnullになっていないかを確認します。

C#
if (numbers != null)
{
    int[] array = numbers.ToArray();
}

また、LINQの結果に対してToArray()を使う場合は、using System.Linq;が必要になることがあります。

C#
using System.Linq;

たとえば、次のようなコードです。

C#
List<int> numbers = new List<int> { 1, 2, 3, 4 };

int[] evenNumbers = numbers
    .Where(x => x % 2 == 0)
    .ToArray();

Where()などのLINQメソッドを使う場合は、using System.Linq;を追加しましょう。

6. LINQや条件付きでListを配列に変換する方法

ToArray()は、LINQと組み合わせることでさらに便利に使えます。

条件に合う要素だけを抽出したり、値を加工したり、並び替えてから配列に変換できます。

6-1. Where()で条件に合う要素だけを配列に変換する

Where()を使うと、条件に合う要素だけを取り出して配列に変換できます。

C#
using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };

        int[] evenNumbers = numbers
            .Where(x => x % 2 == 0)
            .ToArray();

        foreach (int number in evenNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

実行結果は次のとおりです。

2
4
6

この例では、x % 2 == 0という条件に合う偶数だけを抽出しています。

Where()の結果に対してToArray()を呼び出すことで、条件に合った要素だけを配列にできます。

6-2. Select()で加工してから配列に変換する

Select()を使うと、要素を加工してから配列に変換できます。

C#
using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3 };

        int[] doubledNumbers = numbers
            .Select(x => x * 2)
            .ToArray();

        foreach (int number in doubledNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

実行結果は次のようになります。

2
4
6

Select(x => x * 2)によって、それぞれの要素を2倍にしてから配列に変換しています。

文字列の加工にも使えます。

C#
List<string> names = new List<string> { "tanaka", "suzuki", "sato" };

string[] upperNames = names
    .Select(name => name.ToUpper())
    .ToArray();

このように、Select()とToArray()を組み合わせると、加工済みの配列を簡単に作成できます。

6-3. OrderBy()で並び替えてから配列に変換する

OrderBy()を使うと、要素を並び替えてから配列に変換できます。

C#
using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 30, 10, 20 };

        int[] sortedNumbers = numbers
            .OrderBy(x => x)
            .ToArray();

        foreach (int number in sortedNumbers)
        {
            Console.WriteLine(number);
        }
    }
}

実行結果は次のとおりです。

10
20
30

降順にしたい場合は、OrderByDescending()を使います。

C#
int[] sortedNumbers = numbers
    .OrderByDescending(x => x)
    .ToArray();

自作クラスのプロパティで並び替えることもできます。

C#
List<Person> people = new List<Person>
{
    new Person { Name = "Tanaka", Age = 30 },
    new Person { Name = "Suzuki", Age = 25 },
    new Person { Name = "Sato", Age = 28 }
};

Person[] sortedPeople = people
    .OrderBy(person => person.Age)
    .ToArray();

この例では、Ageの小さい順に並び替えてからPerson[]に変換しています。

6-4. LINQを使う場合に必要なusing

Where()、Select()、OrderBy()などのLINQメソッドを使う場合は、次のusingが必要です。

C#
using System.Linq;

List<T>を使うためのusingと合わせると、基本的には次のようになります。

C#
using System;
using System.Collections.Generic;
using System.Linq;

LINQを使わずに単純にListを配列へ変換するだけなら、通常はSystem.Linqは不要です。

C#
List<int> numbers = new List<int> { 1, 2, 3 };

int[] array = numbers.ToArray();

一方で、次のようにWhere()を使う場合はSystem.Linqが必要です。

C#
int[] evenNumbers = numbers
    .Where(x => x % 2 == 0)
    .ToArray();

ToArray()が使えないというより、Where()やSelect()が認識されない場合は、using System.Linq;が不足していないか確認しましょう。

7. Listと配列の使い分け

Listと配列はどちらも複数のデータを扱えますが、用途によって向き不向きがあります。

ここでは、実務でどちらを使うべきか判断するための基準を解説します。

7-1. Listを使うべき場面

List<T>は、要素数が変わる可能性がある場面に向いています。

たとえば、ユーザー入力を順番に追加していく場合や、条件に合うデータだけを集める場合です。

C#
List<string> results = new List<string>();

results.Add("A");
results.Add("B");
results.Add("C");

List<T>はAdd()、Remove()、Clear()などのメソッドが用意されているため、データの追加や削除が簡単です。

C#
results.Remove("B");

処理の途中で要素数が増減する場合は、配列よりもList<T>の方が扱いやすいです。

7-2. 配列を使うべき場面

配列は、要素数が決まっている場面に向いています。

C#
int[] scores = new int[3];

scores[0] = 80;
scores[1] = 90;
scores[2] = 75;

また、既存のAPIやライブラリが配列を要求している場合は、配列を使う必要があります。

C#
void ProcessData(int[] data)
{
    foreach (int item in data)
    {
        Console.WriteLine(item);
    }
}

このようなメソッドにList<int>を渡したい場合は、ToArray()で変換します。

C#
List<int> list = new List<int> { 1, 2, 3 };

ProcessData(list.ToArray());

配列はシンプルなデータ構造なので、固定されたデータを扱う場合に適しています。

7-3. Listから配列への変換が必要になる実務例

実務では、まずListにデータを集めて、最後に配列へ変換する流れがよく使われます。

たとえば、条件に合う商品IDだけを集める処理です。

C#
List<int> targetIds = new List<int>();

foreach (int id in new int[] { 1, 2, 3, 4, 5 })
{
    if (id % 2 == 0)
    {
        targetIds.Add(id);
    }
}

int[] idArray = targetIds.ToArray();

また、外部APIに渡すデータ形式が配列の場合にも使います。

C#
SendIds(targetIds.ToArray());

さらに、LINQで検索・加工した結果を配列として保持したい場合にも便利です。

C#
int[] result = targetIds
    .Where(id => id > 2)
    .ToArray();

データを柔軟に集める段階ではListを使い、最終的に固定データとして渡す段階で配列に変換する、という流れが実務ではよくあります。

7-4. 迷ったときの判断基準

Listと配列のどちらを使うか迷ったときは、要素数が変わるかどうかで判断するとわかりやすいです。

要素の追加や削除があるならList<T>を使います。

C#
List<int> numbers = new List<int>();

numbers.Add(1);
numbers.Add(2);
numbers.Add(3);

要素数が最初から決まっていて、変更しないなら配列を使います。

C#
int[] numbers = new int[] { 1, 2, 3 };

また、メソッドの引数が配列になっている場合は、必要に応じてToArray()で変換します。

C#
SomeMethod(numbers.ToArray());

迷った場合は、処理中はList<T>で扱い、必要なタイミングでToArray()を使って配列に変換する方法が扱いやすいです。

8. Listを配列に変換する方法のよくある質問

最後に、C#でListを配列に変換するときによくある質問をまとめます。

8-1. 空のListをToArray()するとどうなる？

空のListに対してToArray()を呼び出すと、空の配列が返されます。

C#
List<int> numbers = new List<int>();

int[] array = numbers.ToArray();

Console.WriteLine(array.Length);

実行結果は次のとおりです。

0

エラーにはなりません。

List自体がnullではなく、要素数が0であるだけなら、ToArray()は問題なく使えます。

C#
List<string> names = new List<string>();

string[] nameArray = names.ToArray();

この場合、nameArrayは要素数0のstring[]です。

8-2. nullのListをToArray()するとどうなる？

nullのListに対してToArray()を呼び出すと、NullReferenceExceptionが発生します。

C#
List<int> numbers = null;

// エラーになる
// int[] array = numbers.ToArray();

空のListとnullは違います。

空のListはオブジェクトが存在していて、要素数が0の状態です。

C#
List<int> emptyList = new List<int>();

一方、nullはオブジェクトが存在しない状態です。

C#
List<int> nullList = null;

nullの可能性がある場合は、次のように対処します。

C#
int[] array = numbers?.ToArray() ?? Array.Empty<int>();

この書き方なら、numbersがnullの場合でも空の配列を取得できます。

8-3. 配列からListに戻すことはできる？

配列からListに戻すこともできます。

代表的な方法は、ToList()を使う方法です。

C#
using System.Collections.Generic;
using System.Linq;

int[] array = new int[] { 1, 2, 3 };

List<int> list = array.ToList();

ToList()を使う場合は、using System.Linq;が必要です。

また、List<T>のコンストラクタに配列を渡す方法もあります。

C#
int[] array = new int[] { 1, 2, 3 };

List<int> list = new List<int>(array);

この方法なら、配列の内容をもとに新しいList<int>を作成できます。

Listから配列に変換する場合はToArray()、配列からListに変換する場合はToList()またはnew List<T>(array)と覚えておくとよいでしょう。

8-4. ToArray()とCopyTo()の違いは？

ToArray()は、新しい配列を作成して返します。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

一方、CopyTo()は、すでに用意した配列にListの要素をコピーします。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = new int[3];

list.CopyTo(array);

ToArray()は配列の作成まで自動で行うため、簡単に書けます。

CopyTo()は、コピー先の配列を自分で用意する必要があります。

C#
int[] array = new int[list.Count];

list.CopyTo(array);

通常、Listを配列に変換したいだけならToArray()を使うのがわかりやすいです。

CopyTo()は、既存の配列にコピーしたい場合や、特定の位置にコピーしたい場合に使います。

8-5. 多次元配列に変換できる？

ToArray()で直接変換できるのは、基本的に一次元配列です。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

このように、List<int>はint[]になります。

多次元配列にしたい場合は、自分で配列を作成して値を入れる必要があります。

C#
List<int> list = new List<int> { 1, 2, 3, 4, 5, 6 };

int[,] array = new int[2, 3];

int index = 0;

for (int i = 0; i < 2; i++)
{
    for (int j = 0; j < 3; j++)
    {
        array[i, j] = list[index];
        index++;
    }
}

この例では、6個の要素を持つList<int>を、2行3列のint[,]に入れています。

また、ジャグ配列にしたい場合は、List<int[]>やList<List<int>>を使う方法もあります。

C#
List<int[]> rows = new List<int[]>
{
    new int[] { 1, 2, 3 },
    new int[] { 4, 5, 6 }
};

int[][] array = rows.ToArray();

この場合、List<int[]>をToArray()すると、int[][]になります。

多次元配列にしたいのか、ジャグ配列にしたいのかによって書き方が異なるため、目的に合わせて選びましょう。

まとめ

C#でListを配列に変換する基本的な方法は、ToArray()を使うことです。

C#
List<int> list = new List<int> { 1, 2, 3 };

int[] array = list.ToArray();

List<int>ならint[]、List<string>ならstring[]、List<double>ならdouble[]のように、元のList<T>に対応した配列T[]が作成されます。

ToArray()は新しい配列を作成するため、変換後にListを変更しても配列には反映されません。また、変換後の配列を変更しても、元のListには基本的に反映されません。

条件に合う要素だけを配列にしたい場合は、LINQのWhere()と組み合わせます。

C#
int[] evenNumbers = numbers
    .Where(x => x % 2 == 0)
    .ToArray();

加工してから配列にしたい場合は、Select()を使います。

C#
int[] doubledNumbers = numbers
    .Select(x => x * 2)
    .ToArray();

並び替えてから配列にしたい場合は、OrderBy()やOrderByDescending()を使います。

C#
int[] sortedNumbers = numbers
    .OrderBy(x => x)
    .ToArray();

Listを配列に変換するときによくあるエラーとしては、nullのListに対してToArray()を呼び出すケースや、型が一致しない配列に代入しようとするケースがあります。

nullの可能性がある場合は、次のように書くと安全です。

C#
int[] array = numbers?.ToArray() ?? Array.Empty<int>();

C#でデータを柔軟に追加・削除したい場合はList<T>を使い、配列が必要なメソッドに渡すときや固定されたデータとして扱いたいときにToArray()で変換するとよいでしょう。