C#条件演算子「?:」とは？if文との違い・書き方・ネストの注意点を初心者向けに解説

はじめに

C#の条件演算子「?:」は、条件によって返す値を切り替えたいときに使う便利な構文です。

たとえば、点数が60点以上なら「合格」、そうでなければ「不合格」という文字列を変数に入れたい場合、if文でも書けますが、条件演算子を使うと1行で簡潔に表現できます。

C#
int score = 80;

string result = score >= 60 ? "合格" : "不合格";

Console.WriteLine(result);

このように、C# 条件演算子は「条件によって値を選ぶ」場面でよく使われます。

ただし、短く書ける反面、使いすぎると読みにくいコードになりやすい点にも注意が必要です。特に、条件演算子をネストして複雑な分岐を書くと、初心者だけでなく経験者にとっても理解しづらくなることがあります。

この記事では、C#の条件演算子「?:」の基本構文、if文との違い、サンプルコード、ネストの注意点、よくあるエラーまで初心者向けにわかりやすく解説します。

1. C#の条件演算子「?:」とは

C#の条件演算子「?:」とは、条件式の結果に応じて、2つの値のうちどちらかを返す演算子です。

条件がtrueの場合は「trueの場合の値」を返し、条件がfalseの場合は「falseの場合の値」を返します。

1-1. 条件演算子は条件によって返す値を切り替える演算子

条件演算子は、次のような考え方で使います。

C#
条件 ? 条件がtrueのときの値 : 条件がfalseのときの値

たとえば、年齢が20歳以上なら「成人」、そうでなければ「未成年」という文字列を返す場合は、次のように書けます。

C#
int age = 25;

string message = age >= 20 ? "成人" : "未成年";

Console.WriteLine(message);

このコードでは、age >= 20 がtrueなので、message には "成人" が代入されます。

条件演算子は「条件によって処理を実行する」というより、「条件によって使う値を選ぶ」ための構文だと考えると理解しやすいです。

1-2. 「三項演算子」と呼ばれる理由

条件演算子「?:」は、よく「三項演算子」とも呼ばれます。

三項演算子とは、3つの要素を使う演算子という意味です。

C#の条件演算子では、次の3つの要素を使います。

C#
条件式 ? trueの場合の値 : falseの場合の値

具体的には、次の3つです。

1つ目は条件式、2つ目は条件がtrueのときに返す値、3つ目は条件がfalseのときに返す値です。

C#
score >= 60 ? "合格" : "不合格"

この例では、score >= 60、"合格"、"不合格" の3つの要素があります。

そのため、C#の条件演算子は「三項演算子」と呼ばれることがあります。ただし、C#では三項演算子といえば基本的にこの条件演算子「?:」を指します。

1-3. if文より短く書ける代表的な条件分岐

条件演算子を使うと、if文で書くよりも短く書ける場合があります。

たとえば、if文で書くと次のようになります。

C#
int score = 80;
string result;

if (score >= 60)
{
    result = "合格";
}
else
{
    result = "不合格";
}

同じ内容を条件演算子で書くと、次のようになります。

C#
int score = 80;

string result = score >= 60 ? "合格" : "不合格";

条件が単純で、返す値もわかりやすい場合は、条件演算子を使うことでコードをすっきり書けます。

ただし、すべてのif文を条件演算子に置き換えるべきではありません。複雑な処理や複数行の処理がある場合は、if文のほうが読みやすくなります。

1-4. まず覚えるべき基本形

C# 条件演算子でまず覚えるべき基本形は、次の形です。

C#
変数 = 条件式 ? trueの場合の値 : falseの場合の値;

例を見てみましょう。

C#
int number = 10;

string text = number > 0 ? "正の数です" : "0以下です";

Console.WriteLine(text);

このコードでは、number > 0 がtrueなので、text には "正の数です" が代入されます。

初心者のうちは、まず「条件式」「trueの場合」「falseの場合」の3つに分けて読むことを意識しましょう。

C#
number > 0       ? "正の数です" : "0以下です"
// 条件式          trueの場合       falseの場合

この読み方に慣れると、条件演算子のコードを理解しやすくなります。

2. C#条件演算子「?:」の書き方と基本構文

C#の条件演算子「?:」は、書き方自体はとてもシンプルです。

ただし、条件式にはbool型の結果が必要であり、true側とfalse側には「返す値」を書く必要があります。

2-1. 基本文法：条件式 ? trueの場合 : falseの場合

条件演算子の基本構文は次のとおりです。

C#
条件式 ? trueの場合の値 : falseの場合の値

たとえば、次のように使います。

C#
int age = 18;

string result = age >= 20 ? "成人" : "未成年";

この場合、age >= 20 が条件式です。

条件式がtrueなら "成人" が返され、falseなら "未成年" が返されます。

age は18なので、age >= 20 はfalseです。そのため、result には "未成年" が入ります。

2-2. 条件式にはbool型の結果を指定する

条件演算子の条件式には、trueまたはfalseになる式を書く必要があります。

たとえば、次のような式はbool型の結果になります。

C#
score >= 60
age < 20
name == "田中"
isEnabled

具体例です。

C#
int score = 70;

string result = score >= 60 ? "合格" : "不合格";

score >= 60 は、条件を満たせばtrue、満たさなければfalseになります。

一方、次のような書き方は条件式として不適切です。

C#
int score = 70;

string result = score ? "合格" : "不合格";

C#では、score はint型であり、bool型ではありません。そのため、条件式として使うことはできません。

正しくは、次のように比較式を書きます。

C#
string result = score >= 60 ? "合格" : "不合格";

C#では、JavaScriptのように数値の0や1を自動的にfalseやtrueとして扱うことはありません。条件式には明確にbool型の式を書く必要があります。

2-3. true側とfalse側には「返す値」を書く

条件演算子のtrue側とfalse側には、条件に応じて返す値を書きます。

C#
int number = 5;

string result = number % 2 == 0 ? "偶数" : "奇数";

この例では、条件がtrueなら "偶数"、falseなら "奇数" という文字列を返します。

重要なのは、条件演算子は「値を返す式」だということです。

そのため、次のように変数への代入に使えます。

C#
string result = number % 2 == 0 ? "偶数" : "奇数";

また、return文でも使えます。

C#
static string GetEvenOddText(int number)
{
    return number % 2 == 0 ? "偶数" : "奇数";
}

一方で、条件演算子は複数行の処理を分けるためのものではありません。処理を分岐したい場合は、基本的にif文を使うほうが適しています。

2-4. 代入・return・表示処理で使う基本例

条件演算子は、代入、return、表示処理などでよく使われます。

まずは代入の例です。

C#
int score = 85;

string result = score >= 60 ? "合格" : "不合格";

Console.WriteLine(result);

次に、return文で使う例です。

C#
static string GetPassOrFail(int score)
{
    return score >= 60 ? "合格" : "不合格";
}

条件演算子を使うことで、単純な判定結果をそのまま返せます。

表示処理の中で使うこともできます。

C#
int stock = 0;

Console.WriteLine(stock > 0 ? "在庫あり" : "在庫なし");

このように、条件演算子は「条件によって表示する文字列を変える」ような場面でも便利です。

ただし、表示処理そのものを条件演算子の中に書くのではなく、条件演算子で文字列を選び、その結果を Console.WriteLine に渡す形にすると読みやすくなります。

2-5. 初心者が読み間違えやすい「?」と「:」の意味

条件演算子では、? と : の意味を正しく理解することが大切です。

C#
条件式 ? trueの場合 : falseの場合

? は「この条件がtrueなら次の値を使う」という区切りです。

: は「そうでなければこちらの値を使う」という区切りです。

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

C#
int score = 50;

string result = score >= 60 ? "合格" : "不合格";

このコードは、次のように読みます。

score >= 60 ですか？ trueなら "合格"、falseなら "不合格"。

? は疑問、: はそれ以外、というイメージで覚えると理解しやすいです。

ただし、C#には ?? や ?. など、似た記号を使う演算子もあります。条件演算子「?:」とは意味が違うため、混同しないようにしましょう。

3. C#条件演算子の使い方をサンプルコードで解説

ここからは、C# 条件演算子の使い方を具体的なサンプルコードで見ていきます。

初心者のうちは、まず「条件によって文字列を切り替える例」から練習すると理解しやすいです。

3-1. 数値の大小で表示文字列を切り替える例

次の例では、数値が10以上かどうかで表示する文字列を切り替えます。

C#
int number = 15;

string message = number >= 10 ? "10以上です" : "10未満です";

Console.WriteLine(message);

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

C#
10以上です

number は15なので、number >= 10 はtrueです。そのため、"10以上です" が選ばれます。

同じ処理をif文で書くと、次のようになります。

C#
int number = 15;
string message;

if (number >= 10)
{
    message = "10以上です";
}
else
{
    message = "10未満です";
}

Console.WriteLine(message);

このように、単純に値を切り替えるだけなら、条件演算子のほうが短く書けます。

3-2. 合格・不合格を判定する例

条件演算子は、点数による合格・不合格の判定にもよく使われます。

C#
int score = 72;

string result = score >= 60 ? "合格" : "不合格";

Console.WriteLine(result);

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

C#
合格

score >= 60 がtrueなので、"合格" が返されます。

メソッドにすると、次のように書けます。

C#
static string GetResult(int score)
{
    return score >= 60 ? "合格" : "不合格";
}

このように、条件演算子は「条件によって返す文字列を変える」処理に向いています。

ただし、合格・不合格だけでなく、「優」「良」「可」「不可」のように条件が増える場合は、条件演算子をネストするよりもif文やswitch式を検討したほうが読みやすくなります。

3-3. 偶数・奇数を判定する例

偶数・奇数の判定にも条件演算子を使えます。

C#
int number = 9;

string result = number % 2 == 0 ? "偶数" : "奇数";

Console.WriteLine(result);

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

C#
奇数

number % 2 は、numberを2で割った余りを表します。

余りが0なら偶数、0でなければ奇数です。

C#
number % 2 == 0

この条件がtrueなら "偶数"、falseなら "奇数" が返されます。

条件演算子を使うと、偶数・奇数のようなシンプルな判定を1行で表現できます。

3-4. bool値をもとに文言を切り替える例

条件式には、比較式だけでなくbool型の変数も使えます。

C#
bool isLoggedIn = true;

string message = isLoggedIn ? "ログイン中です" : "ログインしてください";

Console.WriteLine(message);

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

C#
ログイン中です

isLoggedIn はbool型なので、そのまま条件式として使えます。

isLoggedIn == true のように書くこともできますが、bool型の変数であれば次のように書くほうが簡潔です。

C#
string message = isLoggedIn ? "ログイン中です" : "ログインしてください";

falseの場合を判定したいときは、否定演算子 ! を使えます。

C#
bool isLoggedIn = false;

string message = !isLoggedIn ? "ログインしてください" : "ログイン中です";

Console.WriteLine(message);

ただし、否定を使うと読みにくくなる場合があります。初心者のうちは、できるだけ自然に読める条件式にすることを意識しましょう。

3-5. return文で条件演算子を使う例

条件演算子は、メソッドのreturn文でよく使われます。

C#
static string GetAgeGroup(int age)
{
    return age >= 20 ? "成人" : "未成年";
}

このメソッドは、年齢が20以上なら "成人"、そうでなければ "未成年" を返します。

呼び出し例は次のとおりです。

C#
Console.WriteLine(GetAgeGroup(25));
Console.WriteLine(GetAgeGroup(18));

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

C#
成人
未成年

return文で条件演算子を使うと、一時的な変数を作らずに結果を返せます。

if文で書くと次のようになります。

C#
static string GetAgeGroup(int age)
{
    if (age >= 20)
    {
        return "成人";
    }
    else
    {
        return "未成年";
    }
}

どちらも正しい書き方です。条件が単純なら条件演算子、処理が複雑ならif文を使うとよいでしょう。

4. 条件演算子「?:」とif文の違い

C#の条件演算子とif文は、どちらも条件分岐に使えます。

しかし、目的が少し違います。

条件演算子は「値を返す」ために使うことが多く、if文は「処理を分岐する」ために使うことが多いです。

4-1. 条件演算子は「値を返す」ために使う

条件演算子は、条件によって返す値を切り替えるための構文です。

C#
string result = score >= 60 ? "合格" : "不合格";

このコードでは、条件によって "合格" または "不合格" という値を返し、それを result に代入しています。

つまり、条件演算子の主な役割は「どの値を使うかを選ぶこと」です。

次のような場面で使いやすいです。

C#
string label = isActive ? "有効" : "無効";
int fee = isMember ? 500 : 1000;
string className = hasError ? "error" : "normal";

どれも、条件によって代入する値を切り替えています。

4-2. if文は「処理を分岐する」ために使う

if文は、条件によって実行する処理を分岐するための構文です。

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

この例では、条件によって実行する Console.WriteLine の処理を分けています。

さらに、複数の処理を書くこともできます。

C#
if (score >= 60)
{
    Console.WriteLine("合格です");
    Console.WriteLine("おめでとうございます");
}
else
{
    Console.WriteLine("不合格です");
    Console.WriteLine("再挑戦しましょう");
}

このように、複数行の処理や状態の変更を伴う処理では、条件演算子よりif文のほうが適しています。

4-3. 条件演算子で書くと読みやすいケース

条件演算子で書くと読みやすいのは、条件が単純で、返す値も短い場合です。

たとえば、次のようなケースです。

C#
string result = score >= 60 ? "合格" : "不合格";

C#
string status = isActive ? "有効" : "無効";

C#
int price = isMember ? 800 : 1000;

これらは、条件式も返す値も短く、1行で読んでも意味がわかりやすいです。

「AならB、そうでなければC」と自然に読める場合は、条件演算子に向いています。

4-4. if文で書いたほうが読みやすいケース

一方で、条件が複雑な場合や、処理が複数ある場合はif文のほうが読みやすくなります。

たとえば、次のような条件演算子は読みにくくなりがちです。

C#
string result = score >= 80 && attendanceRate >= 90 ? "優秀" : "通常";

まだ読める範囲ではありますが、条件がさらに長くなると理解しづらくなります。

また、次のように処理を分けたい場合はif文を使うべきです。

C#
if (isError)
{
    Console.WriteLine("エラーが発生しました");
    LogError();
}
else
{
    Console.WriteLine("正常に完了しました");
    SaveResult();
}

条件演算子は、複数の処理を実行するための構文ではありません。

「値の切り替え」なら条件演算子、「処理の分岐」ならif文と考えると判断しやすくなります。

4-5. 条件演算子とif文の書き換え例

if文を条件演算子に書き換える例を見てみましょう。

まずはif文です。

C#
int score = 75;
string result;

if (score >= 60)
{
    result = "合格";
}
else
{
    result = "不合格";
}

これを条件演算子で書くと、次のようになります。

C#
int score = 75;

string result = score >= 60 ? "合格" : "不合格";

反対に、条件演算子をif文に書き換えると次のようになります。

C#
int age = 18;

string message = age >= 20 ? "成人" : "未成年";

if文で書くと、次のようになります。

C#
int age = 18;
string message;

if (age >= 20)
{
    message = "成人";
}
else
{
    message = "未成年";
}

どちらが正しいというより、読みやすいほうを選ぶことが大切です。

初心者のうちは、条件演算子で読みにくいと感じたら無理に使わず、if文で書くのがおすすめです。

5. C#条件演算子を使うメリット・デメリット

C# 条件演算子には、短く書けるという大きなメリットがあります。

一方で、使い方を間違えると読みにくいコードになりやすいというデメリットもあります。

5-1. メリット：短く簡潔に書ける

条件演算子の最大のメリットは、単純な条件分岐を短く書けることです。

if文では複数行になる処理も、条件演算子なら1行で書けます。

C#
string result = score >= 60 ? "合格" : "不合格";

if文で書くと、次のようになります。

C#
string result;

if (score >= 60)
{
    result = "合格";
}
else
{
    result = "不合格";
}

単純な値の切り替えであれば、条件演算子のほうがコード量を減らせます。

コード量が減ることで、変数の代入先や条件の意図が見えやすくなる場合もあります。

5-2. メリット：代入やreturnを1行で表現できる

条件演算子は、代入やreturnと相性がよいです。

代入の例です。

C#
string status = isActive ? "有効" : "無効";

return文の例です。

C#
static string GetStatus(bool isActive)
{
    return isActive ? "有効" : "無効";
}

このように、単純な結果を返すメソッドでは、条件演算子を使うことでコードがすっきりします。

特に、次のように一時変数を用意する必要がない場合は便利です。

C#
static int GetPrice(bool isMember)
{
    return isMember ? 800 : 1000;
}

条件が単純で、返す値も明確であれば、条件演算子は読みやすいコードを書く助けになります。

5-3. デメリット：複雑な条件では読みにくくなる

条件演算子のデメリットは、複雑な条件を書くと読みにくくなることです。

たとえば、次のようなコードは一目で理解しづらいです。

C#
string result = score >= 80 ? "優" : score >= 60 ? "可" : "不可";

このコードは、条件演算子をネストしています。

短くは書けていますが、どの条件に対してどの結果が返るのかを読み解く必要があります。

if文で書くと、次のようになります。

C#
string result;

if (score >= 80)
{
    result = "優";
}
else if (score >= 60)
{
    result = "可";
}
else
{
    result = "不可";
}

こちらのほうが、条件の流れを追いやすい場合が多いです。

短く書くことよりも、読みやすく書くことを優先しましょう。

5-4. デメリット：処理を書く用途には向いていない

条件演算子は、値を返すための構文です。

そのため、条件によって複数の処理を実行したい場合には向いていません。

たとえば、次のような処理はif文で書くほうが自然です。

C#
if (isSuccess)
{
    Console.WriteLine("成功しました");
    SaveData();
}
else
{
    Console.WriteLine("失敗しました");
    ShowError();
}

これを無理に条件演算子で書こうとすると、コードの意図がわかりにくくなります。

条件演算子は「値を選ぶ」、if文は「処理を分ける」と覚えておきましょう。

5-5. 実務で意識したい可読性の判断基準

実務では、コードは自分だけでなく他の人も読みます。

そのため、条件演算子を使うかどうかは、短さだけでなく可読性で判断することが重要です。

判断基準としては、次のように考えるとよいでしょう。

条件式が短いか、true側とfalse側の値が短いか、1行で自然に読めるか、ネストしていないか、あとから修正しやすいか。

たとえば、次のコードは読みやすいです。

C#
string label = isEnabled ? "有効" : "無効";

一方で、次のようなコードは読みにくくなりやすいです。

C#
string label = isEnabled && userCount > 0 && !isExpired ? "利用可能" : "利用不可";

条件が長くなる場合は、条件を変数に分けると読みやすくなります。

C#
bool canUse = isEnabled && userCount > 0 && !isExpired;

string label = canUse ? "利用可能" : "利用不可";

条件演算子を使う場合でも、読みやすくする工夫は大切です。

6. 条件演算子のネストの書き方と注意点

条件演算子は、条件演算子の中にさらに条件演算子を書くことができます。

これをネストといいます。

ただし、条件演算子のネストは読みにくくなりやすいため、使いすぎには注意が必要です。

6-1. ネストとは条件演算子の中に条件演算子を書くこと

ネストとは、ある構文の中に同じ構文を入れることです。

条件演算子の場合、true側またはfalse側にさらに条件演算子を書くことを指します。

C#
条件1 ? 値1 : 条件2 ? 値2 : 値3

このような書き方をすると、条件1がfalseだった場合に、条件2をさらに判定します。

たとえば、点数によって評価を分ける場合、次のように書けます。

C#
string grade = score >= 80 ? "優" : score >= 60 ? "可" : "不可";

このコードは、次のような意味です。

scoreが80以上なら「優」、そうでなくて60以上なら「可」、それ以外なら「不可」。

短く書けますが、初心者にとっては少し読みづらい形です。

6-2. ネストした条件演算子の基本例

ネストした条件演算子の例を見てみましょう。

C#
int score = 75;

string grade = score >= 80 ? "優" : score >= 60 ? "可" : "不可";

Console.WriteLine(grade);

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

C#
可

score は75なので、最初の条件 score >= 80 はfalseです。

次に、score >= 60 が判定されます。この条件はtrueなので、"可" が返されます。

if文で書くと、次のようになります。

C#
int score = 75;
string grade;

if (score >= 80)
{
    grade = "優";
}
else if (score >= 60)
{
    grade = "可";
}
else
{
    grade = "不可";
}

Console.WriteLine(grade);

条件が2つ以上になると、if文のほうが流れを理解しやすい場合があります。

6-3. ネストが読みにくくなる理由

条件演算子のネストが読みにくくなる理由は、条件と結果の対応関係がわかりにくくなるためです。

次のコードを見てください。

C#
string message = age < 13 ? "子ども" : age < 20 ? "未成年" : age < 65 ? "成人" : "高齢者";

このコードは1行で書けていますが、どの条件のときにどの文字列が返るのかをすぐに判断しにくいです。

特に、条件が増えるほど ? と : の対応が追いづらくなります。

また、あとから条件を追加したり変更したりするときに、間違いが入りやすくなります。

短く書けることはメリットですが、読みにくくなるなら条件演算子を使う意味は薄くなります。

6-4. ネストはif文やswitch式に置き換えると読みやすい

条件演算子のネストが読みにくい場合は、if文に置き換えるとわかりやすくなります。

C#
string message;

if (age < 13)
{
    message = "子ども";
}
else if (age < 20)
{
    message = "未成年";
}
else if (age < 65)
{
    message = "成人";
}
else
{
    message = "高齢者";
}

また、値のパターンによって結果を分ける場合は、switch式を使うと読みやすくなることがあります。

C#
string grade = score switch
{
    >= 80 => "優",
    >= 60 => "可",
    _ => "不可"
};

switch式を使うと、条件と返す値の対応が縦に並ぶため、ネストした条件演算子より見やすくなります。

条件が3つ以上ある場合は、条件演算子のネストではなく、if文やswitch式を検討しましょう。

6-5. ネストを使う場合のインデントと括弧の付け方

どうしても条件演算子をネストする場合は、インデントや括弧を使って読みやすくすることが大切です。

1行で書くと、次のように読みにくくなります。

C#
string grade = score >= 80 ? "優" : score >= 60 ? "可" : "不可";

改行して書くと、少し読みやすくなります。

C#
string grade = score >= 80
    ? "優"
    : score >= 60
        ? "可"
        : "不可";

括弧を使って意図を明確にすることもできます。

C#
string grade = score >= 80
    ? "優"
    : (score >= 60 ? "可" : "不可");

ただし、インデントや括弧を付けても読みにくいと感じる場合は、if文やswitch式にしたほうがよいです。

条件演算子のネストは、書けるから使うのではなく、読んでわかりやすい場合にだけ使いましょう。

7. C#条件演算子でよくあるエラーと注意点

C# 条件演算子は便利ですが、初心者がつまずきやすいポイントもあります。

特に、型の不一致、boolではない条件式、処理文を書こうとするミス、nullや空文字の判定、演算子の優先順位には注意が必要です。

7-1. true側とfalse側の型が合わない

条件演算子では、true側とfalse側の値の型が合わないとエラーになることがあります。

たとえば、次のコードは問題になる可能性があります。

C#
bool isMember = true;

var result = isMember ? "会員" : 0;

true側は文字列、false側は整数です。

C#では、条件演算子全体として1つの型に決める必要があります。そのため、true側とfalse側の型が明らかに異なると、コンパイルエラーになることがあります。

この場合は、型をそろえるのが基本です。

C#
bool isMember = true;

string result = isMember ? "会員" : "非会員";

数値を返したい場合も、両方を数値にします。

C#
int price = isMember ? 800 : 1000;

条件演算子では、true側とfalse側が同じ型、または互換性のある型になるように意識しましょう。

7-2. 条件式がboolになっていない

条件式がbool型になっていない場合もエラーになります。

次のコードは誤りです。

C#
int count = 5;

string message = count ? "あります" : "ありません";

C#では、int型の count をそのまま条件式として使うことはできません。

正しくは、比較式を書きます。

C#
int count = 5;

string message = count > 0 ? "あります" : "ありません";

C#では、条件式には必ずtrueまたはfalseになる式が必要です。

次のような比較式を使いましょう。

C#
count > 0
score >= 60
name == "admin"
isEnabled

bool型の変数であれば、そのまま条件式として使えます。

C#
bool isEnabled = true;

string message = isEnabled ? "有効" : "無効";

7-3. 処理文を書こうとしてエラーになる

条件演算子は、処理を分岐するためではなく、値を返すために使います。

そのため、条件によって複数の処理を実行したい場合には向いていません。

たとえば、次のような考え方は避けたほうがよいです。

C#
// 条件演算子で処理を無理に分けようとするのは読みづらい

表示する文字列を切り替えるなら、次のように書けます。

C#
Console.WriteLine(isSuccess ? "成功しました" : "失敗しました");

しかし、条件ごとに複数の処理を行うならif文を使います。

C#
if (isSuccess)
{
    Console.WriteLine("成功しました");
    SaveData();
}
else
{
    Console.WriteLine("失敗しました");
    ShowError();
}

条件演算子で無理に処理を書こうとすると、可読性が下がるだけでなく、構文エラーにつながることもあります。

「値を返すなら条件演算子、処理を分けるならif文」と覚えておきましょう。

7-4. nullや空文字の判定で混乱する

文字列を扱うとき、nullと空文字を混同しないように注意が必要です。

nullは「値が存在しない」状態です。

空文字 "" は「文字数が0の文字列」です。

たとえば、次のコードではnullだけを判定しています。

C#
string? name = null;

string displayName = name == null ? "名前未設定" : name;

この場合、name がnullなら "名前未設定" が返されます。

ただし、name が空文字の場合はnullではないため、そのまま空文字が返されます。

C#
string name = "";

string displayName = name == null ? "名前未設定" : name;

空文字も含めて判定したい場合は、string.IsNullOrEmpty を使うと便利です。

C#
string name = "";

string displayName = string.IsNullOrEmpty(name) ? "名前未設定" : name;

さらに、空白だけの文字列も未設定として扱いたい場合は、string.IsNullOrWhiteSpace を使えます。

C#
string name = "   ";

string displayName = string.IsNullOrWhiteSpace(name) ? "名前未設定" : name;

null、空文字、空白文字は意味が異なるため、条件演算子で判定するときも意図を明確にしましょう。

7-5. 演算子の優先順位で意図しない結果になる

条件演算子を他の演算子と組み合わせると、優先順位によって意図しない結果になることがあります。

読みやすさを重視するなら、迷う場合は括弧を付けるのがおすすめです。

たとえば、次のように文字列連結と条件演算子を組み合わせる場合は注意が必要です。

C#
int score = 80;

string message = "結果: " + (score >= 60 ? "合格" : "不合格");

Console.WriteLine(message);

このように括弧を付けると、条件演算子の結果を文字列に連結していることが明確になります。

括弧がないと、コードを読む人がどこまでが条件式なのか迷うことがあります。

また、条件式が複雑な場合も括弧を使うと読みやすくなります。

C#
string result = (score >= 60 && attendanceRate >= 80) ? "合格" : "不合格";

C#の演算子には優先順位がありますが、初心者のうちは無理に暗記するより、読み間違えそうな箇所に括弧を付けることを意識しましょう。

8. 条件演算子と似たC#の演算子との違い

C#には、条件演算子「?:」と似た記号を使う演算子があります。

代表的なものに、null合体演算子「??」、null条件演算子「?.」、条件付き論理演算子「&&」「||」、switch式があります。

それぞれ用途が違うため、混同しないようにしましょう。

8-1. null合体演算子「??」との違い

null合体演算子「??」は、左側の値がnullでなければ左側を返し、nullなら右側を返す演算子です。

C#
string? name = null;

string displayName = name ?? "名前未設定";

Console.WriteLine(displayName);

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

C#
名前未設定

これは、条件演算子で書くと次のような意味になります。

C#
string displayName = name != null ? name : "名前未設定";

条件演算子「?:」は自由な条件式を書けます。

一方、null合体演算子「??」はnullかどうかの判定に特化しています。

null判定だけをしたい場合は、?? を使うと簡潔です。

C#
string displayName = name ?? "名前未設定";

複雑な条件で値を切り替えたい場合は、条件演算子を使います。

C#
string message = score >= 60 ? "合格" : "不合格";

8-2. null条件演算子「?.」との違い

null条件演算子「?.」は、対象がnullでない場合だけメンバーにアクセスする演算子です。

C#
string? name = null;

int? length = name?.Length;

Console.WriteLine(length);

name がnullの場合、name.Length を実行するとエラーになります。

しかし、name?.Length と書くと、name がnullなら結果はnullになります。

条件演算子「?:」とは目的が違います。

条件演算子は、条件によって返す値を切り替えます。

C#
string message = name == null ? "名前がありません" : name;

null条件演算子は、nullの可能性があるオブジェクトに安全にアクセスするために使います。

C#
int? length = name?.Length;

nullチェックをしながら値を切り替えたい場合は、条件演算子、nullの可能性があるオブジェクトのメンバーに安全にアクセスしたい場合は、null条件演算子を使います。

8-3. 条件付き論理演算子「&&」「||」との違い

条件付き論理演算子「&&」と「||」は、複数の条件を組み合わせるために使います。

&& は「かつ」、|| は「または」を表します。

C#
int score = 80;
int attendanceRate = 90;

bool isPassed = score >= 60 && attendanceRate >= 80;

この例では、scoreが60以上、かつattendanceRateが80以上ならtrueになります。

|| の例です。

C#
bool canEnter = isMember || hasTicket;

この例では、会員である、またはチケットを持っている場合にtrueになります。

条件演算子「?:」は、条件に応じて返す値を切り替えるために使います。

C#
string result = isPassed ? "合格" : "不合格";

実際のコードでは、&& や || で条件を作り、その結果を条件演算子で使うこともあります。

C#
string result = score >= 60 && attendanceRate >= 80 ? "合格" : "不合格";

ただし、条件が長くなる場合は、bool型の変数に分けると読みやすくなります。

C#
bool isPassed = score >= 60 && attendanceRate >= 80;

string result = isPassed ? "合格" : "不合格";

8-4. switch式との使い分け

switch式は、複数の条件やパターンに応じて値を返すときに便利です。

たとえば、点数によって評価を分ける場合、条件演算子をネストすると次のようになります。

C#
string grade = score >= 80 ? "優" : score >= 60 ? "可" : "不可";

switch式で書くと、次のようになります。

C#
string grade = score switch
{
    >= 80 => "優",
    >= 60 => "可",
    _ => "不可"
};

switch式のほうが、条件と結果の対応が縦に並ぶため読みやすいです。

条件が2択なら条件演算子で十分です。

C#
string result = score >= 60 ? "合格" : "不合格";

条件が3つ以上ある場合や、パターンが増える場合はswitch式を検討しましょう。

8-5. どの構文を選ぶべきかの判断基準

条件演算子、if文、null合体演算子、null条件演算子、switch式は、それぞれ得意な場面が違います。

2択の値を切り替えたいなら、条件演算子が向いています。

C#
string result = isActive ? "有効" : "無効";

nullの場合の代替値を指定したいなら、null合体演算子が向いています。

C#
string displayName = name ?? "未設定";

nullの可能性があるオブジェクトに安全にアクセスしたいなら、null条件演算子が向いています。

C#
int? length = name?.Length;

複数の条件で処理を分けたいなら、if文が向いています。

C#
if (isError)
{
    ShowError();
}
else
{
    SaveData();
}

複数の条件で値を返したいなら、switch式が向いている場合があります。

C#
string grade = score switch
{
    >= 80 => "優",
    >= 60 => "可",
    _ => "不可"
};

どの構文を使うか迷ったら、「値を選ぶのか」「処理を分けるのか」「条件はいくつあるのか」を基準に考えましょう。

9. C#条件演算子を使うときのベストプラクティス

C# 条件演算子は、正しく使えばコードを簡潔にできます。

しかし、使いすぎると読みにくくなるため、可読性を意識して使うことが大切です。

9-1. 単純な条件分岐にだけ使う

条件演算子は、単純な条件分岐に使うのが基本です。

たとえば、次のようなコードは条件演算子に向いています。

C#
string status = isActive ? "有効" : "無効";

条件式が短く、trueの場合とfalseの場合の値も短いため、読みやすいです。

一方で、条件が長い場合は読みにくくなります。

C#
string result = user != null && user.IsActive && user.LoginCount > 0 ? "利用可能" : "利用不可";

このような場合は、条件を変数に分けるとよいです。

C#
bool canUse = user != null && user.IsActive && user.LoginCount > 0;

string result = canUse ? "利用可能" : "利用不可";

条件演算子を使うときは、1行で自然に読めるかを確認しましょう。

9-2. 1行で読めない場合はif文にする

条件演算子は、1行で読めるときに効果を発揮します。

逆に、1行で意味が取りづらい場合は、if文にしたほうが読みやすいです。

読みにくい例です。

C#
string message = age < 13 ? "子ども" : age < 20 ? "未成年" : age < 65 ? "成人" : "高齢者";

if文にすると、条件の流れがわかりやすくなります。

C#
string message;

if (age < 13)
{
    message = "子ども";
}
else if (age < 20)
{
    message = "未成年";
}
else if (age < 65)
{
    message = "成人";
}
else
{
    message = "高齢者";
}

短さよりも、あとから読んで理解しやすいことを優先しましょう。

9-3. ネストはできるだけ避ける

条件演算子のネストは、できるだけ避けるのがおすすめです。

ネストすると、? と : の対応がわかりにくくなります。

C#
string grade = score >= 80 ? "優" : score >= 60 ? "可" : "不可";

この程度なら読める場合もありますが、条件が増えると急に読みにくくなります。

代わりに、if文やswitch式を使うとよいでしょう。

C#
string grade = score switch
{
    >= 80 => "優",
    >= 60 => "可",
    _ => "不可"
};

ネストした条件演算子は、短く書けても保守しづらくなることがあります。

チーム開発では特に、誰が読んでも理解しやすい形を選びましょう。

9-4. 型をそろえて意図を明確にする

条件演算子では、true側とfalse側の型をそろえることが重要です。

良い例です。

C#
string result = score >= 60 ? "合格" : "不合格";

どちらもstring型なので、結果もわかりやすいです。

数値の場合も、同じ型として扱える値を返しましょう。

C#
int price = isMember ? 800 : 1000;

型が異なる値を返すと、コードの意図がわかりにくくなったり、コンパイルエラーになったりします。

C#
// 読みにくく、エラーの原因にもなりやすい
var result = isMember ? "会員" : 0;

条件演算子では、返す値の型をそろえることで、コードの意味が明確になります。

9-5. チーム開発では可読性を優先する

チーム開発では、コードは多くの人が読みます。

そのため、条件演算子を使うかどうかは、自分が書きやすいかではなく、チーム全体で読みやすいかを基準に考えることが大切です。

たとえば、次のコードは多くの人にとって読みやすいです。

C#
string status = isActive ? "有効" : "無効";

一方で、次のようなコードは、人によっては読みにくいと感じる可能性があります。

C#
string status = user != null && user.IsActive && !user.IsLocked ? "利用可能" : "利用不可";

この場合は、条件を変数に分けると意図が伝わりやすくなります。

C#
bool canUse = user != null && user.IsActive && !user.IsLocked;

string status = canUse ? "利用可能" : "利用不可";

条件演算子は便利ですが、無理に使う必要はありません。

読みやすさ、修正しやすさ、チームのコーディング規約を優先して使いましょう。

10. C#条件演算子に関するよくある質問

ここでは、C# 条件演算子について初心者が疑問に思いやすい内容をQ&A形式で解説します。

10-1. C#の条件演算子と三項演算子は同じですか？

はい、基本的には同じものを指します。

C#の条件演算子「?:」は、3つの要素を使うため三項演算子と呼ばれます。

C#
条件式 ? trueの場合の値 : falseの場合の値

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

C#
string result = score >= 60 ? "合格" : "不合格";

score >= 60、"合格"、"不合格" の3つの要素があるため、三項演算子と呼ばれます。

ただし、正確には「条件演算子」が構文名で、「三項演算子」は3つの項を取る演算子という特徴を表す呼び方です。

10-2. 条件演算子で複数条件は書けますか？

はい、書けます。

複数条件を使いたい場合は、&& や || を使います。

C#
int score = 75;
int attendanceRate = 85;

string result = score >= 60 && attendanceRate >= 80 ? "合格" : "不合格";

この例では、scoreが60以上、かつattendanceRateが80以上なら "合格" になります。

ただし、条件が長くなる場合は、bool型の変数に分けたほうが読みやすくなります。

C#
bool isPassed = score >= 60 && attendanceRate >= 80;

string result = isPassed ? "合格" : "不合格";

条件演算子の中に複雑な条件を直接書きすぎると読みにくくなるため注意しましょう。

10-3. 条件演算子の中でメソッドを呼び出せますか？

はい、呼び出せます。

ただし、true側とfalse側で返す値の型が合うようにする必要があります。

C#
string message = isMorning ? GetMorningMessage() : GetEveningMessage();

static string GetMorningMessage()
{
    return "おはようございます";
}

static string GetEveningMessage()
{
    return "こんばんは";
}

この例では、どちらのメソッドもstring型を返すため、条件演算子で使えます。

一方で、条件によって処理だけを実行したい場合は、if文のほうが適しています。

C#
if (isMorning)
{
    ShowMorningMessage();
}
else
{
    ShowEveningMessage();
}

条件演算子の中でメソッドを呼び出せる場合でも、読みやすさを優先して判断しましょう。

10-4. 条件演算子はif文より高速ですか？

基本的に、初心者が気にするほどの速度差はほとんどありません。

条件演算子とif文のどちらを使うかは、速度ではなく可読性で判断するのが基本です。

次の2つのコードは、意味としてはほぼ同じです。

C#
string result = score >= 60 ? "合格" : "不合格";

C#
string result;

if (score >= 60)
{
    result = "合格";
}
else
{
    result = "不合格";
}

単純な分岐であれば、パフォーマンスよりも「読みやすいか」「意図が伝わりやすいか」を重視しましょう。

高速化が必要な場面では、条件演算子かif文かよりも、アルゴリズムやデータ構造の見直しのほうが重要になることが多いです。

10-5. 初心者は条件演算子とif文のどちらを使うべきですか？

初心者は、まずif文をしっかり理解することをおすすめします。

if文は条件分岐の基本であり、処理の流れを理解しやすいからです。

そのうえで、単純な値の切り替えには条件演算子を使うとよいでしょう。

たとえば、次のようなコードは条件演算子に向いています。

C#
string result = score >= 60 ? "合格" : "不合格";

一方で、複数の処理を分ける場合はif文を使いましょう。

C#
if (score >= 60)
{
    Console.WriteLine("合格です");
    SendPassMessage();
}
else
{
    Console.WriteLine("不合格です");
    SendFailMessage();
}

初心者のうちは、「条件演算子で書いて読みにくい」と感じたら、無理せずif文に戻すのがおすすめです。

まとめ

C#の条件演算子「?:」は、条件によって返す値を切り替えるための演算子です。

基本構文は次の形です。

C#
条件式 ? trueの場合の値 : falseの場合の値

たとえば、点数が60点以上なら「合格」、そうでなければ「不合格」としたい場合は、次のように書けます。

C#
string result = score >= 60 ? "合格" : "不合格";

条件演算子は、if文より短く書ける便利な構文です。

ただし、条件演算子は「値を返す」ために使うものであり、複数の処理を分岐する用途には向いていません。

単純な値の切り替えなら条件演算子、複数行の処理や複雑な条件分岐ならif文を使うとよいでしょう。

また、条件演算子のネストは読みにくくなりやすいため、できるだけ避けるのがおすすめです。条件が3つ以上になる場合は、if文やswitch式を検討しましょう。

C# 条件演算子を使うときは、短く書くことだけでなく、読みやすさを意識することが大切です。単純な条件分岐に適切に使えば、コードを簡潔でわかりやすくできます。