C# constとは？使い方・readonlyとの違い・エラー回避を初心者向けに解説

はじめに

C#でプログラムを書いていると、constというキーワードを見かけることがあります。

constは、一度決めたら変更できない値を定義するときに使うキーワードです。たとえば、円周率、固定メッセージ、最大件数、エラーコードなど、プログラム内で何度も使う固定値をわかりやすい名前で管理できます。

C#
const double Pi = 3.14;
const string AppName = "SampleApp";

初心者のうちは、constと通常の変数の違いや、readonlyとの使い分けで迷いやすいです。また、DateTimeや配列をconstにしようとしてエラーになることもよくあります。

この記事では、C#のconstについて、基本的な使い方、使える型、readonlyとの違い、よくあるエラーと回避方法まで初心者向けにわかりやすく解説します。

1. C# constとは？初心者向けに意味をわかりやすく解説

1-1. constは「変更できない定数」を定義するキーワード

C#のconstは、定数を定義するためのキーワードです。

定数とは、プログラムの実行中に値が変わらないものです。たとえば、次のような値は定数として扱いやすいです。

C#
const int MaxRetryCount = 3;
const string ErrorMessage = "エラーが発生しました";

このように書くと、MaxRetryCountには常に3、ErrorMessageには常に"エラーが発生しました"が入ります。

constで定義した値は、後から別の値に変更できません。

C#
const int MaxCount = 10;

// エラーになる
MaxCount = 20;

constは「この値は変えない」という意図をコード上で明確に表すために使います。

1-2. 変数との違い：後から値を代入・変更できない

通常の変数は、後から値を変更できます。

C#
int count = 10;
count = 20;

このコードは問題なく動きます。countは変数なので、最初に10を代入したあとで20に変更できます。

一方、constで定義した値は変更できません。

C#
const int count = 10;

// コンパイルエラー
count = 20;

constは最初に値を決めた時点で固定されます。プログラムの途中で別の値を入れることはできません。

つまり、通常の変数は「変わる可能性がある値」、constは「絶対に変えない値」に使います。

1-3. constを使うメリット：コードの可読性とミス防止

constを使う大きなメリットは、コードの意味がわかりやすくなることです。

たとえば、次のコードを見てみましょう。

C#
if (score >= 80)
{
    Console.WriteLine("合格です");
}

この80が何を意味しているのかは、コードだけでは少しわかりにくいです。このような直接書かれた数値は、一般的にマジックナンバーと呼ばれます。

constを使うと、意味のある名前を付けられます。

C#
const int PassingScore = 80;

if (score >= PassingScore)
{
    Console.WriteLine("合格です");
}

このコードでは、80が「合格点」であることがすぐにわかります。

また、同じ値を複数箇所に書く必要がなくなるため、修正漏れや入力ミスを防ぎやすくなります。

C#
const int MaxLoginAttempts = 5;

このように定義しておけば、ログイン試行回数の上限をコード全体で統一できます。

1-4. constがよく使われる場面

constは、値が固定されていて将来も変わりにくいものに使います。

代表的な例は次のようなものです。

C#
const double Pi = 3.14159;
const int DaysInWeek = 7;
const string DefaultMessage = "処理が完了しました";
const int MaxRetryCount = 3;

円周率、1週間の日数、固定メッセージ、リトライ回数の上限などは、constで定義しやすい値です。

ただし、消費税率や外部APIのURLなど、将来変更される可能性がある値には注意が必要です。これらは一見固定値に見えますが、実際には仕様変更や環境変更によって変わることがあります。

2. C# constの基本的な使い方

2-1. constの基本構文

C#でconstを使う基本構文は次のとおりです。

C#
const 型名 定数名 = 値;

たとえば、整数の定数を定義する場合は次のように書きます。

C#
const int MaxCount = 100;

文字列の場合は次のように書きます。

C#
const string AppName = "MyApplication";

constでは、定義時に必ず値を代入する必要があります。

C#
// エラーになる
const int MaxCount;

constは、後から値を設定できないため、宣言と同時に値を決めなければいけません。

2-2. 数値をconstで定義する例

数値をconstで定義する例を見てみましょう。

C#
const int MaxUserCount = 100;
const double TaxRate = 0.10;
const decimal Price = 1200m;

intは整数、doubleは小数、decimalは金額計算などでよく使われる数値型です。

実際のコードでは、次のように使えます。

C#
const int MaxRetryCount = 3;

for (int i = 0; i < MaxRetryCount; i++)
{
    Console.WriteLine("再試行します");
}

3を直接書くよりも、MaxRetryCountという名前を付けることで、何を表す値なのかがわかりやすくなります。

2-3. 文字列をconstで定義する例

文字列もconstで定義できます。

C#
const string WelcomeMessage = "ようこそ";
const string ErrorMessage = "エラーが発生しました";

使用例は次のとおりです。

C#
const string ServiceName = "会員管理システム";

Console.WriteLine(ServiceName);

固定のメッセージ、アプリケーション名、ログの接頭辞などは、const stringとして定義されることがよくあります。

C#
const string LogPrefix = "[INFO]";

Console.WriteLine($"{LogPrefix} 処理を開始しました");

ただし、ユーザー設定や環境によって変わる文字列はconstにしないほうがよいです。たとえば、接続文字列やAPI URLなどは、設定ファイルから読み込むほうが適しています。

2-4. クラス内でconstを定義する例

constはメソッド内だけでなく、クラス内にも定義できます。

C#
class UserSettings
{
    public const int MaxNameLength = 20;
    public const int MinPasswordLength = 8;
}

クラス内に定義したconstは、次のようにクラス名から参照できます。

C#
Console.WriteLine(UserSettings.MaxNameLength);

constは暗黙的に静的なメンバーとして扱われるため、インスタンスを作らずにアクセスできます。

C#
class Program
{
    public const string AppName = "SampleApp";

    static void Main()
    {
        Console.WriteLine(Program.AppName);
    }
}

ただし、constにstaticを付けることはできません。

C#
// エラーになる
public static const int MaxCount = 10;

constはもともと静的な性質を持っているため、staticを付ける必要はありません。

2-5. constの命名規則と書き方のポイント

C#では、constの名前は一般的にPascalCaseで書かれることが多いです。

C#
const int MaxRetryCount = 3;
const string DefaultUserName = "Guest";

PascalCaseとは、単語の先頭を大文字にする書き方です。

C#
MaxRetryCount
DefaultMessage
ApplicationName

他の言語ではMAX_RETRY_COUNTのようにすべて大文字で書くこともありますが、C#では定数であってもPascalCaseがよく使われます。

また、名前は値そのものではなく、意味が伝わるものにしましょう。

C#
// あまりよくない
const int Number = 10;

// わかりやすい
const int MaxItemCount = 10;

constを使う目的は、固定値に意味のある名前を付けることです。名前を見ただけで用途がわかるようにすると、コードの読みやすさが大きく向上します。

3. constで使える型・使えない型

3-1. constで使える主な型

C#のconstで使える型には制限があります。

主に次のような型が使えます。

C#
const int Count = 10;
const double Rate = 0.5;
const bool IsEnabled = true;
const char Grade = 'A';
const string Message = "Hello";
const decimal Price = 1000m;

また、enumもconstとして扱える場面があります。

C#
enum Status
{
    Active,
    Inactive
}

const Status DefaultStatus = Status.Active;

一方で、DateTime、配列、リスト、独自クラスのインスタンスなどは、通常constにできません。

C#
// エラーになる
const DateTime Today = DateTime.Now;

// エラーになる
const int[] Numbers = new int[] { 1, 2, 3 };

この違いを理解するには、constが「コンパイル時に決まる値」であることを知る必要があります。

3-2. int・double・bool・stringの使用例

よく使う型のconst例を見てみましょう。

C#
const int MaxCount = 100;
const double DiscountRate = 0.2;
const bool IsDebugMode = false;
const string SystemName = "在庫管理システム";

これらはすべてコンパイル時に値が確定しています。

実際の使用例です。

C#
const int PassingScore = 70;
int score = 85;

if (score >= PassingScore)
{
    Console.WriteLine("合格です");
}

boolの定数も使えます。

C#
const bool EnableLog = true;

if (EnableLog)
{
    Console.WriteLine("ログを出力します");
}

文字列もconstにできます。

C#
const string SuccessMessage = "処理に成功しました";

Console.WriteLine(SuccessMessage);

これらの値は、プログラムをコンパイルする時点で確定しているため、constとして定義できます。

3-3. DateTimeや配列をconstにできない理由

DateTimeや配列は、constにできません。

たとえば、次のコードはエラーになります。

C#
// エラー
const DateTime StartDate = new DateTime(2026, 1, 1);

DateTimeは構造体ですが、new DateTime(...)のようにインスタンスを作る必要があります。constではnewを使って値を作ることができません。

配列も同じです。

C#
// エラー
const int[] Scores = new int[] { 80, 90, 100 };

配列は参照型であり、newでオブジェクトを作成します。constはコンパイル時に完全に決まる単純な値に使うものなので、配列やオブジェクトの生成には使えません。

このような場合は、readonlyまたはstatic readonlyを使います。

C#
static readonly DateTime StartDate = new DateTime(2026, 1, 1);

static readonly int[] Scores = new int[] { 80, 90, 100 };

ただし、配列をreadonlyにしても、配列の中身までは完全に変更不可になるわけではありません。

C#
static readonly int[] Scores = { 80, 90, 100 };

// 配列の中身は変更できる
Scores[0] = 70;

配列の内容まで変更されたくない場合は、読み取り専用のコレクションなどを検討します。

3-4. nullをconstにできるケース

constでは、参照型に対してnullを指定できるケースがあります。

C#
const string DefaultName = null;

stringはconstでよく使われる型なので、nullも指定できます。

また、参照型にnullを指定することもできます。

C#
const object EmptyValue = null;

ただし、次のようにオブジェクトを生成することはできません。

C#
// エラー
const object Value = new object();

constで使える参照型の値は、基本的にnullに限られます。stringだけは特別に文字列リテラルを定数として扱えます。

C#
const string Message = "Hello";

3-5. コンパイル時定数とは何か

constを理解するうえで重要なのが、コンパイル時定数です。

コンパイル時定数とは、プログラムを実行する前、つまりコンパイルする時点で値が完全に決まっているものです。

C#
const int A = 10;
const int B = 20;
const int Total = A + B;

この場合、Totalは30になることがコンパイル時にわかります。そのため、constとして定義できます。

一方で、次のような値は実行時にならないと決まりません。

C#
DateTime now = DateTime.Now;

DateTime.Nowはプログラムを実行した瞬間の日時を返します。コンパイル時には値が決まらないため、constにはできません。

C#
// エラー
const DateTime Now = DateTime.Now;

また、メソッドの戻り値も基本的にconstにはできません。

C#
int GetValue()
{
    return 10;
}

// エラー
const int Value = GetValue();

constには、コンパイル時に確定できるリテラルや定数式だけを指定できます。

4. C# constとreadonlyの違い

4-1. constとreadonlyの最大の違い

constとreadonlyは、どちらも「変更できない値」を扱うために使います。

しかし、最大の違いは値が決まるタイミングです。

constは、コンパイル時に値が決まります。

C#
const int MaxCount = 10;

readonlyは、実行時に値を決めることができます。

C#
readonly int maxCount;

public Sample(int count)
{
    maxCount = count;
}

constは宣言時に必ず値を指定する必要がありますが、readonlyはコンストラクタで値を代入できます。

つまり、constは「完全に固定された値」、readonlyは「初期化後は変更しない値」に向いています。

4-2. constはコンパイル時に値が決まる

constの値はコンパイル時に決定されます。

C#
const int TaxRatePercent = 10;

この値は、プログラムの実行中に変わることはありません。また、constはコンパイル時に値がコードへ埋め込まれるように扱われます。

たとえば、次のようなコードがあるとします。

C#
public const int MaxCount = 100;

別の場所で次のように使うと、

C#
Console.WriteLine(MaxCount);

実際には100という値が直接使われるようなイメージです。

そのため、constは高速でシンプルですが、後から値を変更する可能性があるものには向いていません。

4-3. readonlyは実行時やコンストラクタで値を決められる

readonlyは、フィールドの値を初期化時またはコンストラクタ内で決められます。

C#
class User
{
    private readonly string name;

    public User(string userName)
    {
        name = userName;
    }

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

この例では、nameの値はUserオブジェクトを作るときに決まります。

C#
User user = new User("田中");

readonlyはコンストラクタ内で代入した後は変更できません。

C#
class Sample
{
    private readonly int value;

    public Sample()
    {
        value = 10;
    }

    public void Change()
    {
        // エラー
        value = 20;
    }
}

このように、readonlyは「オブジェクトを作るときに値を決めたいが、その後は変更したくない」という場合に便利です。

4-4. static readonlyとの違い

static readonlyは、クラス全体で共有する読み取り専用フィールドです。

C#
class AppSettings
{
    public static readonly DateTime StartDate = new DateTime(2026, 1, 1);
}

static readonlyは、constでは扱えないDateTimeやオブジェクトにも使えます。

C#
class Settings
{
    public static readonly string[] SupportedLanguages =
    {
        "ja",
        "en",
        "fr"
    };
}

constとの大きな違いは、static readonlyの値は実行時に初期化されることです。

C#
public static readonly DateTime CreatedAt = DateTime.Now;

このように、実行時に決まる値にも使えます。

ただし、readonlyはフィールドそのものへの再代入を防ぐものです。参照型の場合、オブジェクトの内部状態まで完全に不変にするわけではありません。

C#
public static readonly List<string> Names = new List<string>();

// Listの中身は変更できる
Names.Add("田中");

中身も変更されたくない場合は、変更できない設計にする必要があります。

4-5. const・readonly・static readonlyの使い分け早見表

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

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

C#
// コンパイル時に決まる固定値
const int MaxRetryCount = 3;

// オブジェクトごとに決まる値
readonly string userName;

// クラス全体で共有し、実行時に決めたい値
static readonly DateTime StartedAt = DateTime.Now;

constにできるなら何でもconstにするのではなく、「本当に将来も変わらないか」「外部に公開して問題ないか」を考えることが大切です。

5. constでよくあるエラーと回避方法

5-1. 「定数値が必要です」エラーの原因

constでよく見るエラーのひとつが、「定数値が必要です」という内容のエラーです。

これは、constに指定した値がコンパイル時に決められない場合に発生します。

C#
int defaultCount = 10;

// エラー
const int MaxCount = defaultCount;

defaultCountには10が入っていますが、変数である以上、constの初期値としては使えません。

正しくは、直接リテラルを指定します。

C#
const int MaxCount = 10;

または、定数から定数を作ります。

C#
const int BaseCount = 10;
const int MaxCount = BaseCount * 2;

constには、コンパイル時に確定できる値だけを指定できると覚えておきましょう。

5-2. constにDateTimeやnewを指定できない理由

次のようなコードはエラーになります。

C#
// エラー
const DateTime StartDate = new DateTime(2026, 1, 1);

new DateTime(...)はオブジェクトを作る処理です。constでは、newを使った初期化はできません。

この場合は、static readonlyを使います。

C#
static readonly DateTime StartDate = new DateTime(2026, 1, 1);

DateTime.Nowもconstにはできません。

C#
// エラー
const DateTime Now = DateTime.Now;

実行した時点の日時は、コンパイル時には決まらないためです。

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

C#
static readonly DateTime StartedAt = DateTime.Now;

newが必要な値、実行時に決まる値は、constではなくreadonlyやstatic readonlyを使いましょう。

5-3. constに変数の値を代入できない理由

次のコードもエラーになります。

C#
int baseValue = 100;

// エラー
const int MaxValue = baseValue;

baseValueは変数です。たとえ値が100で固定されているように見えても、C#ではconstの初期値として使えません。

constに代入できるのは、リテラルや他の定数など、コンパイル時に完全に確定する値です。

C#
const int BaseValue = 100;
const int MaxValue = BaseValue;

また、次のような計算は可能です。

C#
const int Width = 10;
const int Height = 20;
const int Area = Width * Height;

これはWidthもHeightもconstであり、コンパイル時に計算できるためです。

5-4. public constの変更が反映されない問題

public constをライブラリで公開している場合、値を変更しても利用側に反映されないことがあります。

たとえば、ライブラリ側に次の定数があるとします。

C#
public const int MaxCount = 10;

別のプロジェクトでこの値を使っている場合、コンパイル時に10という値が利用側のコードに埋め込まれることがあります。

その後、ライブラリ側で次のように変更したとします。

C#
public const int MaxCount = 20;

ライブラリだけを更新しても、利用側のプロジェクトを再コンパイルしないと、古い値10が使われ続ける可能性があります。

この問題を避けたい場合は、外部公開する値にはpublic constではなく、public static readonlyを使うことを検討します。

C#
public static readonly int MaxCount = 20;

将来変更される可能性がある値や、外部プロジェクトから参照される値には注意が必要です。

5-5. エラーを避けるための実践的な書き方

constのエラーを避けるには、次のように考えるとわかりやすいです。

まず、値が完全に固定で、コンパイル時に決まるならconstを使います。

C#
const int DaysInWeek = 7;
const string DefaultMessage = "こんにちは";

次に、実行時に決まる値ならreadonlyまたはstatic readonlyを使います。

C#
readonly string userName;

static readonly DateTime StartedAt = DateTime.Now;

newが必要な値もconstではなくreadonly系を使います。

C#
static readonly Guid AppId = Guid.NewGuid();

設定ファイル、環境変数、データベース、APIから取得する値はconstにしません。

C#
// constではなく設定から読み込むべき値
string apiUrl = configuration["ApiUrl"];

constを使う前に、「この値はコンパイル時に決まっているか」「将来変更されないか」を確認すると、多くのエラーを回避できます。

6. constを使うべきケース・使わないほうがよいケース

6-1. constを使うべき値の例

constを使うべきなのは、プログラムの実行前から値が確定していて、将来もほとんど変わらない値です。

C#
const int DaysInWeek = 7;
const int MonthsInYear = 12;
const double Pi = 3.141592653589793;
const string DefaultFileExtension = ".txt";

このような値は、コンパイル時に決まり、仕様としても変わりにくいです。

また、コード内で繰り返し使う固定値にも向いています。

C#
const int MaxRetryCount = 3;
const int MinPasswordLength = 8;

直接3や8を書くよりも、名前を付けたほうが意味が伝わりやすくなります。

6-2. readonlyを使ったほうがよい値の例

readonlyは、実行時に値が決まるが、その後は変更したくない値に向いています。

C#
class User
{
    private readonly string userId;

    public User(string id)
    {
        userId = id;
    }
}

この例では、userIdはユーザーごとに異なります。コンパイル時には値が決まらないため、constにはできません。

作成日時のような値もreadonly向きです。

C#
class Order
{
    private readonly DateTime createdAt;

    public Order()
    {
        createdAt = DateTime.Now;
    }
}

オブジェクトごとに異なる固定値は、constではなくreadonlyを使いましょう。

6-3. 将来変更される可能性がある値には注意

将来変更される可能性がある値には、安易にconstを使わないほうがよいです。

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

C#
const double TaxRate = 0.10;

消費税率は一見固定値のように見えますが、法律や仕様変更によって変わる可能性があります。

また、次のような値も注意が必要です。

C#
const string ApiUrl = "https://api.example.com";

API URLは、本番環境、開発環境、テスト環境で変わることがあります。このような値は、設定ファイルや環境変数で管理するほうが適しています。

C#
string apiUrl = configuration["ApiUrl"];

constは便利ですが、変更される可能性がある値には向いていません。

6-4. ライブラリや外部公開APIでpublic constを避ける理由

ライブラリや外部公開APIでpublic constを使う場合は注意が必要です。

C#
public class LibrarySettings
{
    public const int MaxCount = 10;
}

この値を別のプロジェクトが参照すると、コンパイル時に値が埋め込まれることがあります。

つまり、ライブラリ側で値を変更しても、利用側を再コンパイルしない限り、古い値が使われる可能性があります。

C#
public const int MaxCount = 20;

この変更がすぐに利用側へ反映されるとは限りません。

外部に公開する値で、将来変更される可能性がある場合は、public static readonlyを使うほうが安全です。

C#
public static readonly int MaxCount = 20;

特に、NuGetパッケージや共通ライブラリで公開する値は、public constにする前に慎重に判断しましょう。

6-5. 設定値や環境依存の値にconstを使わない理由

設定値や環境依存の値には、constを使わないほうがよいです。

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

C#
const string ConnectionString = "Server=...";
const string ApiKey = "xxxxx";
const string UploadPath = "/var/uploads";

これらは環境によって変わる可能性があります。

開発環境、ステージング環境、本番環境で値が異なる場合、constにしてしまうとコードを変更して再コンパイルする必要があります。

このような値は、設定ファイルや環境変数から読み込むのが一般的です。

C#
string connectionString = configuration.GetConnectionString("Default");
string apiKey = configuration["ApiKey"];

また、APIキーやパスワードのような秘密情報をconstとしてコードに直接書くのは避けるべきです。セキュリティ上のリスクが高くなります。

7. constの実践サンプルコード

7-1. 消費税率や固定メッセージをconstで定義する例

まずは、消費税率や固定メッセージをconstで定義する例です。

C#
class PriceCalculator
{
    private const double TaxRate = 0.10;
    private const string CompleteMessage = "計算が完了しました";

    public void Calculate(int price)
    {
        double total = price + price * TaxRate;

        Console.WriteLine($"税込価格: {total}");
        Console.WriteLine(CompleteMessage);
    }
}

このコードでは、TaxRateとCompleteMessageをconstで定義しています。

ただし、実務では消費税率は将来変更される可能性があります。そのため、長期的に運用するシステムでは、設定ファイルやデータベースで管理したほうがよい場合もあります。

学習用のサンプルとしては、constの使い方を理解しやすい例です。

7-2. クラス定数として使う例

クラス内に定数をまとめて定義することもできます。

C#
class ValidationRules
{
    public const int MinPasswordLength = 8;
    public const int MaxUserNameLength = 20;
    public const string RequiredMessage = "必須項目です";
}

使用する側は、クラス名を使ってアクセスできます。

C#
class Program
{
    static void Main()
    {
        Console.WriteLine(ValidationRules.MinPasswordLength);
        Console.WriteLine(ValidationRules.RequiredMessage);
    }
}

このように、関連する定数をひとつのクラスにまとめると、コードの見通しがよくなります。

ただし、外部プロジェクトから参照されるpublic constは、将来変更時に注意が必要です。内部だけで使う定数であれば、private constとして定義するのが安全です。

C#
private const int MaxRetryCount = 3;

7-3. readonlyに置き換えるべき例

次のようなコードは、constでは書けません。

C#
class Sample
{
    // エラー
    private const DateTime CreatedAt = DateTime.Now;
}

DateTime.Nowは実行時に決まる値なので、constにできません。

この場合は、readonlyに置き換えます。

C#
class Sample
{
    private readonly DateTime createdAt;

    public Sample()
    {
        createdAt = DateTime.Now;
    }

    public void ShowCreatedAt()
    {
        Console.WriteLine(createdAt);
    }
}

クラス全体で共有したい場合は、static readonlyを使います。

C#
class AppInfo
{
    public static readonly DateTime StartedAt = DateTime.Now;
}

constにできない値を無理に定数化しようとせず、値が決まるタイミングに合わせてreadonlyを使うことが大切です。

7-4. constとreadonlyを比較するサンプル

constとreadonlyの違いがわかるサンプルを見てみましょう。

C#
class Sample
{
    private const int ConstValue = 10;
    private readonly int readonlyValue;

    public Sample(int value)
    {
        readonlyValue = value;
    }

    public void Show()
    {
        Console.WriteLine($"const: {ConstValue}");
        Console.WriteLine($"readonly: {readonlyValue}");
    }
}

使い方は次のとおりです。

C#
class Program
{
    static void Main()
    {
        Sample sample1 = new Sample(100);
        Sample sample2 = new Sample(200);

        sample1.Show();
        sample2.Show();
    }
}

実行結果のイメージです。

C#
const: 10
readonly: 100
const: 10
readonly: 200

ConstValueはすべてのインスタンスで同じ値です。一方、readonlyValueはインスタンスを作るときに渡した値によって変わります。

このように、constは全体で固定の値、readonlyはオブジェクトごとに固定の値として使えます。

7-5. 初心者が理解しやすいコード例

最後に、初心者向けにわかりやすい例を見てみましょう。

C#
class Program
{
    const int PassingScore = 70;
    const string PassMessage = "合格です";
    const string FailMessage = "不合格です";

    static void Main()
    {
        int score = 85;

        if (score >= PassingScore)
        {
            Console.WriteLine(PassMessage);
        }
        else
        {
            Console.WriteLine(FailMessage);
        }
    }
}

このコードでは、合格点と表示メッセージをconstで定義しています。

もし70や"合格です"を直接コード内に書くと、後から見たときに意味がわかりにくくなることがあります。

constを使うことで、次のようなメリットがあります。

C#
const int PassingScore = 70;

この1行を見るだけで、70が「合格点」であることがわかります。

初心者のうちは、まず「変わらない値に名前を付ける」目的でconstを使うと理解しやすいです。

8. C# constに関するよくある質問

8-1. constはstaticを付けなくても静的メンバーになる？

はい。クラス内で定義したconstは、staticを付けなくても静的なメンバーとして扱われます。

C#
class AppSettings
{
    public const string AppName = "SampleApp";
}

この定数は、インスタンスを作らずにクラス名から参照できます。

C#
Console.WriteLine(AppSettings.AppName);

逆に、constにstaticを付けることはできません。

C#
// エラー
public static const string AppName = "SampleApp";

constはもともと静的な性質を持っているため、staticは不要です。

8-2. constは後から変更できる？

いいえ。constで定義した値は後から変更できません。

C#
const int MaxCount = 10;

// エラー
MaxCount = 20;

constは宣言時に値を決め、その後は固定されます。

値を後から変更したい場合は、通常の変数を使います。

C#
int maxCount = 10;
maxCount = 20;

初期化後に変更したくないが、コンストラクタで値を決めたい場合はreadonlyを使います。

C#
readonly int maxCount;

public Sample(int count)
{
    maxCount = count;
}

8-3. constとマジックナンバーの関係は？

constは、マジックナンバーを避けるためによく使われます。

マジックナンバーとは、コード内に直接書かれた意味のわかりにくい数値のことです。

C#
if (age >= 20)
{
    Console.WriteLine("成人です");
}

この20は何を意味するのか、コードだけでは少しわかりにくいです。

constを使うと、意味のある名前を付けられます。

C#
const int AdultAge = 20;

if (age >= AdultAge)
{
    Console.WriteLine("成人です");
}

これにより、20が成人年齢を意味していることが明確になります。

マジックナンバーを減らすことで、コードの可読性と保守性が向上します。

8-4. const stringは使ってもよい？

はい。固定の文字列であれば、const stringを使って問題ありません。

C#
const string AppName = "SampleApp";
const string DefaultMessage = "処理が完了しました";

固定メッセージ、アプリケーション名、ログの接頭辞などはconst stringとして使いやすいです。

C#
const string ErrorPrefix = "[ERROR]";

ただし、変更される可能性がある文字列や環境によって異なる文字列はconstにしないほうがよいです。

C#
// 環境によって変わる可能性があるため注意
const string ApiUrl = "https://api.example.com";

API URL、接続文字列、ファイルパスなどは、設定ファイルや環境変数から読み込むほうが適しています。

8-5. enumとconstはどう使い分ける？

enumは、関連する選択肢をまとめて表現したいときに使います。

C#
enum OrderStatus
{
    Pending,
    Shipped,
    Delivered,
    Canceled
}

注文状態、ユーザー種別、処理ステータスなど、複数の決まった選択肢がある場合はenumが向いています。

C#
OrderStatus status = OrderStatus.Pending;

一方、constは単独の固定値に名前を付けたいときに使います。

C#
const int MaxRetryCount = 3;
const string DefaultMessage = "処理中です";

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

たとえば、注文ステータスにはenum、最大リトライ回数にはconstを使うと自然です。

C#
enum OrderStatus
{
    Pending,
    Completed
}

const int MaxRetryCount = 3;

まとめ

C#のconstは、変更できない定数を定義するためのキーワードです。

C#
const int MaxCount = 10;
const string Message = "こんにちは";

constを使うと、固定値に意味のある名前を付けられるため、コードの可読性が向上します。また、同じ値を複数箇所に直接書く必要がなくなり、修正漏れや入力ミスを防ぎやすくなります。

ただし、constにはいくつかの制限があります。constにできるのは、コンパイル時に値が決まるものです。

C#
const int A = 10;
const int B = A * 2;

一方で、DateTime.Nowやnewを使う値、配列、オブジェクトなどはconstにできません。

C#
// エラー
const DateTime Now = DateTime.Now;

このような場合は、readonlyやstatic readonlyを使います。

C#
static readonly DateTime StartedAt = DateTime.Now;

constとreadonlyの大きな違いは、値が決まるタイミングです。constはコンパイル時、readonlyは実行時やコンストラクタで値を決められます。

また、ライブラリや外部公開APIでpublic constを使う場合は注意が必要です。値が利用側に埋め込まれることがあるため、将来変更される可能性がある値にはpublic static readonlyを使うほうが安全です。

constを使うときは、次のように判断するとわかりやすいです。

C#のconstは、正しく使えばコードを読みやすくし、ミスを減らせる便利な機能です。まずは、マジックナンバーや固定メッセージをconstに置き換えるところから始めると、自然に使い方を理解できます。