C#のネームスペースとは？usingとの違い・書き方・使い方を初心者向けに解説

はじめに

C#でプログラムを書いていると、ほとんど必ず登場するのが「ネームスペース」です。C#のネームスペースは、クラスやメソッドなどを整理し、名前の衝突を防ぐための仕組みです。

初心者の方は、namespaceとusingの違いで混乱しやすいかもしれません。

たとえば、C#のコードでは次のような書き方をよく見かけます。

C#
using System;

namespace MyApp
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("Hello, C#!");
        }
    }
}

この中にあるusing System;とnamespace MyAppは、どちらもネームスペースに関係していますが、役割はまったく異なります。

この記事では、C#のネームスペースとは何か、usingとの違い、基本的な書き方、実際の使い方、初心者がつまずきやすいエラーまで、サンプルコードを使ってわかりやすく解説します。

1. C#のネームスペースとは？

C#のネームスペースとは、クラスや構造体、インターフェース、列挙型などを分類・整理するための名前のまとまりです。

プログラムが大きくなると、たくさんのクラスを作ることになります。そのまま何も整理せずにクラスを増やしていくと、どのクラスがどの機能に関係しているのか分かりにくくなります。

そこで使うのがネームスペースです。

ネームスペースを使うことで、関連するクラスをグループ化し、コードを管理しやすくできます。

1-1. ネームスペースの基本的な意味

ネームスペースは、日本語にすると「名前空間」と呼ばれます。

名前空間とは、名前を管理するための範囲のことです。C#では、クラス名やインターフェース名などをネームスペースの中に配置できます。

たとえば、次のように書きます。

C#
namespace SampleApp
{
    class User
    {
    }
}

この場合、UserクラスはSampleAppというネームスペースに所属しています。

つまり、正確にはこのクラスは単なるUserではなく、SampleApp.Userという名前で管理されています。

C#
SampleApp.User

このように、ネームスペースを使うことで「どこに所属しているクラスなのか」を明確にできます。

1-2. クラスやメソッドを整理するための仕組み

C#のネームスペースは、クラスを整理するためによく使われます。

たとえば、会員管理システムを作る場合、次のような機能ごとにクラスを分けることがあります。

C#
namespace MemberSystem.Users
{
    class User
    {
    }
}

namespace MemberSystem.Products
{
    class Product
    {
    }
}

namespace MemberSystem.Orders
{
    class Order
    {
    }
}

このように、ユーザー関連はMemberSystem.Users、商品関連はMemberSystem.Products、注文関連はMemberSystem.Ordersのように分けると、コードの役割がわかりやすくなります。

ネームスペースは、フォルダのようにコードを分類するための仕組みだと考えると理解しやすいです。

ただし、ネームスペースは実際のフォルダそのものではありません。フォルダ構成と合わせることは多いですが、C#の文法上はフォルダ名とネームスペース名が必ず一致している必要はありません。

1-3. ネームスペースが必要になる理由

ネームスペースが必要になる大きな理由は、コードの整理と名前の衝突を防ぐためです。

小さなプログラムでは、クラスが数個しかないため、ネームスペースの必要性を感じにくいかもしれません。

しかし、実際の開発では数十個、数百個のクラスを扱うことがあります。さらに、自分で作ったクラスだけでなく、.NETの標準ライブラリや外部ライブラリも使います。

そのとき、同じ名前のクラスが存在する可能性があります。

たとえば、自分のプロジェクトにFileというクラスを作ったとします。しかし、C#にはSystem.IO.Fileという標準ライブラリのクラスもあります。

このような場合、ネームスペースがないと、どちらのFileを指しているのか分からなくなります。

ネームスペースを使えば、次のように区別できます。

C#
MyApp.File
System.IO.File

このように、ネームスペースはC#のプログラムを安全に整理するために欠かせない仕組みです。

1-4. 同じ名前のクラスを区別できる仕組み

C#では、異なるネームスペースにあるクラスであれば、同じクラス名を使うことができます。

たとえば、次のようにUserという名前のクラスを複数作ることができます。

C#
namespace MyApp.Admin
{
    class User
    {
    }
}

namespace MyApp.Customer
{
    class User
    {
    }
}

この場合、どちらもクラス名はUserですが、完全な名前は異なります。

C#
MyApp.Admin.User
MyApp.Customer.User

管理者用のユーザーはMyApp.Admin.User、顧客用のユーザーはMyApp.Customer.Userとして区別できます。

このように、ネームスペースを使うことで、同じ名前のクラスがあっても衝突を避けることができます。

2. C#のネームスペースとusingの違い

C#初心者が特に混乱しやすいのが、namespaceとusingの違いです。

どちらもネームスペースに関係するキーワードですが、役割は異なります。

簡単に言うと、namespaceはクラスの所属先を決めるものです。一方、usingは他のネームスペースにあるクラスを短く書けるようにするものです。

2-1. namespaceは「所属先」を定義するもの

namespaceは、クラスやインターフェースなどがどの名前空間に所属するかを定義します。

たとえば、次のコードを見てください。

C#
namespace MyApp.Models
{
    class User
    {
        public string Name { get; set; }
    }
}

このUserクラスは、MyApp.Modelsというネームスペースに所属しています。

そのため、別の場所から正確に指定する場合は、次のように書きます。

C#
MyApp.Models.User

つまり、namespaceはクラスの住所のようなものです。

クラスがどこにあるのか、どのグループに属しているのかを示すために使います。

2-2. usingは「参照を省略する」ためのもの

usingは、ネームスペース名を毎回書かなくてもよいようにするためのキーワードです。

たとえば、C#で文字を画面に表示する場合、よく次のように書きます。

C#
Console.WriteLine("Hello");

このConsoleクラスは、実際にはSystemネームスペースにあります。

正確には次のように書くこともできます。

C#
System.Console.WriteLine("Hello");

しかし、毎回System.Consoleと書くのは少し面倒です。

そこで、ファイルの先頭に次のように書きます。

C#
using System;

これにより、System.Consoleを単にConsoleと書けるようになります。

C#
using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello");
    }
}

つまり、usingはクラスの所属先を変えるものではありません。あくまで、長いネームスペース名を省略して書けるようにするためのものです。

2-3. namespaceとusingの関係をコードで理解する

namespaceとusingの関係を、簡単なコードで確認してみましょう。

まず、次のようなUserクラスがあるとします。

C#
namespace MyApp.Models
{
    public class User
    {
        public string Name { get; set; }
    }
}

このクラスを別のファイルから使う場合、usingを書けば短く呼び出せます。

C#
using MyApp.Models;

namespace MyApp
{
    class Program
    {
        static void Main()
        {
            User user = new User();
            user.Name = "田中";
        }
    }
}

ここでは、using MyApp.Models;を書いているため、MyApp.Models.Userを単にUserと書けます。

一方、usingを書かない場合は、次のように完全修飾名で書く必要があります。

C#
namespace MyApp
{
    class Program
    {
        static void Main()
        {
            MyApp.Models.User user = new MyApp.Models.User();
            user.Name = "田中";
        }
    }
}

このように、namespaceはクラスの所属先、usingはその所属先を省略して書くための宣言です。

2-4. usingを書かない場合の書き方

usingを書かなくても、C#のクラスを使うことはできます。

その場合は、完全修飾名を使います。

完全修飾名とは、ネームスペース名を含めた正式な名前のことです。

たとえば、Consoleクラスをusing System;なしで使う場合は、次のように書きます。

C#
class Program
{
    static void Main()
    {
        System.Console.WriteLine("Hello");
    }
}

List<T>をusing System.Collections.Generic;なしで使う場合は、次のように書きます。

C#
class Program
{
    static void Main()
    {
        System.Collections.Generic.List<string> names =
            new System.Collections.Generic.List<string>();

        names.Add("田中");
    }
}

このように完全修飾名を使えばusingは不要です。

ただし、コードが長くなって読みづらくなるため、通常は必要なネームスペースをusingで読み込んで使います。

3. C#のネームスペースの基本的な書き方

C#のネームスペースには、主に2つの書き方があります。

1つ目は、従来から使われているブロック構文です。2つ目は、C# 10以降で使えるファイルスコープnamespaceです。

どちらもネームスペースを定義するための書き方ですが、コードの見た目が少し異なります。

3-1. 従来のnamespaceブロック構文

従来のネームスペースの書き方は、波かっこ{ }で囲むブロック構文です。

C#
namespace MyApp.Models
{
    public class User
    {
        public string Name { get; set; }
    }
}

この書き方では、namespace MyApp.Modelsの中にUserクラスを書いています。

ブロックの中に書かれたクラスは、すべてそのネームスペースに所属します。

複数のクラスを書くこともできます。

C#
namespace MyApp.Models
{
    public class User
    {
    }

    public class Product
    {
    }
}

この場合、UserクラスもProductクラスもMyApp.Modelsネームスペースに所属します。

従来の書き方は、多くのC#プロジェクトで使われている基本的な構文です。

3-2. C# 10以降のファイルスコープnamespace

C# 10以降では、ファイルスコープnamespaceという書き方が使えます。

C#
namespace MyApp.Models;

public class User
{
    public string Name { get; set; }
}

この書き方では、namespace MyApp.Models;のようにセミコロンで終わります。

このファイル内に書かれたクラスは、すべてMyApp.Modelsネームスペースに所属します。

従来のブロック構文と比べると、波かっこが不要になるため、インデントが少なくなり、コードがすっきりします。

従来の書き方は次のようになります。

C#
namespace MyApp.Models
{
    public class User
    {
    }
}

ファイルスコープnamespaceでは次のように書けます。

C#
namespace MyApp.Models;

public class User
{
}

1つのファイルに1つのネームスペースだけを書く場合は、ファイルスコープnamespaceを使うと読みやすくなります。

3-3. 複数階層のネームスペースの書き方

C#のネームスペースは、ドット.を使って階層的に表現できます。

C#
namespace MyCompany.MyProduct.Users
{
    public class UserService
    {
    }
}

この場合、UserServiceクラスはMyCompany.MyProduct.Usersネームスペースに所属します。

階層名には、会社名、製品名、機能名などを使うことが多いです。

C#
namespace ExampleCompany.SalesApp.Models
{
    public class Customer
    {
    }
}

namespace ExampleCompany.SalesApp.Services
{
    public class CustomerService
    {
    }
}

このように分けると、どの会社の、どの製品の、どの機能に関係するクラスなのかが分かりやすくなります。

ただし、階層を深くしすぎるとコードが長くなるため注意が必要です。

C#
namespace Company.Product.Module.Feature.SubFeature.Models
{
    public class User
    {
    }
}

このように深すぎるネームスペースは、かえって読みにくくなります。必要な範囲でシンプルに設計することが大切です。

3-4. 1つのファイルに複数のネームスペースを書く場合

C#では、1つのファイルに複数のネームスペースを書くこともできます。

C#
namespace MyApp.Models
{
    public class User
    {
    }
}

namespace MyApp.Services
{
    public class UserService
    {
    }
}

この場合、UserクラスはMyApp.Modelsに所属し、UserServiceクラスはMyApp.Servicesに所属します。

ただし、実際の開発では、1つのファイルに複数のネームスペースを書くことはあまり多くありません。

一般的には、1ファイルに1クラス、または関連するクラスをまとめる形にした方が管理しやすいです。

また、ファイルスコープnamespaceを使う場合、1つのファイルに複数のファイルスコープnamespaceを書くことはできません。

C#
namespace MyApp.Models;

public class User
{
}

// このように同じファイル内で別のファイルスコープnamespaceを書くことはできません
namespace MyApp.Services;

public class UserService
{
}

複数のネームスペースを1つのファイルに書きたい場合は、従来のブロック構文を使います。

4. C#のネームスペースの使い方をサンプルコードで解説

ここからは、C#のネームスペースの使い方を具体的なサンプルコードで確認していきます。

自作クラスにネームスペースを付ける方法、別ファイルのクラスをusingで呼び出す方法、完全修飾名で呼び出す方法、同名クラスを使い分ける方法を順番に見ていきましょう。

4-1. 自作クラスにネームスペースを付ける例

まずは、自作クラスにネームスペースを付ける基本例です。

C#
namespace SampleApp.Models
{
    public class User
    {
        public string Name { get; set; }

        public void ShowName()
        {
            Console.WriteLine(Name);
        }
    }
}

このコードでは、UserクラスをSampleApp.Modelsネームスペースに所属させています。

ただし、このままだとConsoleを使うためにSystemネームスペースが必要です。

そのため、通常は次のようにusing System;を追加します。

C#
using System;

namespace SampleApp.Models
{
    public class User
    {
        public string Name { get; set; }

        public void ShowName()
        {
            Console.WriteLine(Name);
        }
    }
}

このように、自分で作ったクラスにもネームスペースを付けることで、どの機能に関係するクラスなのかを整理できます。

4-2. 別ファイルのクラスをusingで呼び出す例

次に、別ファイルにあるクラスをusingで呼び出す例を見てみましょう。

まず、User.csというファイルに次のクラスを作ります。

C#
namespace SampleApp.Models
{
    public class User
    {
        public string Name { get; set; }
    }
}

次に、Program.csでこのUserクラスを使います。

C#
using System;
using SampleApp.Models;

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            User user = new User();
            user.Name = "佐藤";

            Console.WriteLine(user.Name);
        }
    }
}

using SampleApp.Models;を書いているため、UserクラスをそのままUserと書けます。

もしusing SampleApp.Models;を書かなければ、Userという名前だけではクラスを見つけられない場合があります。

このように、別ファイルのクラスを使うときは、そのクラスが所属しているネームスペースをusingで指定します。

4-3. 完全修飾名でクラスを呼び出す例

usingを使わずに、完全修飾名でクラスを呼び出すこともできます。

C#
using System;

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            SampleApp.Models.User user = new SampleApp.Models.User();
            user.Name = "鈴木";

            Console.WriteLine(user.Name);
        }
    }
}

このコードでは、UserではなくSampleApp.Models.Userと書いています。

これが完全修飾名です。

完全修飾名を使うと、どのネームスペースにあるクラスなのかを明確に指定できます。

ただし、毎回完全修飾名を書くとコードが長くなります。

そのため、通常はusingを使い、同名クラスがあって区別が必要な場合などに完全修飾名を使うとよいでしょう。

4-4. 同名クラスがある場合の使い分け例

C#では、異なるネームスペースに同じ名前のクラスを作ることができます。

次の例では、Admin.UserとCustomer.Userという2つのUserクラスを作ります。

C#
namespace SampleApp.Admin
{
    public class User
    {
        public string Role { get; set; } = "管理者";
    }
}

C#
namespace SampleApp.Customer
{
    public class User
    {
        public string Rank { get; set; } = "一般会員";
    }
}

この2つのクラスを同じファイルで使う場合、単にUserと書くと、どちらのUserなのか分からなくなることがあります。

その場合は、完全修飾名で指定します。

C#
using System;

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            SampleApp.Admin.User adminUser = new SampleApp.Admin.User();
            SampleApp.Customer.User customerUser = new SampleApp.Customer.User();

            Console.WriteLine(adminUser.Role);
            Console.WriteLine(customerUser.Rank);
        }
    }
}

また、usingのエイリアスを使って名前を付けることもできます。

C#
using System;
using AdminUser = SampleApp.Admin.User;
using CustomerUser = SampleApp.Customer.User;

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            AdminUser adminUser = new AdminUser();
            CustomerUser customerUser = new CustomerUser();

            Console.WriteLine(adminUser.Role);
            Console.WriteLine(customerUser.Rank);
        }
    }
}

このように、同名クラスがある場合は、完全修飾名やusingエイリアスを使って区別できます。

5. よく使うC#標準ライブラリのネームスペース

C#では、自分で作るネームスペースだけでなく、.NETに用意されている標準ライブラリのネームスペースをよく使います。

代表的なものに、System、System.Collections.Generic、System.Linqなどがあります。

これらを理解しておくと、C#のコードを読むときにも役立ちます。

5-1. Systemとは何か

Systemは、C#で非常によく使う基本的なネームスペースです。

たとえば、次のようなクラスがSystemネームスペースに含まれています。

C#
Console
String
DateTime
Math
Random

画面に文字を表示するConsoleクラスもSystemに含まれています。

C#
using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("こんにちは");
    }
}

using System;を書かない場合は、次のように書きます。

C#
class Program
{
    static void Main()
    {
        System.Console.WriteLine("こんにちは");
    }
}

Systemは、C#で基本的な処理を行うためによく使うネームスペースです。

5-2. System.Collections.Genericの使い方

System.Collections.Genericは、ジェネリックコレクションを使うときによく利用するネームスペースです。

代表的なクラスにList<T>やDictionary<TKey, TValue>があります。

List<T>は、複数の値をまとめて管理できる便利なクラスです。

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

class Program
{
    static void Main()
    {
        List<string> names = new List<string>();

        names.Add("田中");
        names.Add("佐藤");
        names.Add("鈴木");

        foreach (string name in names)
        {
            Console.WriteLine(name);
        }
    }
}

Dictionary<TKey, TValue>は、キーと値のペアを管理するためのクラスです。

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

class Program
{
    static void Main()
    {
        Dictionary<string, int> scores = new Dictionary<string, int>();

        scores["田中"] = 80;
        scores["佐藤"] = 90;

        Console.WriteLine(scores["田中"]);
    }
}

リストや辞書を使うときは、System.Collections.Genericを覚えておくとよいでしょう。

5-3. System.Linqの使い方

System.Linqは、配列やリストなどのデータを簡単に検索・並べ替え・集計するためによく使われるネームスペースです。

たとえば、リストの中から条件に合うデータだけを取り出すことができます。

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 };

        var evenNumbers = numbers.Where(n => n % 2 == 0);

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

このコードでは、Whereメソッドを使って偶数だけを取り出しています。

WhereやSelect、OrderBy、FirstOrDefaultなどのLINQメソッドを使うには、using System.Linq;が必要になることがあります。

C#
using System.Linq;

LINQを使うと、データ操作のコードを短く読みやすく書けます。

5-4. Visual Studioや.NETプロジェクトで自動追加されるusing

最近の.NETプロジェクトでは、よく使うusingが自動的に有効になる場合があります。

たとえば、コンソールアプリを作成したときに、ファイルの先頭にusing System;を書いていなくてもConsole.WriteLineが使えることがあります。

これは、プロジェクトの設定で暗黙的なusingが有効になっているためです。

.csprojファイルに次のような設定がある場合、よく使うネームスペースが自動的に読み込まれます。

XML
<ImplicitUsings>enable</ImplicitUsings>

この設定が有効になっていると、SystemやSystem.Collections.Genericなど、よく使うネームスペースが自動で利用できるようになります。

ただし、自分で作ったネームスペースや外部ライブラリのネームスペースは、必要に応じてusingを書く必要があります。

また、Visual Studioでは、未使用のusingを薄く表示したり、必要なusingを自動追加する機能もあります。

初心者のうちは、なぜusingを書いていないのに使えるのか分からなくなることがあります。その場合は、プロジェクト設定のImplicitUsingsを確認するとよいでしょう。

6. C#のネームスペース設計のルールとベストプラクティス

ネームスペースは自由に名前を付けられますが、何でもよいわけではありません。

わかりやすく、管理しやすいネームスペースにすることが大切です。

ここでは、C#のネームスペース設計で意識したいルールとベストプラクティスを解説します。

6-1. プロジェクト名やフォルダ構成と合わせる

C#では、ネームスペース名をプロジェクト名やフォルダ構成と合わせることがよくあります。

たとえば、次のようなフォルダ構成があるとします。

SampleApp
 ├─ Models
 │   └─ User.cs
 ├─ Services
 │   └─ UserService.cs
 └─ Controllers
     └─ UserController.cs

この場合、ネームスペースは次のようにすると分かりやすくなります。

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

C#
namespace SampleApp.Services
{
    public class UserService
    {
    }
}

C#
namespace SampleApp.Controllers
{
    public class UserController
    {
    }
}

フォルダ名とネームスペースを合わせると、コードを探しやすくなります。

ただし、C#の文法上、フォルダ名とネームスペース名が必ず一致している必要はありません。あくまで、保守性を高めるための設計上のルールです。

6-2. わかりやすい命名規則にする

ネームスペース名は、何を表しているのか分かりやすい名前にすることが重要です。

一般的には、次のようにパスカルケースで書きます。

C#
namespace SampleApp.UserManagement
{
}

パスカルケースとは、単語の先頭を大文字にする命名規則です。

よい例は次のような名前です。

C#
SampleApp.Models
SampleApp.Services
SampleApp.Repositories
SampleApp.UserManagement
SampleApp.OrderManagement

一方、意味があいまいな名前は避けた方がよいです。

C#
SampleApp.Common
SampleApp.Utils
SampleApp.Other

CommonやUtilsが悪いわけではありませんが、何でも入れてしまうと中身が分かりにくくなります。

ネームスペース名は、「どの機能に関係するコードなのか」が分かる名前にするとよいでしょう。

6-3. ネームスペースを細かく分けすぎない

ネームスペースは便利ですが、細かく分けすぎると逆に管理が難しくなります。

たとえば、次のように細かすぎるネームスペースは読みにくくなることがあります。

C#
namespace SampleApp.Users.Create.Input.Validation.Rules
{
    public class UserNameRule
    {
    }
}

ネームスペースが深くなりすぎると、完全修飾名も長くなります。

C#
SampleApp.Users.Create.Input.Validation.Rules.UserNameRule

これでは、コードを読むたびに負担が増えます。

機能ごとに分けることは大切ですが、必要以上に細かくしないようにしましょう。

たとえば、次のようにまとめる方が扱いやすい場合があります。

C#
namespace SampleApp.Users
{
    public class UserService
    {
    }

    public class UserValidator
    {
    }
}

または、役割ごとに分けるなら次のようにします。

C#
namespace SampleApp.Users.Services
{
    public class UserService
    {
    }
}

namespace SampleApp.Users.Validation
{
    public class UserValidator
    {
    }
}

ネームスペースは、コードの見通しをよくするために使うものです。分けすぎて見通しが悪くならないように注意しましょう。

6-4. 会社名・製品名・機能名を使った設計例

大きなアプリケーションやライブラリを作る場合、会社名、製品名、機能名を組み合わせてネームスペースを設計することがあります。

たとえば、会社名がExampleCompany、製品名がInventoryAppの場合、次のようなネームスペースにできます。

C#
namespace ExampleCompany.InventoryApp.Products
{
    public class Product
    {
    }
}

C#
namespace ExampleCompany.InventoryApp.Orders
{
    public class Order
    {
    }
}

C#
namespace ExampleCompany.InventoryApp.Reports
{
    public class SalesReport
    {
    }
}

このようにすると、他の会社や別製品のコードと名前が衝突しにくくなります。

ライブラリを公開する場合も、会社名や組織名を先頭に付けておくと、他のライブラリとの衝突を避けやすくなります。

C#
namespace ExampleCompany.Logging
{
    public class Logger
    {
    }
}

C#
namespace ExampleCompany.Logging.Formatters
{
    public class JsonLogFormatter
    {
    }
}

C#のネームスペース設計では、将来的にコードが増えたときにも分かりやすい構成にすることが大切です。

7. C#のネームスペースで初心者がつまずきやすいエラー

C#のネームスペースを学び始めたばかりの頃は、エラーの原因が分からずに悩むことがあります。

特に多いのが、「型または名前空間の名前が見つかりません」というエラーです。

ここでは、初心者がつまずきやすいエラーと確認ポイントを解説します。

7-1. 型または名前空間の名前が見つからない原因

C#でよく見かけるエラーに、次のようなものがあります。

型または名前空間の名前 'User' が見つかりませんでした

英語環境では次のように表示されることがあります。

The type or namespace name 'User' could not be found

このエラーの主な原因は、次のようなものです。

対象のクラスが存在しない、クラス名のスペルが間違っている、必要なusingを書いていない、参照するプロジェクトが追加されていない、クラスのアクセス修飾子がpublicになっていない、などです。

たとえば、次のようなクラスがあるとします。

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

別のファイルで次のように書くと、using SampleApp.Models;がないためエラーになる場合があります。

C#
namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            User user = new User();
        }
    }
}

この場合は、ファイルの先頭にusingを追加します。

C#
using SampleApp.Models;

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            User user = new User();
        }
    }
}

または、完全修飾名で書きます。

C#
namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            SampleApp.Models.User user = new SampleApp.Models.User();
        }
    }
}

7-2. usingを書いても参照できない場合の確認点

usingを書いているのにクラスを参照できない場合は、いくつかの確認ポイントがあります。

まず、ネームスペース名が正しいか確認します。

C#
using SampleApp.Model;

実際のネームスペースがSampleApp.Modelsなのに、SampleApp.Modelと書いていると参照できません。

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

正しくは次のように書きます。

C#
using SampleApp.Models;

次に、クラスがpublicになっているか確認します。

別のプロジェクトや別のアセンブリから使う場合、クラスがpublicでないと参照できません。

C#
namespace SampleApp.Models
{
    class User
    {
    }
}

このようにpublicが付いていない場合、外部から使えないことがあります。

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

また、別プロジェクトのクラスを使う場合は、プロジェクト参照が追加されているかも確認しましょう。

usingは、参照を省略するためのものです。ライブラリやプロジェクトそのものを読み込む機能ではありません。

つまり、参照設定がないプロジェクトのクラスは、usingを書いても使えません。

7-3. ネームスペース名とクラス名が重複した場合

ネームスペース名とクラス名が重複すると、コードが分かりにくくなったり、名前解決で混乱したりすることがあります。

たとえば、次のような構成です。

C#
namespace SampleApp.User
{
    public class User
    {
    }
}

この場合、SampleApp.User.Userという名前になります。

動作自体は可能ですが、読む側にとっては分かりにくくなります。

より分かりやすくするなら、ネームスペース名を複数形や機能名にします。

C#
namespace SampleApp.Users
{
    public class User
    {
    }
}

または、役割を示す名前にします。

C#
namespace SampleApp.UserManagement
{
    public class User
    {
    }
}

ネームスペース名とクラス名が同じだと、コードを読むときに「これはネームスペースなのか、クラスなのか」が分かりにくくなります。

初心者のうちは特に、ネームスペース名とクラス名を完全に同じにしない方が理解しやすいです。

7-4. ファイル名・クラス名・ネームスペース名の関係

C#では、ファイル名、クラス名、ネームスペース名はそれぞれ別のものです。

たとえば、User.csというファイルに、次のようなクラスを書くことができます。

C#
namespace SampleApp.Models
{
    public class Customer
    {
    }
}

この場合、ファイル名はUser.csですが、クラス名はCustomerです。

C#の文法上は、ファイル名とクラス名が必ず一致している必要はありません。

ただし、実際の開発では、ファイル名とクラス名を一致させるのが一般的です。

C#
// User.cs
namespace SampleApp.Models
{
    public class User
    {
    }
}

このようにすると、ファイルを見ただけでどのクラスが定義されているか分かります。

また、フォルダ構成とネームスペースも必ず一致させる必要はありませんが、合わせておくと管理しやすくなります。

Models/User.cs

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

初心者のうちは、ファイル名、クラス名、フォルダ名、ネームスペース名の関係を整理しておくと、エラーの原因を見つけやすくなります。

8. C#のネームスペースに関するよくある質問

ここでは、C#のネームスペースについて初心者が疑問に思いやすいポイントをQ&A形式で解説します。

8-1. namespaceは必ず書く必要がある？

C#では、簡単なプログラムであればnamespaceを書かなくても動作する場合があります。

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

C#
class Program
{
    static void Main()
    {
        System.Console.WriteLine("Hello");
    }
}

このコードにはnamespaceがありませんが、コンパイルできる場合があります。

ただし、実際の開発ではnamespaceを書くのが一般的です。

ネームスペースを書いておくと、クラスを整理しやすくなり、名前の衝突も防ぎやすくなります。

特に、複数のクラスや複数のプロジェクトを扱う場合は、ネームスペースを適切に付けることが重要です。

8-2. usingはどこに書くのが正しい？

通常、usingはファイルの先頭に書きます。

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

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("Hello");
        }
    }
}

C#では、usingをネームスペースの外側に書くことも、内側に書くこともできます。

外側に書く例です。

C#
using System;

namespace SampleApp
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("Hello");
        }
    }
}

内側に書く例です。

C#
namespace SampleApp
{
    using System;

    class Program
    {
        static void Main()
        {
            Console.WriteLine("Hello");
        }
    }
}

一般的には、ファイルの先頭にまとめて書くことが多いです。

C# 10以降のファイルスコープnamespaceを使う場合も、通常はusingを先に書きます。

C#
using System;

namespace SampleApp;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello");
    }
}

8-3. namespaceとフォルダ名は同じにするべき？

C#の文法上、ネームスペース名とフォルダ名を同じにする必要はありません。

しかし、実際の開発では同じにすることが多いです。

たとえば、ModelsフォルダにあるクラスはSampleApp.Models、ServicesフォルダにあるクラスはSampleApp.Servicesにすると分かりやすくなります。

SampleApp
 ├─ Models
 │   └─ User.cs
 └─ Services
     └─ UserService.cs

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

C#
namespace SampleApp.Services
{
    public class UserService
    {
    }
}

フォルダ構成とネームスペースを合わせると、コードを探しやすくなり、チーム開発でも理解しやすくなります。

8-4. global usingとは何か？

global usingは、C# 10以降で使える機能です。

通常のusingは、そのファイルの中だけで有効です。

C#
using System;

一方、global usingを使うと、プロジェクト全体でそのusingを有効にできます。

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

たとえば、GlobalUsings.csというファイルを作り、よく使うネームスペースをまとめて書いておくことがあります。

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

これにより、各ファイルで毎回同じusingを書かなくてもよくなります。

ただし、何でもglobal usingにしてしまうと、どのネームスペースがどこで読み込まれているのか分かりにくくなることがあります。

よく使う基本的なネームスペースだけをglobal usingにするのがおすすめです。

8-5. Javaのpackageとの違いは？

C#のnamespaceは、Javaのpackageと似ています。

どちらも、クラスを分類し、名前の衝突を防ぐための仕組みです。

Javaでは、ファイルの先頭に次のように書きます。

Java
package com.example.app;

C#では、次のように書きます。

C#
namespace ExampleApp
{
    public class User
    {
    }
}

大きな違いのひとつは、Javaではパッケージ名とフォルダ構成の対応がより強く意識される点です。

C#でもフォルダ構成とネームスペースを合わせることは多いですが、文法上は必須ではありません。

また、Javaでは他のパッケージのクラスを使うときにimportを使います。

Java
import java.util.List;

C#では、同じような役割としてusingを使います。

C#
using System.Collections.Generic;

つまり、JavaのpackageはC#のnamespaceに近く、JavaのimportはC#のusingに近いものだと考えると分かりやすいです。

まとめ

C#のネームスペースは、クラスやインターフェースなどを整理し、名前の衝突を防ぐための仕組みです。

namespaceは、クラスの所属先を定義するために使います。一方、usingは、別のネームスペースにあるクラスを短く書くために使います。

たとえば、namespace SampleApp.ModelsにあるUserクラスは、完全修飾名ではSampleApp.Models.Userと表せます。using SampleApp.Models;を書けば、コード内で単にUserと書けるようになります。

C#のネームスペースには、従来のブロック構文と、C# 10以降で使えるファイルスコープnamespaceがあります。

C#
namespace SampleApp.Models
{
    public class User
    {
    }
}

C#
namespace SampleApp.Models;

public class User
{
}

また、C#ではSystem、System.Collections.Generic、System.Linqなどの標準ライブラリのネームスペースをよく使います。

ネームスペースを設計するときは、プロジェクト名やフォルダ構成に合わせ、わかりやすい名前を付けることが大切です。ただし、細かく分けすぎると逆に読みにくくなるため、機能ごとに適切な粒度で整理しましょう。

初心者がつまずきやすい「型または名前空間の名前が見つかりません」というエラーは、usingの不足、ネームスペース名の間違い、参照設定の不足、クラスのアクセス修飾子などが原因で起こります。

C#のネームスペースを理解すると、コードの構成が分かりやすくなり、複数ファイルや複数プロジェクトを扱う開発でも迷いにくくなります。まずは、namespaceは所属先、usingは省略のための宣言、という違いをしっかり押さえておきましょう。