C#のOrElseはどれ？VB.NETとの違いから「||」の短絡評価までわかりやすく解説

はじめに

VB.NETからC#へ移行するときや、VB.NETのコードを読んでC#に書き換えるときに、「C#のOrElseはどれ？」と迷うことがあります。

結論からいうと、C#にはOrElseというキーワードはありません。VB.NETのOrElseに相当するC#の演算子は、**||**です。

OrElseも||も、どちらも「左側の条件が真なら、右側の条件を評価しない」という短絡評価を行うOR演算です。短絡評価を理解しておくと、nullチェック、ゼロ除算の回避、不要なメソッド呼び出しの防止など、実務でよく使う条件式を安全に書けるようになります。

この記事では、VB.NETのOrElseとC#の||の対応関係、||と|の違い、短絡評価の具体例、さらにExpression.OrElseとの違いまでわかりやすく解説します。

1. C#にOrElseはある？結論は「||」を使う

1-1. C#にはVB.NETのOrElseキーワードは存在しない

C#には、VB.NETのようなOrElseキーワードは存在しません。

そのため、C#で次のように書くとコンパイルエラーになります。

C#
if (isAdmin OrElse isOwner)
{
    Console.WriteLine("アクセスできます");
}

C#ではOrElseではなく、論理OR演算子の||を使います。

C#
if (isAdmin || isOwner)
{
    Console.WriteLine("アクセスできます");
}

C#で「または」を表す条件式を書きたい場合は、基本的に||を使う、と覚えておけば問題ありません。

1-2. VB.NETのOrElseに相当するC#の演算子は「||」

VB.NETのOrElseに相当するC#の演算子は、**||**です。

VB.NETでは次のように書きます。

VB.NET
If isAdmin OrElse isOwner Then
    Console.WriteLine("アクセスできます")
End If

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

C#
if (isAdmin || isOwner)
{
    Console.WriteLine("アクセスできます");
}

どちらも意味は同じです。

「isAdminが真、またはisOwnerが真なら処理を実行する」という条件になります。

さらに重要なのは、OrElseも||も短絡評価を行う点です。左辺が真であれば、OR条件全体の結果はすでに真だと決まるため、右辺は評価されません。

1-3. まず覚える対応表：OrElse＝||、AndAlso＝&&

VB.NETとC#の論理演算子を対応させると、まず覚えるべきなのは次の2つです。

VB.NETC#意味
OrElse`
AndAlso&&短絡評価するAND

VB.NETのOrElseはC#の||、VB.NETのAndAlsoはC#の&&に対応します。

たとえば、VB.NETの次のコードは、

VB.NET
If user IsNot Nothing AndAlso user.IsActive Then
    Console.WriteLine("有効なユーザーです")
End If

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

C#
if (user != null && user.IsActive)
{
    Console.WriteLine("有効なユーザーです");
}

OrElseとAndAlsoは、VB.NETで安全な条件分岐を書くためによく使われる演算子です。C#では、それぞれ||と&&を使います。

1-4. 「C# OrElse」と検索する人が混乱しやすい理由

「C# OrElse」と検索する人が混乱しやすい理由は、主に次の3つです。

1つ目は、VB.NETではOrElseという英単語に近いキーワードを使うのに対して、C#では||という記号を使う点です。見た目が大きく違うため、同じ意味だと気づきにくいことがあります。

2つ目は、C#にも|というORに見える演算子がある点です。||と|は似ていますが、条件式における動作は異なります。特に短絡評価の有無が重要です。

3つ目は、C#にはExpression.OrElseというAPIも存在する点です。これは通常のif文で使う演算子ではなく、式ツリーを組み立てるときに使うメソッドです。初心者が普段のC#コードでExpression.OrElseを使う必要はほとんどありません。

そのため、まずは次のように整理しておくと理解しやすくなります。

C#
// VB.NETの OrElse に相当
if (condition1 || condition2)
{
    // 条件1または条件2がtrueなら実行
}

2. OrElseとは何か：VB.NETにおける短絡評価のOR演算子

2-1. OrElseは条件式のORを短絡評価する演算子

VB.NETのOrElseは、条件式で使うOR演算子です。

OR演算とは、「どちらか一方でも真なら全体が真になる」演算です。

VB.NET
If age < 20 OrElse hasCoupon Then
    Console.WriteLine("割引対象です")
End If

この例では、age < 20が真、またはhasCouponが真なら、割引対象として処理されます。

OrElseの重要な特徴は、単なるORではなく、短絡評価するORであることです。短絡評価とは、結果が確定した時点で残りの条件を評価しない仕組みです。

2-2. 左辺がTrueなら右辺は評価されない

OrElseでは、左辺がTrueの場合、右辺は評価されません。

VB.NET
If isAdmin OrElse CheckPermission() Then
    Console.WriteLine("アクセス許可")
End If

このコードでisAdminがTrueの場合、条件全体は必ずTrueになります。つまり、CheckPermission()を呼び出す必要がありません。

そのため、CheckPermission()は実行されません。

これはパフォーマンス面だけでなく、安全性の面でも重要です。右辺にnull参照が起きる可能性のある処理や、実行コストの高い処理がある場合、短絡評価によって不要な実行を避けられます。

2-3. VB.NETのOrとの違い

VB.NETにはOrElseのほかに、Orもあります。

どちらもOR演算ですが、評価方法が異なります。

VB.NET
If condition1 OrElse condition2 Then
    ' condition1がTrueならcondition2は評価されない
End If
VB.NET
If condition1 Or condition2 Then
    ' condition1がTrueでもcondition2は評価される
End If

OrElseは短絡評価します。一方、Orは基本的に両辺を評価します。

たとえば次のようなコードでは、OrElseを使うことで安全に条件判定できます。

VB.NET
If user Is Nothing OrElse user.Name = "" Then
    Console.WriteLine("ユーザー情報が不正です")
End If

user Is NothingがTrueなら、user.Nameは評価されません。そのため、NullReferenceExceptionを防げます。

もしここでOrを使うと、userがNothingであってもuser.Nameを評価しようとして、例外が発生する可能性があります。

2-4. OrElseを使う典型的な場面

OrElseは、次のような場面でよく使われます。

VB.NET
If user Is Nothing OrElse user.IsDeleted Then
    Console.WriteLine("処理できないユーザーです")
End If

このように、左側で安全確認を行い、右側で詳細な条件を確認するケースです。

ほかにも、次のような場面で使われます。

VB.NET
If count = 0 OrElse total / count < 10 Then
    Console.WriteLine("条件に一致しました")
End If

count = 0がTrueなら、右辺のtotal / countは評価されないため、ゼロ除算を避けられます。

OrElseは、単に「または」を表すだけでなく、危険な評価をスキップするための演算子としても重要です。

3. C#の「||」とは：OrElseと同じ短絡評価を行う論理OR

3-1. C#の||は条件式で使う論理OR演算子

C#の||は、条件式で使う論理OR演算子です。

C#
if (isAdmin || isOwner)
{
    Console.WriteLine("アクセスできます");
}

このコードは、isAdminまたはisOwnerのどちらかがtrueなら、if文の中を実行します。

VB.NETのOrElseに慣れている人は、C#では次のように置き換えると考えるとわかりやすいです。

VB.NET
' VB.NET
If isAdmin OrElse isOwner Then
End If
C#
// C#
if (isAdmin || isOwner)
{
}

つまり、C#におけるOrElse相当の書き方が||です。

3-2. 左辺がtrueなら右辺は実行されない

C#の||も、VB.NETのOrElseと同じく短絡評価を行います。

C#
if (isAdmin || CheckPermission())
{
    Console.WriteLine("アクセスできます");
}

このコードでisAdminがtrueの場合、CheckPermission()は呼び出されません。

なぜなら、OR条件では左辺がtrueの時点で、全体の結果がtrueだと確定するからです。

次のコードで確認できます。

C#
bool IsAdmin()
{
    Console.WriteLine("IsAdminが呼ばれました");
    return true;
}

bool CheckPermission()
{
    Console.WriteLine("CheckPermissionが呼ばれました");
    return false;
}

if (IsAdmin() || CheckPermission())
{
    Console.WriteLine("条件に一致しました");
}

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

IsAdminが呼ばれました
条件に一致しました

CheckPermission()は実行されていません。

3-3. nullチェックやゼロ除算回避で役立つ理由

||の短絡評価は、nullチェックで特に役立ちます。

C#
if (user == null || user.IsDeleted)
{
    Console.WriteLine("処理できないユーザーです");
}

このコードでは、user == nullがtrueの場合、右辺のuser.IsDeletedは評価されません。

もし右辺が評価されると、userがnullのときにNullReferenceExceptionが発生します。しかし、||は左辺がtrueなら右辺を評価しないため、安全に書けます。

ゼロ除算の回避にも使えます。

C#
if (count == 0 || total / count < 10)
{
    Console.WriteLine("条件に一致しました");
}

count == 0がtrueなら、total / countは評価されません。そのため、ゼロ除算を防げます。

このように、||は単なるOR条件ではなく、右辺を実行してよいかどうかを左辺で制御するためにも使われます。

3-4. if文での基本的な使い方

C#のif文で||を使う基本形は次のとおりです。

C#
if (条件1 || 条件2)
{
    // 条件1または条件2がtrueなら実行される
}

具体例を見てみましょう。

C#
int age = 17;
bool hasCoupon = false;

if (age < 20 || hasCoupon)
{
    Console.WriteLine("割引対象です");
}

この例では、age < 20がtrueなので、hasCouponがfalseでも条件全体はtrueになります。

複数の条件を組み合わせることもできます。

C#
if (role == "Admin" || role == "Manager" || role == "Owner")
{
    Console.WriteLine("管理画面にアクセスできます");
}

ただし、条件が長くなりすぎる場合は、後述するように変数やメソッドに分けると読みやすくなります。

4. C#の「||」と「|」の違い

4-1. ||は短絡評価、|は両辺を評価する

C#には||と|があります。

どちらもORのように見えますが、条件式で使う場合の大きな違いは、短絡評価するかどうかです。

C#
// 短絡評価する
if (condition1 || condition2)
{
}
C#
// 両辺を評価する
if (condition1 | condition2)
{
}

||は左辺がtrueなら右辺を評価しません。

一方、|は左辺がtrueであっても右辺を評価します。

4-2. bool型における||と|の違い

bool型に対して||と|を使った場合、最終的な真偽値だけを見ると同じ結果になることがあります。

C#
bool a = true;
bool b = false;

Console.WriteLine(a || b); // True
Console.WriteLine(a | b);  // True

この場合、どちらも結果はtrueです。

しかし、右辺にメソッド呼び出しがある場合は違いが出ます。

C#
bool Left()
{
    Console.WriteLine("Left");
    return true;
}

bool Right()
{
    Console.WriteLine("Right");
    return false;
}

Console.WriteLine(Left() || Right());

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

Left
True

Right()は実行されません。

一方、|を使うと次のようになります。

C#
Console.WriteLine(Left() | Right());

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

Left
Right
True

|では右辺も実行されます。

4-3. |はビット演算子としても使われる

|は、bool型に対して使うと論理ORとして動作しますが、整数型に対して使うとビットOR演算子として動作します。

C#
int a = 0b_0101; // 5
int b = 0b_0011; // 3

int result = a | b;

Console.WriteLine(result); // 7

ビットで見ると、次のような演算です。

0101
0011
----
0111

このように、|はビット演算でも使われるため、条件式で||の代わりに何となく使うと意図が伝わりにくくなります。

条件分岐で「または」を表したい場合は、基本的に||を使うべきです。

4-4. 条件式では基本的に||を使うべき理由

条件式では、基本的に||を使うのがおすすめです。

理由は、短絡評価によって不要な処理を避けられるからです。

C#
if (user == null || user.IsDeleted)
{
    Console.WriteLine("処理できません");
}

このコードは安全です。

しかし、|を使うと危険です。

C#
if (user == null | user.IsDeleted)
{
    Console.WriteLine("処理できません");
}

この場合、user == nullがtrueでも、右辺のuser.IsDeletedが評価されます。その結果、userがnullならNullReferenceExceptionが発生します。

条件式で|を使う明確な理由がない限り、||を使うのが基本です。

4-5. 副作用のあるメソッド呼び出しで起こる違い

||と|の違いは、副作用のあるメソッド呼び出しで特に重要です。

副作用とは、メソッドが値を返すだけでなく、ログ出力、DB更新、カウンター加算、ファイル書き込みなど、外部の状態を変更することです。

C#
bool IsValid()
{
    Console.WriteLine("IsValid");
    return true;
}

bool SaveLog()
{
    Console.WriteLine("SaveLog");
    return true;
}

if (IsValid() || SaveLog())
{
    Console.WriteLine("OK");
}

この場合、IsValid()がtrueを返すため、SaveLog()は実行されません。

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

IsValid
OK

一方、|を使うと次のようになります。

C#
if (IsValid() | SaveLog())
{
    Console.WriteLine("OK");
}

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

IsValid
SaveLog
OK

右辺のSaveLog()が必ず実行されます。

このように、条件式の中に副作用のある処理を書くと、||と|の違いによって動作が変わります。バグの原因になりやすいため、条件式の中ではできるだけ副作用のある処理を避けるのが安全です。

5. VB.NETとC#の論理演算子対応表

5-1. VB.NETのOrElseとC#の||

VB.NETのOrElseは、C#の||に対応します。

VB.NETC#説明
OrElse`

VB.NETでは次のように書きます。

VB.NET
If user Is Nothing OrElse user.IsDeleted Then
    Console.WriteLine("処理できません")
End If

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

C#
if (user == null || user.IsDeleted)
{
    Console.WriteLine("処理できません");
}

左辺が真なら右辺は評価されません。

5-2. VB.NETのAndAlsoとC#の&&

VB.NETのAndAlsoは、C#の&&に対応します。

VB.NETC#説明
AndAlso&&短絡評価するAND

VB.NETでは次のように書きます。

VB.NET
If user IsNot Nothing AndAlso user.IsActive Then
    Console.WriteLine("有効なユーザーです")
End If

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

C#
if (user != null && user.IsActive)
{
    Console.WriteLine("有効なユーザーです");
}

&&は、左辺がfalseなら右辺を評価しません。

AND条件では、左辺がfalseの時点で全体がfalseだと確定するからです。

5-3. VB.NETのOrとC#の|

VB.NETのOrは、C#の|に対応します。

VB.NETC#説明
Or``

VB.NETのOrは、条件式で使うと両辺を評価するORとして使われます。また、ビット演算にも使われます。

C#の|も同様に、bool型に対しては両辺を評価するOR、整数型に対してはビットORとして使われます。

C#
if (condition1 | condition2)
{
    Console.WriteLine("条件に一致しました");
}

ただし、条件式では短絡評価が必要なことが多いため、通常は||を使います。

5-4. VB.NETのAndとC#の&

VB.NETのAndは、C#の&に対応します。

VB.NETC#説明
And&両辺を評価するAND、またはビットAND

C#の&は、bool型に対して使うと両辺を評価するANDとして動作します。

C#
if (condition1 & condition2)
{
    Console.WriteLine("両方trueです");
}

&&との違いは、左辺がfalseでも右辺が評価される点です。

また、整数型に対して使うとビットANDになります。

C#
int a = 0b_0101;
int b = 0b_0011;

Console.WriteLine(a & b); // 1

5-5. 移行時に間違えやすい演算子の対応

VB.NETからC#へ移行するときは、次の対応を覚えておくと便利です。

VB.NETC#短絡評価主な用途
OrElse``
AndAlso&&あり条件式のAND
Or``なし
And&なしboolのAND、ビットAND
Not!-否定

特に間違えやすいのは、OrElseを|に置き換えてしまうことです。

VB.NETのOrElseに対応するのは、C#の|ではなく||です。

C#
// OrElse相当
if (condition1 || condition2)
{
}

|を使うと右辺も評価されるため、例外や意図しないメソッド実行につながる可能性があります。

6. 短絡評価をコード例で理解する

6-1. nullチェックでNullReferenceExceptionを防ぐ例

短絡評価が最もよく使われる例の1つが、nullチェックです。

C#
User? user = null;

if (user == null || user.Name == "")
{
    Console.WriteLine("ユーザー名がありません");
}

このコードでは、user == nullがtrueです。そのため、右辺のuser.Name == ""は評価されません。

もし右辺が評価されると、userがnullなのでNullReferenceExceptionが発生します。

||を使うことで、次のような流れになります。

user == null を評価
true なので条件全体は true
右辺の user.Name == "" は評価しない
if文の中を実行

これが短絡評価です。

6-2. ゼロ除算を避ける例

||はゼロ除算を避けるときにも使えます。

C#
int total = 100;
int count = 0;

if (count == 0 || total / count > 10)
{
    Console.WriteLine("条件に一致しました");
}

count == 0がtrueなので、total / count > 10は評価されません。

そのため、ゼロ除算の例外を防げます。

ただし、このコードは条件の意味が少し読み取りにくい場合があります。実務では、次のように分けて書いたほうがわかりやすいこともあります。

C#
if (count == 0)
{
    Console.WriteLine("件数が0です");
}
else if (total / count > 10)
{
    Console.WriteLine("平均が10を超えています");
}

短絡評価は便利ですが、条件式が複雑になりすぎる場合は、if文を分けることも大切です。

6-3. メソッド呼び出しがスキップされる例

||では、左辺がtrueなら右辺のメソッド呼び出しはスキップされます。

C#
bool IsCached()
{
    Console.WriteLine("キャッシュを確認しました");
    return true;
}

bool LoadFromDatabase()
{
    Console.WriteLine("データベースから読み込みました");
    return true;
}

if (IsCached() || LoadFromDatabase())
{
    Console.WriteLine("データを取得できました");
}

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

キャッシュを確認しました
データを取得できました

IsCached()がtrueを返しているため、LoadFromDatabase()は実行されません。

このように、||は不要な処理を避けるためにも使えます。

6-4. ||と|で実行結果が変わる例

||と|の違いを、同じコードで比較してみましょう。

まずは||です。

C#
bool Left()
{
    Console.WriteLine("Left");
    return true;
}

bool Right()
{
    Console.WriteLine("Right");
    return false;
}

if (Left() || Right())
{
    Console.WriteLine("OK");
}

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

Left
OK

右辺のRight()は実行されません。

次に|を使います。

C#
if (Left() | Right())
{
    Console.WriteLine("OK");
}

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

Left
Right
OK

|では、左辺がtrueでも右辺が評価されます。

この違いは、右辺に例外が起きる可能性のある処理や、データ更新のような副作用を持つ処理がある場合に大きな問題になります。

6-5. デバッグ時に確認すべき評価順序

||を使った条件式をデバッグするときは、評価順序を意識することが重要です。

C#では、||の左辺から右辺へ順番に評価されます。

C#
if (A() || B() || C())
{
    Console.WriteLine("条件に一致しました");
}

この場合、評価順序は次のとおりです。

A()を評価
A()がtrueならB()とC()は評価しない
A()がfalseならB()を評価
B()がtrueならC()は評価しない
B()がfalseならC()を評価

たとえば次のコードを見てみます。

C#
bool A()
{
    Console.WriteLine("A");
    return false;
}

bool B()
{
    Console.WriteLine("B");
    return true;
}

bool C()
{
    Console.WriteLine("C");
    return true;
}

if (A() || B() || C())
{
    Console.WriteLine("OK");
}

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

A
B
OK

B()がtrueを返した時点で条件全体がtrueになるため、C()は実行されません。

デバッグ時に「なぜこのメソッドが呼ばれないのか」と感じた場合は、||による短絡評価が原因かもしれません。

7. C#でOrElseのように書きたいときの実践パターン

7-1. if文で複数条件をOR判定する

C#でVB.NETのOrElseのように複数条件をOR判定したい場合は、||を使います。

C#
if (status == "Pending" || status == "Retry" || status == "Failed")
{
    Console.WriteLine("再処理の対象です");
}

このコードは、statusがPending、Retry、Failedのいずれかであれば処理を実行します。

条件が少ない場合は、この書き方で十分です。

ただし、条件が増えてきた場合は、配列やリストを使うと読みやすくなります。

C#
var retryStatuses = new[] { "Pending", "Retry", "Failed" };

if (retryStatuses.Contains(status))
{
    Console.WriteLine("再処理の対象です");
}

単純なOR条件なら||、同じ項目との比較がたくさん並ぶ場合はContainsを使うと整理しやすくなります。

7-2. null条件演算子やnull合体演算子と組み合わせる

C#では、||だけでなく、null条件演算子?.やnull合体演算子??と組み合わせて、より簡潔に書ける場合があります。

たとえば、次のような条件を考えます。

C#
if (user == null || user.Name == null || user.Name == "")
{
    Console.WriteLine("名前がありません");
}

この場合、string.IsNullOrEmptyを使うとわかりやすくなります。

C#
if (string.IsNullOrEmpty(user?.Name))
{
    Console.WriteLine("名前がありません");
}

user?.Nameは、userがnullならnullを返します。そのため、user.Nameに直接アクセスして例外が起きることを防げます。

null合体演算子??を使う例もあります。

C#
string name = user?.Name ?? "ゲスト";

||は条件分岐で便利ですが、nullを扱う場合は?.や??を使ったほうが読みやすいこともあります。

7-3. LINQのWhere句で||を使う

LINQのWhere句でも、C#の||を使えます。

C#
var users = new List<User>
{
    new User { Name = "Alice", Role = "Admin", IsActive = true },
    new User { Name = "Bob", Role = "User", IsActive = false },
    new User { Name = "Carol", Role = "Manager", IsActive = true }
};

var result = users
    .Where(user => user.Role == "Admin" || user.Role == "Manager")
    .ToList();

このコードは、RoleがAdminまたはManagerのユーザーを抽出します。

さらに条件を組み合わせることもできます。

C#
var result = users
    .Where(user => user.IsActive && (user.Role == "Admin" || user.Role == "Manager"))
    .ToList();

この場合、アクティブなユーザーのうち、RoleがAdminまたはManagerの人だけを抽出します。

&&と||を組み合わせる場合は、意図を明確にするために括弧を使うのがおすすめです。

7-4. 条件が長いときの読みやすい書き方

条件が長くなると、1行で書くと読みにくくなります。

C#
if (user == null || user.IsDeleted || user.IsLocked || user.Role == "Guest" || user.ExpiredAt < DateTime.Now)
{
    Console.WriteLine("ログインできません");
}

このような場合は、改行して整えると読みやすくなります。

C#
if (user == null
    || user.IsDeleted
    || user.IsLocked
    || user.Role == "Guest"
    || user.ExpiredAt < DateTime.Now)
{
    Console.WriteLine("ログインできません");
}

ただし、このコードには注意点があります。

user == nullがtrueなら右辺は評価されないため安全ですが、見た目上はuser.IsDeletedなどが続いているため、読み手が少し注意する必要があります。

より読みやすくするなら、早期returnを使う方法もあります。

C#
if (user == null)
{
    Console.WriteLine("ユーザーが存在しません");
    return;
}

if (user.IsDeleted || user.IsLocked || user.Role == "Guest")
{
    Console.WriteLine("ログインできません");
    return;
}

条件が長いときは、無理に1つのif文にまとめず、意味のある単位で分けると保守しやすくなります。

7-5. メソッド化して条件式を整理する

複雑な条件は、メソッド化するとさらに読みやすくなります。

C#
if (CannotLogin(user))
{
    Console.WriteLine("ログインできません");
}

条件の詳細はメソッド側に隠せます。

C#
bool CannotLogin(User? user)
{
    return user == null
        || user.IsDeleted
        || user.IsLocked
        || user.Role == "Guest"
        || user.ExpiredAt < DateTime.Now;
}

このように書くと、if文を読む人は「ログインできない条件かどうか」をすぐに理解できます。

条件式が長い場合、||を何度も並べるよりも、意味のあるメソッド名を付けたほうがコードの意図が伝わりやすくなります。

8. Expression.OrElseとの違いに注意

8-1. System.Linq.Expressions.Expression.OrElseとは

C#には、System.Linq.Expressions.Expression.OrElseというメソッドがあります。

名前にOrElseが含まれているため、「C#にもOrElseがあるのでは？」と思うかもしれません。

しかし、これはVB.NETのOrElseキーワードや、C#の通常の||演算子とは使う場面が異なります。

Expression.OrElseは、式ツリーを作るためのAPIです。

たとえば、動的に条件式を組み立てたい場合に使われます。

C#
using System;
using System.Linq.Expressions;

Expression left = Expression.Constant(true);
Expression right = Expression.Constant(false);

Expression expression = Expression.OrElse(left, right);

Console.WriteLine(expression);

これは通常のif文で条件分岐をするための書き方ではありません。

8-2. 通常のC#コードで使う||との違い

通常のC#コードでは、OR条件を書きたいときに||を使います。

C#
if (isAdmin || isOwner)
{
    Console.WriteLine("アクセスできます");
}

一方、Expression.OrElseは、条件式そのものをオブジェクトとして組み立てるときに使います。

C#
Expression<Func<User, bool>> condition =
    user => user.Role == "Admin" || user.Role == "Manager";

このような式ツリーを動的に組み立てる場合に、Expression.OrElseが登場します。

つまり、整理すると次のようになります。

書き方用途
`
Expression.OrElse式ツリーでOR条件を表現する

初心者がif文を書くときに必要なのは、基本的に||です。

8-3. LINQ式ツリーや動的クエリで使われる場面

Expression.OrElseは、主にLINQ式ツリーや動的クエリで使われます。

たとえば、検索条件を画面入力に応じて動的に追加するようなケースです。

C#
ParameterExpression param = Expression.Parameter(typeof(User), "user");

Expression roleAdmin = Expression.Equal(
    Expression.Property(param, "Role"),
    Expression.Constant("Admin")
);

Expression roleManager = Expression.Equal(
    Expression.Property(param, "Role"),
    Expression.Constant("Manager")
);

Expression orCondition = Expression.OrElse(roleAdmin, roleManager);

var lambda = Expression.Lambda<Func<User, bool>>(orCondition, param);

このコードでは、次のような条件を式ツリーとして組み立てています。

C#
user => user.Role == "Admin" || user.Role == "Manager"

このような書き方は、通常のアプリケーションコードではあまり頻繁には使いません。ORM、検索機能、動的フィルター、クエリビルダーなどを作るときに登場します。

8-4. 初心者が混同しなくてよいケース

C#を学び始めた段階では、Expression.OrElseを無理に覚える必要はありません。

次のように理解しておけば十分です。

C#
// 普通の条件式ではこれを使う
if (condition1 || condition2)
{
}

Expression.OrElseは、普通のif文で使うものではありません。

「C# OrElse」と調べたときにExpression.OrElseが出てきても、通常の条件分岐で使いたいなら||を使えば問題ありません。

9. よくあるエラーと勘違い

9-1. C#でOrElseと書くとコンパイルエラーになる

C#ではOrElseというキーワードは使えません。

C#
if (a OrElse b)
{
}

このように書くとコンパイルエラーになります。

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

C#
if (a || b)
{
}

VB.NETのOrElseをC#に変換するときは、必ず||に置き換えましょう。

9-2. ||と&&を逆に覚えてしまう

C#では、||がOR、&&がANDです。

演算子読み方意味
``
&&AND両方trueならtrue

たとえば、次のコードは「管理者または所有者ならアクセス可能」という意味です。

C#
if (isAdmin || isOwner)
{
    Console.WriteLine("アクセスできます");
}

一方、次のコードは「管理者かつ所有者ならアクセス可能」という意味になります。

C#
if (isAdmin && isOwner)
{
    Console.WriteLine("アクセスできます");
}

||と&&を逆にすると、条件の意味が大きく変わるため注意が必要です。

9-3. |を使って意図せず右辺が実行される

C#で||の代わりに|を使うと、右辺が必ず評価されます。

C#
if (user == null | user.IsDeleted)
{
    Console.WriteLine("処理できません");
}

このコードは危険です。

user == nullがtrueでも、user.IsDeletedが評価されます。そのため、userがnullの場合に例外が発生します。

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

C#
if (user == null || user.IsDeleted)
{
    Console.WriteLine("処理できません");
}

条件式では、明確な理由がない限り||を使いましょう。

9-4. bool以外の型で||が使えないケース

C#の||は、基本的にbool型の条件式で使います。

そのため、整数に対して次のように書くことはできません。

C#
int a = 1;
int b = 2;

if (a || b)
{
}

これはコンパイルエラーになります。

整数の値を条件として判定したい場合は、比較式を書く必要があります。

C#
if (a != 0 || b != 0)
{
    Console.WriteLine("どちらかは0ではありません");
}

また、ビット演算をしたい場合は|を使います。

C#
int result = a | b;

||は論理OR、|はビットORまたは両辺評価のOR、と区別して覚えましょう。

9-5. 条件式に副作用を書くとバグの原因になる

||では、左辺がtrueになると右辺が実行されません。

そのため、右辺に「必ず実行されるべき処理」を書くとバグの原因になります。

C#
if (IsValid() || SaveLog())
{
    Console.WriteLine("処理を続行します");
}

このコードでは、IsValid()がtrueを返すと、SaveLog()は実行されません。

もしログ保存を必ず行いたいなら、条件式の外に出すべきです。

C#
bool isValid = IsValid();
SaveLog();

if (isValid)
{
    Console.WriteLine("処理を続行します");
}

条件式の中には、できるだけ「判定」だけを書くのが理想です。データ更新、ログ保存、メール送信などの副作用がある処理は、条件式とは分けて書くと安全です。

まとめ

C#には、VB.NETのOrElseキーワードは存在しません。VB.NETのOrElseに相当するC#の演算子は、||です。

C#
if (condition1 || condition2)
{
    // condition1 または condition2 が true なら実行
}

||は短絡評価を行う論理OR演算子です。左辺がtrueなら、右辺は評価されません。

そのため、次のようなコードを安全に書けます。

C#
if (user == null || user.IsDeleted)
{
    Console.WriteLine("処理できません");
}

user == nullがtrueなら、user.IsDeletedは評価されないため、NullReferenceExceptionを防げます。

一方、C#の|は||とは異なり、bool型に対して使うと両辺を評価します。また、整数型ではビットOR演算子として使われます。

C#
// 短絡評価するOR
if (a || b)
{
}

// 両辺を評価するOR
if (a | b)
{
}

VB.NETからC#へ移行する場合は、次の対応を覚えておきましょう。

VB.NETC#意味
OrElse`
AndAlso&&短絡評価するAND
Or``
And&両辺を評価するAND、ビットAND

また、Expression.OrElseというAPIもありますが、これは通常のif文で使うものではなく、式ツリーや動的クエリを組み立てるときに使うものです。

普段のC#コードで「OrElseのように書きたい」と思った場合は、基本的に||を使えば問題ありません。