C#で配列・リスト・文字列を逆順にする方法｜Reverseの使い方をわかりやすく解説

はじめに

C#で「配列を逆順にしたい」「Listを後ろから並べたい」「文字列を反転したい」と思ったときによく使うのが、Reverseです。

ただし、C#のReverseにはいくつか種類があります。たとえば、Array.ReverseやList<T>.Reverseは元のデータそのものを並び替えます。一方、LINQのReverseは元データを変更せず、逆順の結果を返します。

この違いを理解しないまま使うと、「元の配列が書き換わってしまった」「ReverseしたのにListにならない」「文字列に戻せない」といったつまずきが起こりやすくなります。

この記事では、C#で配列・リスト・文字列を逆順にする方法を、初心者にもわかりやすいコード例付きで解説します。逆順と降順の違い、よくあるエラー、実務での使い分けもあわせて確認していきましょう。

1. C#で逆順にする方法の結論

C#で逆順にする方法は、対象が配列なのか、List<T>なのか、文字列なのかによって少し書き方が変わります。

また、「元のデータを直接変更してよいのか」「元のデータは残したまま逆順のデータを作りたいのか」によって、使うメソッドを選ぶ必要があります。

1-1. 配列・リスト・文字列で使うメソッドの早見表

まずは、よく使う書き方を一覧で確認しましょう。

配列やListは、元の中身を直接並び替えることができます。一方、stringは変更できない型なので、逆順にした新しい文字列を作成します。

1-2. Reverseには「元データを変更する方法」と「変更しない方法」がある

C#のReverseで特に重要なのは、次の2種類があることです。

C#
Array.Reverse(array);
list.Reverse();

これらは、元の配列やリスト自体を逆順に並び替えます。

一方、LINQのReverseは次のように使います。

C#
var reversed = numbers.Reverse();

LINQのReverseは、元のデータを変更せず、逆順に列挙するための結果を返します。

たとえば、元の配列を残したい場合は次のように書きます。

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

int[] reversed = numbers.Reverse().ToArray();

Console.WriteLine(string.Join(", ", numbers));  // 1, 2, 3, 4, 5
Console.WriteLine(string.Join(", ", reversed)); // 5, 4, 3, 2, 1

1-3. まず覚えるべき使い分け

最初は、次の使い分けを覚えると実用上困りにくいです。

元のデータを変更してよい場合は、配列ならArray.Reverse、ListならList<T>.Reverseを使います。

C#
Array.Reverse(array);
list.Reverse();

元のデータを残したい場合は、LINQのReverseを使って新しい配列やListに変換します。

C#
var reversedArray = array.Reverse().ToArray();
var reversedList = list.AsEnumerable().Reverse().ToList();

文字列を逆順にしたい場合は、Reverseした結果をToArrayで文字配列にし、new stringで文字列に戻します。

C#
string reversedText = new string(text.Reverse().ToArray());

2. C#のReverseとは

C#のReverseは、要素の並び順を反対にするためのメソッドです。

たとえば、1, 2, 3, 4, 5という並びを5, 4, 3, 2, 1にできます。

ただし、C#では同じReverseという名前でも、呼び出し方によって動作が変わります。ここを理解しておくと、配列・List・文字列の逆順処理で迷いにくくなります。

2-1. Reverseメソッドでできること

Reverseを使うと、次のような処理ができます。

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

Array.Reverse(numbers);

Console.WriteLine(string.Join(", ", numbers));

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

5, 4, 3, 2, 1

このように、現在の並び順をそのまま反転するのがReverseの基本的な役割です。

「値が大きい順に並べる」のではなく、「今の順番を逆にする」という点が重要です。

2-2. Array.Reverse・List<T>.Reverse・LINQのReverseの違い

C#でよく使うReverseには、主に次の3種類があります。

C#
Array.Reverse(array);
list.Reverse();
source.Reverse();

Array.Reverseは配列用のメソッドです。元の配列を直接逆順にします。

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

Array.Reverse(array);

List<T>.ReverseはList用のメソッドです。元のList自体を直接逆順にします。

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

list.Reverse();

LINQのReverseは、IEnumerable<T>に対して使う拡張メソッドです。元データを直接変更せず、逆順に列挙する結果を返します。

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

var reversed = array.Reverse();

2-3. 破壊的操作と非破壊的操作の違い

プログラミングでは、元のデータを変更する処理を「破壊的操作」と呼ぶことがあります。

Array.ReverseやList<T>.Reverseは破壊的操作です。

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

Array.Reverse(numbers);

Console.WriteLine(string.Join(", ", numbers)); // 3, 2, 1

この例では、numbers自体の順番が変わっています。

一方、LINQのReverseは元のデータを変更しない非破壊的な使い方ができます。

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

var reversed = numbers.Reverse();

Console.WriteLine(string.Join(", ", numbers));  // 1, 2, 3
Console.WriteLine(string.Join(", ", reversed)); // 3, 2, 1

元データを残したい場合は、LINQのReverseを使うと安全です。

2-4. using System.Linqが必要なケース

LINQのReverseを使う場合は、通常、ファイルの先頭に次のusingが必要です。

C#
using System.Linq;

たとえば、次のようにarray.Reverse()やtext.Reverse()を使う場合です。

C#
using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3 };

        var reversed = numbers.Reverse();

        Console.WriteLine(string.Join(", ", reversed));
    }
}

Array.Reverse(array)やlist.Reverse()だけを使う場合、LINQのReverseではないため、using System.Linqが不要なケースもあります。

ただし、ToArrayやToListと一緒に使うことも多いため、逆順処理ではusing System.Linq;を追加する場面がよくあります。

3. 配列を逆順にする方法

配列を逆順にする場合は、主に次の2つの方法があります。

元の配列を直接変更するならArray.Reverseを使います。元の配列を残したいなら、LINQのReverseを使います。

3-1. Array.Reverseで元の配列を逆順にする

配列自体を逆順にしたい場合は、Array.Reverseを使います。

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

Array.Reverse(numbers);

Console.WriteLine(string.Join(", ", numbers));

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

5, 4, 3, 2, 1

Array.Reverse(numbers)を実行すると、numbersの中身そのものが逆順に変わります。

文字列の配列でも同じように使えます。

C#
string[] fruits = { "apple", "banana", "orange" };

Array.Reverse(fruits);

Console.WriteLine(string.Join(", ", fruits));

実行結果です。

orange, banana, apple

3-2. LINQのReverseで元の配列を変更せず逆順にする

元の配列を変更したくない場合は、LINQのReverseを使います。

C#
using System;
using System.Linq;

int[] numbers = { 1, 2, 3, 4, 5 };

var reversed = numbers.Reverse();

Console.WriteLine(string.Join(", ", numbers));
Console.WriteLine(string.Join(", ", reversed));

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

1, 2, 3, 4, 5
5, 4, 3, 2, 1

この場合、numbers自体は変更されません。

ただし、reversedの型は配列ではなく、IEnumerable<int>です。配列として使いたい場合はToArrayを使います。

3-3. ToArrayで逆順の配列を作成する

LINQのReverseで得た結果を配列にしたい場合は、ToArrayを使います。

C#
using System;
using System.Linq;

int[] numbers = { 1, 2, 3, 4, 5 };

int[] reversedArray = numbers.Reverse().ToArray();

Console.WriteLine(string.Join(", ", reversedArray));

実行結果です。

5, 4, 3, 2, 1

この書き方では、元のnumbersはそのまま残り、新しい配列reversedArrayが作成されます。

C#
Console.WriteLine(string.Join(", ", numbers));       // 1, 2, 3, 4, 5
Console.WriteLine(string.Join(", ", reversedArray)); // 5, 4, 3, 2, 1

実務では、「元の配列を保持しつつ、逆順の配列も使いたい」という場面でよく使う書き方です。

3-4. 配列の一部だけを逆順にする方法

Array.Reverseでは、配列全体ではなく一部だけを逆順にすることもできます。

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

Array.Reverse(numbers, 1, 3);

Console.WriteLine(string.Join(", ", numbers));

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

1, 4, 3, 2, 5

Array.Reverse(numbers, 1, 3)は、インデックス1から3個分の要素を逆順にします。

対象になるのは、次の部分です。

2, 3, 4

これが逆順になり、次のようになります。

4, 3, 2

配列の一部だけを反転したい場合に便利です。

3-5. 配列を逆順にするときの注意点

配列を逆順にするときに注意したいのは、Array.Reverseが元の配列を変更することです。

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

Array.Reverse(numbers);

Console.WriteLine(string.Join(", ", numbers)); // 3, 2, 1

元の順番を後で使いたい場合、Array.Reverseを直接使うと困ることがあります。

元の配列を残したい場合は、次のようにコピーしてから逆順にするか、LINQを使います。

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

int[] copy = numbers.ToArray();
Array.Reverse(copy);

Console.WriteLine(string.Join(", ", numbers)); // 1, 2, 3
Console.WriteLine(string.Join(", ", copy));    // 3, 2, 1

また、LINQを使う場合は次のように書けます。

C#
int[] reversed = numbers.Reverse().ToArray();

元データを変更してよいのかを確認してから、Array.Reverseを使うようにしましょう。

4. Listを逆順にする方法

List<T>を逆順にする場合は、List<T>.Reverseを使う方法と、LINQのReverseを使う方法があります。

配列と同じように、元のListを変更するかどうかで使い分けます。

4-1. List<T>.Reverseでリスト自体を逆順にする

List自体を逆順にしたい場合は、List<T>.Reverseを使います。

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

numbers.Reverse();

Console.WriteLine(string.Join(", ", numbers));

実行結果です。

5, 4, 3, 2, 1

numbers.Reverse()を実行すると、numbers自体の並び順が変更されます。

文字列のListでも同じです。

C#
List<string> names = new List<string> { "佐藤", "鈴木", "田中" };

names.Reverse();

Console.WriteLine(string.Join(", ", names));

実行結果です。

田中, 鈴木, 佐藤

4-2. LINQのReverseで逆順のリストを作成する

元のListを変更せずに逆順の結果を作りたい場合は、LINQのReverseを使います。

ただし、ListにはList<T>.Reverseという同名のメソッドがあるため、次のように書くと元のListが変更されます。

C#
numbers.Reverse();

LINQのReverseとして使いたい場合は、AsEnumerableを使うと意図が明確になります。

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

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

var reversed = numbers.AsEnumerable().Reverse();

Console.WriteLine(string.Join(", ", numbers));
Console.WriteLine(string.Join(", ", reversed));

実行結果です。

1, 2, 3, 4, 5
5, 4, 3, 2, 1

元のnumbersは変更されていません。

4-3. ToListで逆順のListに変換する

LINQのReverseで得た結果をListとして扱いたい場合は、ToListを使います。

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

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

List<int> reversedList = numbers.AsEnumerable().Reverse().ToList();

Console.WriteLine(string.Join(", ", reversedList));

実行結果です。

5, 4, 3, 2, 1

この書き方なら、元のListを残したまま、逆順の新しいListを作成できます。

C#
Console.WriteLine(string.Join(", ", numbers));      // 1, 2, 3, 4, 5
Console.WriteLine(string.Join(", ", reversedList)); // 5, 4, 3, 2, 1

4-4. 元のリストを残したい場合の書き方

元のListを残したい場合は、主に次の2つの書き方があります。

1つ目は、LINQのReverseを使う方法です。

C#
List<int> reversedList = numbers.AsEnumerable().Reverse().ToList();

2つ目は、コピーを作ってからReverseする方法です。

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

List<int> copy = new List<int>(numbers);
copy.Reverse();

Console.WriteLine(string.Join(", ", numbers)); // 1, 2, 3, 4, 5
Console.WriteLine(string.Join(", ", copy));    // 5, 4, 3, 2, 1

どちらの方法でも、元のnumbersは変更されません。

処理の意図をわかりやすくしたい場合は、AsEnumerable().Reverse().ToList()が読みやすいことが多いです。一方、Listとしてコピーしてから反転する方法は、LINQに慣れていない人にも理解しやすい書き方です。

4-5. List<T>.ReverseとEnumerable.Reverseの使い分け

List<T>.ReverseとEnumerable.Reverseは、同じReverseという名前でも動作が異なります。

List<T>.Reverseは、List自体を変更します。

C#
numbers.Reverse();

Enumerable.Reverseは、元のListを変更せずに逆順の列挙結果を返します。

C#
var reversed = numbers.AsEnumerable().Reverse();

使い分けは次のとおりです。

単にListの順番を変えたいだけならlist.Reverse()で十分です。元データを残したい場合は、LINQのReverseを使いましょう。

5. 文字列を逆順にする方法

C#のstringは、配列やListのように中身を直接変更できません。

そのため、文字列を逆順にしたい場合は、文字列を文字の並びとして扱い、逆順にした結果から新しい文字列を作成します。

5-1. stringをReverseで逆順にする基本コード

文字列を逆順にする基本コードは次のとおりです。

C#
using System;
using System.Linq;

string text = "abcde";

string reversed = new string(text.Reverse().ToArray());

Console.WriteLine(reversed);

実行結果です。

edcba

text.Reverse()で文字を逆順に並べ、ToArray()で文字配列に変換し、new string(...)で文字列に戻しています。

5-2. Reverseした文字列をToArrayとnew stringで戻す方法

stringに対してReverseを使うと、戻り値はstringではありません。

C#
var reversed = text.Reverse();

このreversedは、逆順の文字を列挙するIEnumerable<char>です。そのため、文字列として使うには変換が必要です。

C#
string reversedText = new string(text.Reverse().ToArray());

処理の流れは次のようになります。

string
↓
Reverse
↓
IEnumerable<char>
↓
ToArray
↓
char[]
↓
new string
↓
string

文字列の逆順処理では、この形をまず覚えておくと便利です。

5-3. 拡張メソッドとして文字列反転処理を作る

文字列の反転処理を何度も使う場合は、拡張メソッドにしておくと便利です。

C#
using System.Linq;

public static class StringExtensions
{
    public static string ReverseString(this string text)
    {
        return new string(text.Reverse().ToArray());
    }
}

使う側は次のように書けます。

C#
string text = "abcde";

string reversed = text.ReverseString();

Console.WriteLine(reversed);

実行結果です。

edcba

毎回new string(text.Reverse().ToArray())と書く必要がなくなり、処理の意味もわかりやすくなります。

nullを考慮するなら、次のように書くこともできます。

C#
using System.Linq;

public static class StringExtensions
{
    public static string? ReverseString(this string? text)
    {
        if (text == null)
        {
            return null;
        }

        return new string(text.Reverse().ToArray());
    }
}

5-4. 日本語や絵文字を逆順にするときの注意点

日本語のひらがな・カタカナ・漢字だけであれば、単純なReverseでも期待通りに見えることが多いです。

C#
string text = "こんにちは";

string reversed = new string(text.Reverse().ToArray());

Console.WriteLine(reversed);

実行結果です。

はちにんこ

しかし、絵文字や結合文字を含む文字列では注意が必要です。

C#のstringは内部的にUTF-16のコード単位で扱われるため、単純にchar単位で反転すると、絵文字や濁点付き文字などが崩れる可能性があります。

たとえば、絵文字を含む文字列では、単純なReverseが見た目上の1文字を正しく扱えない場合があります。

C#
string text = "A😀B";

string reversed = new string(text.Reverse().ToArray());

Console.WriteLine(reversed);

このようなケースでは、通常の英数字や簡単な日本語の反転とは違い、Unicodeの「文字として見える単位」を考慮した処理が必要です。

実務でユーザー名、絵文字、各国語の文字列を正確に反転したい場合は、StringInfoなどを使ってテキスト要素単位で処理することを検討します。

C#
using System.Globalization;
using System.Linq;

string text = "A😀B";

TextElementEnumerator enumerator = StringInfo.GetTextElementEnumerator(text);

List<string> elements = new List<string>();

while (enumerator.MoveNext())
{
    elements.Add(enumerator.GetTextElement());
}

elements.Reverse();

string reversed = string.Concat(elements);

Console.WriteLine(reversed);

単純なサンプルや英数字の反転であればnew string(text.Reverse().ToArray())で十分ですが、多言語対応や絵文字を扱う場合は注意しましょう。

5-5. nullや空文字を扱う場合の書き方

文字列がnullの可能性がある場合、そのままReverseを呼ぶとエラーになります。

C#
string? text = null;

string reversed = new string(text.Reverse().ToArray()); // エラー

安全に扱うなら、nullチェックを入れます。

C#
string? text = null;

string? reversed = text == null
    ? null
    : new string(text.Reverse().ToArray());

空文字の場合は、反転しても空文字のままです。

C#
string text = "";

string reversed = new string(text.Reverse().ToArray());

Console.WriteLine(reversed); // 空文字

nullを空文字として扱いたい場合は、次のように書けます。

C#
string? text = null;

string reversed = new string((text ?? "").Reverse().ToArray());

Console.WriteLine(reversed); // 空文字

nullをそのままnullとして返すのか、空文字として扱うのかは、アプリケーションの仕様に合わせて決めましょう。

6. foreachやfor文で逆順に処理する方法

データそのものを逆順に並び替えたいのではなく、「後ろから順番に処理したいだけ」という場合もあります。

その場合、必ずしもReverseでデータを並び替える必要はありません。for文で後ろからループしたり、foreachとLINQのReverseを組み合わせたりできます。

6-1. for文で後ろから順番にループする

配列やListを後ろから処理するなら、for文を使う方法がシンプルです。

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

for (int i = numbers.Length - 1; i >= 0; i--)
{
    Console.WriteLine(numbers[i]);
}

実行結果です。

5
4
3
2
1

Listの場合は、Countを使います。

C#
List<string> names = new List<string> { "佐藤", "鈴木", "田中" };

for (int i = names.Count - 1; i >= 0; i--)
{
    Console.WriteLine(names[i]);
}

実行結果です。

田中
鈴木
佐藤

インデックスを使いたい場合は、for文が便利です。

6-2. foreachとReverseを組み合わせる

逆順に処理したいだけなら、foreachとLINQのReverseを組み合わせる方法もあります。

C#
using System;
using System.Linq;

int[] numbers = { 1, 2, 3, 4, 5 };

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

実行結果です。

5
4
3
2
1

この書き方では、元の配列は変更されません。

Listの場合は、LINQのReverseとして使うためにAsEnumerableを付けると意図が明確です。

C#
foreach (int number in numbers.AsEnumerable().Reverse())
{
    Console.WriteLine(number);
}

6-3. 元データを並び替えずに逆順で出力する

元データを並び替えず、逆順で出力するだけなら、LINQのReverseが便利です。

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

foreach (int number in numbers.AsEnumerable().Reverse())
{
    Console.WriteLine(number);
}

Console.WriteLine(string.Join(", ", numbers));

実行結果です。

5
4
3
2
1
1, 2, 3, 4, 5

元のListはそのまま残っています。

一方、次のようにnumbers.Reverse()と書くと、List自体が逆順になります。

C#
numbers.Reverse();

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

逆順で表示したいだけなのか、データ自体を逆順にしたいのかを分けて考えましょう。

6-4. インデックスが必要な場合の書き方

逆順に処理しながらインデックスも使いたい場合は、for文がわかりやすいです。

C#
string[] items = { "A", "B", "C", "D" };

for (int i = items.Length - 1; i >= 0; i--)
{
    Console.WriteLine($"index: {i}, value: {items[i]}");
}

実行結果です。

index: 3, value: D
index: 2, value: C
index: 1, value: B
index: 0, value: A

「逆順で何番目か」も欲しい場合は、カウンターを別に用意します。

C#
string[] items = { "A", "B", "C", "D" };

int reverseIndex = 0;

for (int i = items.Length - 1; i >= 0; i--)
{
    Console.WriteLine($"reverseIndex: {reverseIndex}, originalIndex: {i}, value: {items[i]}");
    reverseIndex++;
}

元のインデックスが必要ならfor文、値だけを逆順に処理したいならforeachとReverseが使いやすいです。

7. ReverseとOrderByDescendingの違い

C#で「逆順」と「降順」は混同されやすいですが、意味はまったく違います。

Reverseは現在の並び順を反転します。一方、OrderByDescendingは値を基準に大きい順へ並び替えます。

7-1. Reverseは現在の並び順を反転する

Reverseは、現在の並び順をそのまま逆にします。

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

var reversed = numbers.Reverse();

Console.WriteLine(string.Join(", ", reversed));

実行結果です。

4, 2, 5, 1, 3

元の並びが3, 1, 5, 2, 4なので、それを後ろから読んだ4, 2, 5, 1, 3になります。

値の大きさで並び替えているわけではありません。

7-2. OrderByDescendingは値を基準に降順ソートする

OrderByDescendingは、値を基準に大きい順へ並び替えます。

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

var descending = numbers.OrderByDescending(x => x);

Console.WriteLine(string.Join(", ", descending));

実行結果です。

5, 4, 3, 2, 1

この場合は、現在の並び順ではなく、数値の大きさを基準に並び替えています。

文字列の場合も同じように、指定したキーを基準に降順ソートします。

C#
string[] names = { "Sato", "Suzuki", "Tanaka" };

var descending = names.OrderByDescending(x => x);

Console.WriteLine(string.Join(", ", descending));

7-3. 逆順と降順を混同しないための例

次の例を見ると、違いがわかりやすくなります。

C#
int[] numbers = { 10, 3, 8, 1 };

var reversed = numbers.Reverse();
var descending = numbers.OrderByDescending(x => x);

Console.WriteLine(string.Join(", ", reversed));
Console.WriteLine(string.Join(", ", descending));

実行結果です。

1, 8, 3, 10
10, 8, 3, 1

Reverseは、元の並び10, 3, 8, 1を反対にしているだけです。

10, 3, 8, 1
↓
1, 8, 3, 10

OrderByDescendingは、値が大きい順に並べています。

10, 8, 3, 1

つまり、「後ろから表示したい」ならReverse、「大きい順に並べたい」ならOrderByDescendingです。

7-4. 目的別の使い分け

目的に応じて、次のように使い分けます。

たとえば、投稿一覧を新しい順にしたい場合、投稿データが古い順で取得済みならReverseで対応できることがあります。

C#
var newestFirst = posts.Reverse();

しかし、投稿日時を基準に確実に新しい順へ並べたいなら、OrderByDescendingを使う方が適切です。

C#
var newestFirst = posts.OrderByDescending(post => post.CreatedAt);

データがすでに目的の順番で並んでいるかどうかによって、使うメソッドを選びましょう。

8. よくあるエラーと解決方法

C#でReverseを使うときは、いくつかよくあるつまずきがあります。

特に多いのは、Reverseが認識されない、結果がIEnumerableになる、元データが書き換わる、文字列に戻せない、nullでエラーになるといったケースです。

8-1. Reverseが使えない・認識されない場合

array.Reverse()やtext.Reverse()が使えない場合、using System.Linq;が不足している可能性があります。

C#
using System.Linq;

LINQのReverseは拡張メソッドなので、通常はSystem.Linqを読み込む必要があります。

C#
using System;
using System.Linq;

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

var reversed = numbers.Reverse();

Console.WriteLine(string.Join(", ", reversed));

また、配列を直接変更したいだけなら、LINQではなくArray.Reverseを使えます。

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

Array.Reverse(numbers);

Listの場合は、List<T>.Reverseが標準で使えます。

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

numbers.Reverse();

8-2. Reverseの結果がIEnumerableになってしまう場合

LINQのReverseを使うと、結果は配列やListではなくIEnumerable<T>になります。

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

var reversed = numbers.Reverse();

このreversedを配列として使いたい場合は、ToArrayを付けます。

C#
int[] reversedArray = numbers.Reverse().ToArray();

Listとして使いたい場合は、ToListを付けます。

C#
List<int> reversedList = numbers.Reverse().ToList();

ToArrayやToListを使う場合も、通常はusing System.Linq;が必要です。

C#
using System.Linq;

8-3. 元の配列やリストが書き換わってしまう場合

Array.ReverseやList<T>.Reverseを使うと、元データが書き換わります。

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

Array.Reverse(numbers);

Console.WriteLine(string.Join(", ", numbers)); // 3, 2, 1

Listでも同じです。

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

numbers.Reverse();

Console.WriteLine(string.Join(", ", numbers)); // 3, 2, 1

元のデータを残したい場合は、LINQのReverseを使います。

C#
int[] reversedArray = numbers.Reverse().ToArray();

Listの場合は、AsEnumerableを使うと、List<T>.ReverseではなくLINQのReverseを使っていることがわかりやすくなります。

C#
List<int> reversedList = numbers.AsEnumerable().Reverse().ToList();

8-4. 文字列でReverseした結果をstringに戻せない場合

文字列にReverseを使った結果は、stringではなくIEnumerable<char>です。

そのため、次のようには書けません。

C#
string text = "abcde";

string reversed = text.Reverse(); // エラー

正しくは、ToArrayでchar[]に変換し、new stringで文字列を作成します。

C#
string text = "abcde";

string reversed = new string(text.Reverse().ToArray());

Console.WriteLine(reversed); // edcba

文字列を逆順にする場合は、次の形を覚えておきましょう。

C#
new string(text.Reverse().ToArray())

8-5. null参照でエラーになる場合

配列、List、文字列がnullの状態でReverseを呼び出すと、エラーになります。

C#
int[]? numbers = null;

var reversed = numbers.Reverse(); // エラー

nullの可能性がある場合は、事前にチェックします。

C#
int[]? numbers = null;

if (numbers != null)
{
    var reversed = numbers.Reverse().ToArray();
}

空の配列として扱いたい場合は、null合体演算子を使う方法もあります。

C#
int[]? numbers = null;

int[] reversed = (numbers ?? Array.Empty<int>()).Reverse().ToArray();

文字列の場合も同じです。

C#
string? text = null;

string reversed = new string((text ?? "").Reverse().ToArray());

nullを許可する設計なのか、空として扱う設計なのかを決めてから実装しましょう。

9. パフォーマンスと実務での使い分け

C#で逆順処理を書くときは、動けばよいだけでなく、可読性やパフォーマンスも意識すると実務で扱いやすくなります。

基本的には、元データを変更してよいならArray.ReverseやList<T>.Reverse、元データを残したいならLINQのReverseを使うと考えれば十分です。

9-1. 元データを変更してよいならArray.ReverseやList<T>.Reverse

元の配列やListを変更してよい場合は、Array.ReverseやList<T>.Reverseがシンプルです。

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

Array.Reverse(array);

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

list.Reverse();

新しい配列やListを作らずに済むため、余計なメモリ使用を抑えやすい書き方です。

「この後は逆順のデータだけを使う」という場合は、元データを直接反転して問題ないことが多いです。

9-2. 元データを残したいならLINQのReverse

元データを後で使う場合は、LINQのReverseを使って新しい結果を作成します。

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

int[] reversed = numbers.Reverse().ToArray();

Listの場合は次のように書けます。

C#
List<int> reversed = numbers.AsEnumerable().Reverse().ToList();

この書き方なら、元の順番を保持できます。

C#
Console.WriteLine(string.Join(", ", numbers));  // 1, 2, 3, 4, 5
Console.WriteLine(string.Join(", ", reversed)); // 5, 4, 3, 2, 1

データの再利用がある場合や、副作用を避けたい場合は、非破壊的な書き方を選びましょう。

9-3. 大量データで意識したいメモリ使用量

大量データを扱う場合は、新しい配列やListを作ると、その分メモリを使います。

C#
int[] reversed = numbers.Reverse().ToArray();

この書き方では、逆順の新しい配列が作成されます。元の配列も残るため、データ量が多いほどメモリ使用量が増えます。

元データを変更してもよいなら、次のように直接反転した方がメモリ効率はよくなります。

C#
Array.Reverse(numbers);

ただし、元データを変更すると意図しない副作用が起きることもあります。

パフォーマンスだけでなく、データを変更してよいかどうかを優先して判断することが大切です。

9-4. 可読性を重視した書き方

実務では、コードを読んだ人が意図を理解しやすいことも重要です。

元のListを直接変更する意図があるなら、次の書き方はわかりやすいです。

C#
items.Reverse();

元のListを残したいなら、次のように書くと意図が伝わりやすくなります。

C#
var reversedItems = items.AsEnumerable().Reverse().ToList();

文字列の場合は、反転処理をメソッド化すると読みやすくなります。

C#
string reversed = text.ReverseString();

拡張メソッドを用意しておけば、処理の中身を毎回意識せずに使えます。

C#
public static string ReverseString(this string text)
{
    return new string(text.Reverse().ToArray());
}

短い処理でも、何をしたいのかが伝わる名前を付けることで、保守しやすいコードになります。

10. C#の逆順処理に関するFAQ

ここでは、C#で配列・List・文字列を逆順にするときによくある質問をまとめます。

10-1. Reverseは元のデータを変更しますか？

使うReverseによって変わります。

Array.Reverseは元の配列を変更します。

C#
Array.Reverse(array);

List<T>.Reverseは元のListを変更します。

C#
list.Reverse();

LINQのReverseは元データを変更せず、逆順に列挙する結果を返します。

C#
var reversed = array.Reverse();

元データを変更したくない場合は、LINQのReverseを使い、必要に応じてToArrayやToListで変換しましょう。

10-2. 配列とListでReverseの書き方は違いますか？

はい、元データを直接変更する場合は書き方が違います。

配列の場合は、Array.Reverseを使います。

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

Array.Reverse(numbers);

Listの場合は、Listのインスタンスに対してReverseを呼びます。

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

numbers.Reverse();

元データを変更しない場合は、どちらもLINQのReverseを使えます。

C#
int[] reversedArray = array.Reverse().ToArray();

List<int> reversedList = list.AsEnumerable().Reverse().ToList();

10-3. 文字列を一番簡単に逆順にする方法は？

英数字などの単純な文字列であれば、次の書き方が簡単です。

C#
using System.Linq;

string text = "abcde";

string reversed = new string(text.Reverse().ToArray());

実行結果です。

edcba

ただし、絵文字や結合文字を含む文字列では、単純なchar単位の反転では文字が崩れる可能性があります。

通常の英数字や簡単な日本語を反転するだけなら、new string(text.Reverse().ToArray())を覚えておけばよいでしょう。

10-4. 逆順と降順の違いは何ですか？

逆順は、現在の並び順を反対にすることです。

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

var reversed = numbers.Reverse();

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

5, 1, 3

降順は、値を基準に大きい順へ並べることです。

C#
var descending = numbers.OrderByDescending(x => x);

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

5, 3, 1

現在の順番を反転したいならReverse、値の大きい順に並べたいならOrderByDescendingを使います。

10-5. Reverseした結果を配列やListに戻すには？

LINQのReverseの結果を配列に戻すには、ToArrayを使います。

C#
int[] reversedArray = numbers.Reverse().ToArray();

Listに戻すには、ToListを使います。

C#
List<int> reversedList = numbers.Reverse().ToList();

元のデータがListで、元のListを変更したくない場合は、次のように書くとわかりやすいです。

C#
List<int> reversedList = numbers.AsEnumerable().Reverse().ToList();

Reverseしただけでは配列やListにならないことがあるため、必要な型に応じて変換しましょう。

10-6. C#で逆順に出力するだけならどの方法がよいですか？

逆順に出力するだけなら、元データを変更しない方法がおすすめです。

配列なら次のように書けます。

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

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

Listなら、LINQのReverseを使う意図を明確にするためにAsEnumerableを付けるとよいです。

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

foreach (int number in numbers.AsEnumerable().Reverse())
{
    Console.WriteLine(number);
}

インデックスが必要な場合は、for文で後ろから処理します。

C#
for (int i = numbers.Count - 1; i >= 0; i--)
{
    Console.WriteLine(numbers[i]);
}