【C#】もう迷わない！IEnumerable、IList、ICollectionの正しい選択方法

実務経験半年以上のエンジニア探してます！

>> 【急募】C# または TypeScript エンジニア募集（完全フルリモート）

こんにちは！

C#のコレクション操作において、「IEnumerable」「IList」「ICollection」。これらのインターフェースの違いと使い分けについて、詳しく知りたくありませんか？

IEnumerableって何だろう？IListとの違いは？

どのインターフェースをいつ使えばいいの？

Listクラスとインターフェースの関係がよくわからない…

C#でのコレクション処理において、このような疑問をお持ちではないでしょうか。

この記事では、C#の重要なコレクションインターフェース「IEnumerable」「IList」「ICollection」について、基本概念から具体的な使い分け、そして実践的な例までを詳しく解説します。

この記事は次のような方におすすめです。

この記事はこんな人におすすめ！

C#のコレクションインターフェースの違いを理解したい方
適切なインターフェースの選び方を知りたい開発者
メソッドの引数や戻り値の型選択で迷っている方
コードの可読性と保守性を向上させたい方
LINQ操作をより効率的に行いたい方

この記事を読めば、各インターフェースの特徴が理解でき、実際のプロジェクトで適切な型選択ができるスキルが身につきます。C#での効率的なコレクション処理を取り入れて、より洗練されたコードを書けるようになりましょう。

「C#のコレクション操作を極めたい方」「設計レベルでのコード品質を向上させたい方」は、ぜひ参考にしてください。

それでは、順を追って詳しく見ていきましょう！

Contents

C#コレクションインターフェースとは何か

C#におけるコレクションインターフェースは、様々な種類のコレクション（配列、リスト、辞書など）に対して統一された操作方法を提供する重要な仕組みです。これらのインターフェースを理解することで、柔軟で保守性の高いコードを書くことができます。

コレクションインターフェースの基本的な特徴は以下の通りです。

異なるコレクション型に対して統一されたアクセス方法を提供する
ポリモーフィズムを活用して、実装の詳細に依存しないコードを書ける
メソッドの引数や戻り値の型として使用することで、コードの柔軟性が向上する
必要最小限の機能のみを公開することで、コードの意図を明確にする

インターフェースの継承関係

C#のコレクションインターフェースには明確な継承関係があります。この関係を理解することは、適切なインターフェース選択の基礎となります。

インターフェース	継承元	主な機能
IEnumerable<T>	なし	要素の列挙（反復処理）
ICollection<T>	IEnumerable<T>	要素の追加・削除、要素数の取得
IList<T>	ICollection<T>	インデックスによる要素アクセス

継承関係により、下位のインターフェースは上位のインターフェースの機能をすべて持っています。つまり、IList<T>はICollection<T>とIEnumerable<T>の機能をすべて利用できます。

IEnumerable<T>とは

IEnumerable<T>は、C#におけるコレクションインターフェースの最も基本的なものです。「列挙可能」という意味の通り、コレクションの要素を順番に取り出すことができる機能を提供します。

IEnumerable<T>の特徴

IEnumerable<T>には以下のような特徴があります。

特徴	説明
読み取り専用	要素の追加や削除はできません。
順次アクセス	要素を順番に取り出すことのみ可能です。
遅延評価	LINQと組み合わせることで、必要な時まで処理を遅延できます。
foreach対応	C#のforeach文で直接使用できます。

IEnumerable<T>の基本的な使い方

IEnumerable<T>の基本的な使用例を見てみましょう。

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
  static void Main()
  {
    // 整数の配列を作成
    int[] numbers = { 1, 2, 3, 4, 5 };

    // IEnumerable<int>として扱う
    IEnumerable<int> enumerable = numbers;

    // foreach文で要素を列挙
    Console.WriteLine("IEnumerableの要素:");
    foreach (int number in enumerable)
    {
      Console.Write($"{number} ");
    }
    Console.WriteLine();

    // LINQを使った処理
    var evenNumbers = enumerable.Where(x => x % 2 == 0);
    Console.WriteLine("偶数のみ:");
    foreach (int number in evenNumbers)
    {
      Console.Write($"{number} ");
    }
  }
}

この例では、配列をIEnumerable<int>として扱い、foreach文とLINQを使用して要素を処理しています。

ICollection<T>とは

ICollection<T>は、IEnumerable<T>を継承したインターフェースで、コレクションの要素を追加・削除する機能と、要素数を取得する機能を追加で提供します。

ICollection<T>の特徴

ICollection<T>の主な特徴は以下の通りです。

特徴	説明
要素の変更	Add、Remove、Clearメソッドでコレクションを変更できます。
要素数の取得	Countプロパティで要素数を即座に取得できます。
存在確認	Containsメソッドで特定の要素が存在するかチェックできます。
読み取り専用判定	IsReadOnlyプロパティでコレクションが変更可能かどうか確認できます。

ICollection<T>の基本的な使い方

ICollection<T>を使用した例を見てみましょう。

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
    // List<string>をICollection<string>として扱う
    ICollection<string> fruits = new List<string> { "りんご", "バナナ", "オレンジ" };

    // 要素数を表示
    Console.WriteLine($"要素数: {fruits.Count}");

    // 要素を追加
    fruits.Add("ぶどう");
    Console.WriteLine($"追加後の要素数: {fruits.Count}");

    // 要素の存在確認
    if (fruits.Contains("バナナ"))
    {
      Console.WriteLine("バナナが見つかりました");
    }

    // 要素を削除
    fruits.Remove("オレンジ");
    Console.WriteLine($"削除後の要素数: {fruits.Count}");

    // すべての要素を表示
    Console.WriteLine("現在の要素:");
    foreach (string fruit in fruits)
    {
      Console.WriteLine($"- {fruit}");
    }
  }
}

この例では、List<string>をICollection<string>として扱い、要素の追加・削除・検索を行っています。

IList<T>とは

IList<T>は、ICollection<T>を継承したインターフェースで、インデックスによる要素へのアクセス機能を追加で提供します。これにより、配列のような操作が可能になります。

IList<T>の特徴

IList<T>には以下のような特徴があります。

特徴	説明
インデックスアクセス	インデクサ（[]演算子）で特定位置の要素にアクセスできます。
位置指定挿入	Insertメソッドで特定の位置に要素を挿入できます。
位置指定削除	RemoveAtメソッドで特定の位置の要素を削除できます。
要素の検索	IndexOfメソッドで特定の要素のインデックスを取得できます。

IList<T>の基本的な使い方

IList<T>を使用した例を見てみましょう。

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
    // List<int>をIList<int>として扱う
    IList<int> numbers = new List<int> { 10, 20, 30, 40, 50 };

    // インデックスでアクセス
    Console.WriteLine($"最初の要素: {numbers[0]}");
    Console.WriteLine($"最後の要素: {numbers[numbers.Count - 1]}");

    // 要素を変更
    numbers[2] = 35;
    Console.WriteLine($"3番目の要素を変更: {numbers[2]}");

    // 特定の位置に要素を挿入
    numbers.Insert(1, 15);
    Console.WriteLine($"インデックス1に15を挿入後: {numbers[1]}");

    // 要素のインデックスを検索
    int index = numbers.IndexOf(35);
    Console.WriteLine($"35のインデックス: {index}");

    // 特定の位置の要素を削除
    numbers.RemoveAt(0);
    Console.WriteLine($"最初の要素を削除後の新しい最初の要素: {numbers[0]}");

    // すべての要素を表示
    Console.WriteLine("現在の要素:");
    for (int i = 0; i < numbers.Count; i++)
    {
      Console.WriteLine($"[{i}] = {numbers[i]}");
    }
  }
}

この例では、List<int>をIList<int>として扱い、インデックスによる操作を行っています。

インターフェースと具象クラスの関係

C#のコレクションでは、Listクラスのような具象クラスが複数のインターフェースを実装しています。この関係を理解することで、適切な型選択ができるようになります。

using System;
using System.Collections.Generic;

class Program
{
  static void Main()
  {
    // Listクラスは複数のインターフェースを実装している
    List<string> list = new List<string> { "A", "B", "C" };

    // 同じオブジェクトを異なるインターフェース型として扱える
    IEnumerable<string> enumerable = list;
    ICollection<string> collection = list;
    IList<string> ilist = list;

    Console.WriteLine("各インターフェースの実際の使用例:");

    // IEnumerableでは反復のみ
    Console.WriteLine("\nIEnumerableでのforeach反復:");
    foreach (string item in enumerable)
    {
      Console.Write($"{item} ");
    }
    Console.WriteLine();

    // ICollectionでは要素数取得と要素の変更が可能
    Console.WriteLine($"\nICollection: 元の要素数={collection.Count}");
    collection.Add("D");
    Console.WriteLine($"要素追加後の要素数={collection.Count}");

    // IListではさらにインデックスアクセスが可能
    Console.WriteLine($"\nIList: インデクサアクセス [0]={ilist[0]}");
    ilist[0] = "A1";
    Console.WriteLine($"要素変更後 [0]={ilist[0]}");
  }
}

インターフェースの使い分け

どのインターフェースを使用するかは、その場面で必要な機能によって決まります。以下のガイドラインを参考にしてください。

用途	推奨インターフェース	理由
要素の反復処理のみ	IEnumerable<T>	最小限の機能で意図が明確
要素数の取得が必要	ICollection<T>	Count プロパティが利用可能
要素の追加・削除が必要	ICollection<T>	Add/Remove メソッドが利用可能
インデックスアクセスが必要	IList<T>	インデクサとInsert/RemoveAtが利用可能

メソッドの引数での使い分け

メソッドの引数では、必要最小限のインターフェースを使用することが推奨されます。

using System;
using System.Collections.Generic;

class CollectionProcessor
{
  // 要素を表示するだけなのでIEnumerableを使用
  public static void PrintItems<T>(IEnumerable<T> items)
  {
    foreach (T item in items)
    {
      Console.WriteLine(item);
    }
  }

  // 要素数が必要なのでICollectionを使用
  public static void PrintCount<T>(ICollection<T> items)
  {
    Console.WriteLine($"要素数: {items.Count}");
  }

  // インデックスアクセスが必要なのでIListを使用
  public static void PrintFirstAndLast<T>(IList<T> items)
  {
    if (items.Count > 0)
    {
      Console.WriteLine($"最初: {items[0]}");
      Console.WriteLine($"最後: {items[items.Count - 1]}");
    }
  }
}

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

    // 同じListオブジェクトを異なるインターフェースとして渡せる
    CollectionProcessor.PrintItems(numbers);      // IEnumerable<int>として
    CollectionProcessor.PrintCount(numbers);      // ICollection<int>として
    CollectionProcessor.PrintFirstAndLast(numbers); // IList<int>として
  }
}

メソッドの戻り値での使い分け

メソッドの戻り値では、呼び出し側に必要な機能に応じて適切なインターフェースを選択します。

using System;
using System.Collections.Generic;
using System.Linq;

class TaskManager
{
  private List<string> _tasks = new List<string> { "メール確認", "会議準備", "資料作成" };

  // 反復処理のみを想定した場合（IEnumerable）
  public IEnumerable<string> GetTasksForDisplay()
  {
    return _tasks; // 表示用
  }

  // 要素数チェックや存在確認が必要な場合（ICollection）
  public ICollection<string> GetTasksForAnalysis()
  {
    return new List<string>(_tasks); // Countや含有チェックが可能
  }

  // インデックスアクセスや位置指定操作が必要な場合（IList）
  public IList<string> GetTasksForEditing()
  {
    return new List<string>(_tasks); // 自由に編集可能
  }
}

{
  static void Main()
  {
    var taskManager = new TaskManager();

    // IEnumerableの使用例：表示のみ
    Console.WriteLine("=== タスク一覧表示（IEnumerable） ===");
    var displayTasks = taskManager.GetTasksForDisplay();
    foreach (var task in displayTasks)
    {
      Console.WriteLine($"- {task}");
    }

    // ICollectionの使用例：要素数チェックと存在確認
    Console.WriteLine("\n=== タスク分析（ICollection） ===");
    var analysisTasks = taskManager.GetTasksForAnalysis();
    Console.WriteLine($"総タスク数: {analysisTasks.Count}");
    Console.WriteLine($"「会議準備」が含まれている: {analysisTasks.Contains("会議準備")}");

    // 新しいタスクを追加
    analysisTasks.Add("進捗報告");
    Console.WriteLine($"タスク追加後の総数: {analysisTasks.Count}");

    // IListの使用例：インデックスアクセスと位置指定操作
    Console.WriteLine("\n=== タスク編集（IList） ===");
    var editTasks = taskManager.GetTasksForEditing();
    Console.WriteLine($"最初のタスク: {editTasks[0]}");

    // 特定位置にタスクを挿入
    editTasks.Insert(1, "緊急対応");
    Console.WriteLine("緊急タスクを2番目に挿入:");
    for (int i = 0; i < editTasks.Count; i++)
    {
      Console.WriteLine($"  {i + 1}. {editTasks[i]}");
    }

    // 最初のタスクを変更
    editTasks[0] = "メール確認（優先）";
    Console.WriteLine($"\n最初のタスクを変更: {editTasks[0]}");
  }
}

パフォーマンス考慮事項

各インターフェースを選択する際には、パフォーマンスへの影響も考慮する必要があります。

IEnumerableの遅延評価

IEnumerableは遅延評価をサポートしており、大量のデータを効率的に処理できます。

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
  static void Main()
  {
    var numbers = Enumerable.Range(1, 1000000);

    // 遅延評価：この時点では実際の処理は行われない
    var evenNumbers = numbers.Where(x => x % 2 == 0);
    var firstTenEven = evenNumbers.Take(10);

    Console.WriteLine("最初の10個の偶数:");
    // foreach で初めて実際の処理が行われる
    foreach (var number in firstTenEven)
    {
      Console.Write($"{number} ");
    }
  }
}

Count操作の効率性

ICollectionのCountプロパティは即座に要素数を返しますが、IEnumerableのCount()拡張メソッドは要素を数える必要がある場合があります。

using System;
using System.Collections.Generic;
using System.Linq;

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

    // ICollectionのCountプロパティ（効率的）
    ICollection<int> collection = list;
    int count1 = collection.Count; // O(1)

    // IEnumerableのCount()メソッド（場合によっては非効率）
    IEnumerable<int> enumerable = list.Where(x => x > 0);
    int count2 = enumerable.Count(); // O(n) - 要素を数える必要がある

    Console.WriteLine($"Collection.Count: {count1}");
    Console.WriteLine($"Enumerable.Count(): {count2}");
  }
}

実践的な例：データ処理システム

これまでの知識を組み合わせて、実践的なデータ処理システムの例を見てみましょう。

using System;
using System.Collections.Generic;
using System.Linq;

// 商品クラス
class Product
{
  public int Id { get; set; }
  public string Name { get; set; }
  public decimal Price { get; set; }
  public string Category { get; set; }

  public override string ToString()
  {
    return $"[{Id}] {Name} - {Price:C} ({Category})";
  }
}

// 商品管理サービス
class ProductService
{
  private readonly List<Product> _products;

  public ProductService()
  {
    _products = new List<Product>
    {
      new Product { Id = 1, Name = "ノートPC", Price = 80000, Category = "電子機器" },
      new Product { Id = 2, Name = "マウス", Price = 3000, Category = "電子機器" },
      new Product { Id = 3, Name = "本", Price = 1500, Category = "書籍" },
      new Product { Id = 4, Name = "ペン", Price = 200, Category = "文具" }
    };
  }

  // 読み取り専用ですべての商品を取得
  public IEnumerable<Product> GetAllProducts()
  {
    return _products;
  }

  // カテゴリで絞り込み（遅延評価）
  public IEnumerable<Product> GetProductsByCategory(string category)
  {
    return _products.Where(p => p.Category == category);
  }

  // 商品を追加（ICollectionの機能を内部的に使用）
  public void AddProduct(Product product)
  {
    _products.Add(product);
  }

  // 特定の商品を取得（IListの機能を内部的に使用）
  public Product GetProductAt(int index)
  {
    if (index >= 0 && index < _products.Count)
    {
      return _products[index];
    }
    return null;
  }
}

class Program
{
  static void Main()
  {
    var service = new ProductService();

    // すべての商品を表示（IEnumerableとして処理）
    Console.WriteLine("=== すべての商品 ===");
    DisplayProducts(service.GetAllProducts());

    // カテゴリで絞り込み（IEnumerableとして処理）
    Console.WriteLine("\n=== 電子機器のみ ===");
    DisplayProducts(service.GetProductsByCategory("電子機器"));

    // 商品を追加
    service.AddProduct(new Product { Id = 5, Name = "キーボード", Price = 5000, Category = "電子機器" });

    Console.WriteLine("\n=== 商品追加後 ===");
    DisplayProducts(service.GetAllProducts());

    // 最初の商品を取得
    var firstProduct = service.GetProductAt(0);
    Console.WriteLine($"\n最初の商品: {firstProduct}");
  }

  // IEnumerableを受け取るメソッド
  static void DisplayProducts(IEnumerable products)
  {
    foreach (var product in products)
    {
      Console.WriteLine(product);
    }
  }
}

この例では、ProductServiceクラスが内部的にList<Product>を使用しながら、外部には適切なインターフェース（主にIEnumerable<Product>）を公開しています。これにより、実装の詳細を隠蔽しながら、必要な機能のみを提供しています。

キャリア形成/給与還元
ひとつひとつ真摯に向き合う企業