C#という言語を扱う上で、「using」というキーワードは避けて通ることのできない極めて重要な要素です。

このキーワードには、大きく分けて「名前空間の指定」と「リソースの管理」という2つの全く異なる役割があります。

初心者から中級者へとステップアップするためには、これら2つの役割を正しく理解し、さらには近年のアップデートで追加された「using宣言」や「グローバルusing」といったモダンな記述方法を使いこなす必要があります。

本記事では、C#におけるusingの全機能を、基礎から応用まで徹底的に解説します。

目次 [ close ]
  1. usingキーワードが持つ2つの主要な役割
  2. 名前空間を指定するusingディレクティブ
    1. 基本的な名前空間の参照
    2. usingエイリアス（別名指定）
    3. static usingディレクティブ（C# 6.0～）
    4. グローバルusing（C# 10.0～）
  3. リソース管理を行うusingステートメント
    1. 従来のusingステートメント（ブロック形式）
    2. usingステートメントの内部動作
  4. モダンな記述：C# 8.0のusing宣言
    1. using宣言のコード例
    2. 複数のリソースを扱う比較
  5. IAsyncDisposableとawait using（C# 8.0～）
  6. 実践的な使用シナリオ：データベース接続
  7. usingを使用する際の注意点とベストプラクティス
    1. IDisposableを実装していない型には使えない
    2. Dispose済みのオブジェクトへのアクセス
    3. DisposeとCloseの違い
  8. よくある質問とトラブルシューティング
  9. まとめ

usingキーワードが持つ2つの主要な役割

C#のプログラムを書く際、コードの冒頭で必ずと言っていいほど目にするのが using です。

しかし、同じキーワードでありながら、その用途は文脈によって大きく異なります。

まず1つ目の役割は、名前空間（Namespace）の参照を簡略化する「ディレクティブ」としての機能です。

これにより、長い完全修飾名を記述することなく、クラスやメソッドを呼び出すことが可能になります。

2つ目の役割は、メモリやファイルハンドルなどのリソースを確実に解放する「ステートメント」および「宣言」としての機能です。

C#のガベージコレクション（GC）は非常に優秀ですが、ファイル操作やネットワーク接続といった「アンマネージリソース」の管理には、明示的な解放処理が求められます。

これを自動化し、プログラムの安定性を高めるのがusingの役割です。

本記事では、まずディレクティブとしての使い方を解説し、その後にリソース管理というより深いテーマへと掘り下げていきます。

名前空間を指定するusingディレクティブ

C#のクラスは、役割ごとに「名前空間」というグループに分けられています。

例えば、標準的な入出力に関するクラスは System.IO に、リストなどのコレクションに関するクラスは System.Collections.Generic に含まれています。

基本的な名前空間の参照

通常、別の名前空間にあるクラスを使用する場合、System.Console.WriteLine() のようにフルネーム（完全修飾名）で記述しなければなりません。

しかし、ファイル冒頭で using System; と記述しておくことで、単に Console.WriteLine() と記述できるようになります。

C#
using System; // 名前空間の指定

namespace UsingSample
{
    class Program
    {
        static void Main()
        {
            // System. を省略して記述できる
            Console.WriteLine("Hello, Using!");
        }
    }
}

usingエイリアス（別名指定）

同じプロジェクト内で、異なる名前空間に同名のクラスが存在する場合があります。

例えば、System.Timers.Timer と System.Threading.Timer です。

これらを同時に使用すると、単に Timer と書いただけではコンパイラがどちらを指しているか判断できず、エラーが発生します。

このような場合に便利なのが、usingエイリアスです。

特定の型や名前空間に短い別名を与えることができます。

C#
using ThreadTimer = System.Threading.Timer; // 別名の定義
using Timer = System.Timers.Timer;

class AliasSample
{
    void CreateTimers()
    {
        // 別名を使って区別する
        var t1 = new ThreadTimer(state => { }, null, 0, 1000);
        var t2 = new Timer();
    }
}

static usingディレクティブ（C# 6.0～）

C# 6.0からは、特定のクラスの静的（static）メンバを、クラス名を介さずに直接呼び出せる using static が導入されました。

数学計算を行う Math クラスなどで多用されます。

C#
using static System.Math; // 静的メンバのインポート
using System;

class StaticUsingSample
{
    void Calculate()
    {
        // Math.Sqrt ではなく Sqrt と書ける
        double result = Sqrt(25);
        Console.WriteLine(result);
    }
}

この機能を使うとコードが簡潔になりますが、メソッドの由来が不明確になりやすいため、多用しすぎないよう注意が必要です。

グローバルusing（C# 10.0～）

C# 10.0からは、プロジェクト全体のすべてのファイルに対して名前空間を適用する Global using が追加されました。

これにより、すべてのファイルの冒頭に同じ using を書く手間が省けます。

通常は GlobalUsings.cs といったファイルを作成し、そこに記述するのが一般的です。

C#
// GlobalUsings.cs などのファイルに1回書くだけでOK
global using System;
global using System.Collections.Generic;
global using System.Linq;

また、最新の.NETプロジェクトでは、プロジェクトファイル（.csproj）の設定で <ImplicitUsings>enable</ImplicitUsings> が有効になっている場合、一般的な名前空間が自動的にグローバル適用されます。

リソース管理を行うusingステートメント

次に、もう一つの重要な機能である「リソース管理」としての using について解説します。

C#には、メモリ管理を行う「ガベージコレクション（GC）」が存在しますが、GCはあくまで「メモリ」の管理が主目的です。

一方で、ファイル、データベース接続、ネットワークソケット、グラフィックコンテキストなどは「アンマネージリソース」と呼ばれ、使い終わったら即座に、かつ確実に解放しなければなりません。

これらを実現するのが IDisposable インターフェースであり、その Dispose メソッドの呼び出しを保証するのが using です。

従来のusingステートメント（ブロック形式）

最も基本的な使い方は、using ( ... ) { ... } というブロック形式です。

このブロックを抜ける際、例外が発生したとしても、必ず Dispose メソッドが呼び出されます。

C#
using System;
using System.IO;

class FileSample
{
    public void WriteFile()
    {
        // StreamWriterはIDisposableを継承している
        using (StreamWriter sw = new StreamWriter("test.txt"))
        {
            sw.WriteLine("Hello, C#!");
        } // ここで自動的に sw.Dispose() が呼ばれ、ファイルが閉じられる
    }
}

usingステートメントの内部動作

コンパイラは、この using ブロックを try-finally 構造に展開します。

実際には以下のようなコードと同等の処理が行われています。

C#
{
    StreamWriter sw = new StreamWriter("test.txt");
    try
    {
        sw.WriteLine("Hello, C#!");
    }
    finally
    {
        if (sw != null)
        {
            ((IDisposable)sw).Dispose();
        }
    }
}

自分で try-finally を書くのは煩雑でミスが起きやすいため、IDisposableを実装したクラスを扱う際は必ず using を使うようにしましょう。

モダンな記述：C# 8.0のusing宣言

C# 8.0では、より簡潔に記述できる using宣言（using declaration） が導入されました。

中括弧 {} によるスコープを定義せず、変数の宣言の前に using キーワードを付けるだけで、その変数が属するスコープ（通常はメソッドの終了時など）を抜けるときに自動で Dispose されます。

using宣言のコード例

C#
using System.IO;

class ModernSample
{
    public void ReadFile()
    {
        // C# 8.0以降の書き方
        using var reader = new StreamReader("test.txt");
        
        string content = reader.ReadToEnd();
        System.Console.WriteLine(content);

        // メソッドの終了時に自動で Dispose() される
    }
}

この書き方のメリットは、ネスト（入れ子）が深くならないことです。

特に複数のリソースを同時に扱う場合、従来のステートメント形式では階段状にネストが深くなってしまいましたが、using宣言ならフラットに記述できます。

複数のリソースを扱う比較

記述方法特徴
従来のステートメント解放のタイミングを明確に制御できるが、ネストが深くなりやすい。
モダンなusing宣言コードが非常にシンプル。現在のスコープ（メソッド終了時など）で解放される。

IAsyncDisposableとawait using（C# 8.0～）

現代のアプリケーション開発、特にASP.NET Coreやクラウドアプリケーションでは、非同期処理が不可欠です。

リソースの解放処理自体がネットワーク通信を伴うなど、非同期で行う必要がある場合のために、IAsyncDisposable インターフェースが用意されています。

これを扱うのが await using です。

C#
public async Task ProcessAsync()
{
    // 非同期でのリソース解放をサポート
    await using (var resource = new MyAsyncResource())
    {
        await resource.DoSomethingAsync();
    } // ここで DisposeAsync() が await 付きで呼ばれる
}

もちろん、前述の「using宣言」と組み合わせて await using var resource = ...; と書くことも可能です。

実践的な使用シナリオ：データベース接続

実務で最も頻繁に using が活躍するのは、データベース（DB）操作です。

DB接続は限られた貴重なリソースであり、接続したまま放置すると「コネクションプール不足」を引き起こし、システム全体がダウンする原因となります。

C#
using System;
using System.Data.SqlClient; // SQL Server用

public class DatabaseRepo
{
    private string connectionString = "YourConnectionString";

    public void GetData()
    {
        // Connection, Command, DataReaderはすべてIDisposable
        using var connection = new SqlConnection(connectionString);
        using var command = new SqlCommand("SELECT * FROM Users", connection);
        
        connection.Open();
        
        using var reader = command.ExecuteReader();
        while (reader.Read())
        {
            Console.WriteLine(reader["UserName"]);
        }
        // reader, command, connection の順に自動解放される
    }
}

このように、複数のリソースを扱う場合でも using var を使うことで、可読性を損なわずに安全なコードを記述できます。

usingを使用する際の注意点とベストプラクティス

強力な機能である using ですが、正しく使うためのポイントがいくつかあります。

IDisposableを実装していない型には使えない

using ステートメントや宣言に使用できるのは、System.IDisposable（または非同期の場合は System.IAsyncDisposable）を実装しているクラスに限られます。

自作クラスでリソース管理を行いたい場合は、必ずこのインターフェースを継承し、Dispose メソッドを実装してください。

Dispose済みのオブジェクトへのアクセス

using ブロックを抜けた後のオブジェクトにアクセスしようとすると、ObjectDisposedException がスローされます。

C#
StreamWriter sw;
using (sw = new StreamWriter("test.txt"))
{
    sw.WriteLine("Working...");
}
sw.WriteLine("Error!"); // ここで例外発生

特に「using宣言」を使用している場合、変数がどこまで有効（Disposeされていない状態）なのか、スコープの範囲を常に意識する必要があります。

DisposeとCloseの違い

多くのクラス（StreamやSqlConnectionなど）には Close() メソッドが存在します。

一般的に、Dispose() は内部的に Close() を呼び出すため、using を使っていれば明示的に Close() を呼ぶ必要はありません。

よくある質問とトラブルシューティング

usingを使わないとどうなりますか？

メモリ上のオブジェクトは最終的にGCによって回収されますが、ファイルやDB接続などの外部リソースはGCが動くまでロックされたままになる可能性があります。

これにより、例えば「ファイルが別のプロセスで使用されているため開けません」といったエラーや、システムのメモリ不足を引き起こすことがあります。

対策としては、明示的にusingや破棄処理を行い、外部リソースを確実に解放することが重要です。

foreach文の内部でusingを使っても大丈夫ですか？

はい、問題ありません。

ループの各回で生成されたオブジェクトは各イテレーション内で破棄されるため、リソースの占有時間を短くできます。

ただし、極端にパフォーマンスが求められる場面では、オブジェクトの再利用を検討すると良い場合もあります。

foreach内でのusingは一般に安全かつ推奨される使い方です。

static using と通常の using、どちらを優先すべきですか？

基本的には通常のusing（クラス名を明示して書く）を優先するのが安全です。

可読性や名前衝突の観点で明示的な方が扱いやすいためです。

ただし、Mathクラスや頻繁に使う定数クラスのように特定のメンバーを多用する場合は、static usingを使うことでコードがすっきりするため、状況に応じて使い分けると良いでしょう。

まとめ

C#の using は、コードの可読性を高めるディレクティブとしての顔と、システムの安定性を支えるリソース管理としての顔を持つ、非常に多機能なキーワードです。

  • ディレクティブ: 名前空間の参照を簡略化し、global using や static using でさらに記述を効率化できる。
  • リソース管理: IDisposable を実装したオブジェクトを確実に解放する。
  • モダンな進化: C# 8.0以降の using宣言 により、ネストを抑えた綺麗なコードが書けるようになった。

特にリソース管理に関しては、「IDisposableを見かけたらusingを使う」 というルールを徹底するだけで、バグの少ない堅牢なアプリケーションを構築できるようになります。

最新のC#の機能を積極的に取り入れ、よりクリーンでプロフェッショナルなコーディングを目指しましょう。