C#のAND条件を完全解説｜&&・&・LINQの使い方と違いが初心者にもわかる

はじめに

C#で複数の条件を同時に判定したいときに使うのが、AND条件です。検索キーワードとして「c# and」と調べる人の多くは、「C#ではandと書けるのか」「&&と&は何が違うのか」「if文やLINQで複数条件をどう書けばよいのか」といった疑問を持っているはずです。

C#のAND条件では、基本的に&&演算子を使います。たとえば「年齢が20歳以上、かつ会員である」という条件は、次のように書けます。

C#
if (age >= 20 && isMember)
{
    Console.WriteLine("条件を満たしています");
}

一方で、C#には&を使ったAND条件や、LINQのWhereで複数条件を指定する方法もあります。さらに、C# 9.0以降のパターンマッチングではandパターンも登場しているため、初心者にとっては少し混乱しやすい部分です。

この記事では、C#のAND条件について、&&・&・LINQでの使い方と違いを初心者にもわかるように解説します。if文の基本から実務でよく使う書き方、よくあるエラー、読みやすく書くコツまで順番に見ていきましょう。

1. C#のAND条件とは？検索ユーザーがまず知りたい基本

1-1. AND条件は「複数の条件をすべて満たす」判定

AND条件とは、複数の条件がすべて成り立つ場合にだけ、全体としてtrueになる条件のことです。

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

C#
int age = 25;
bool hasTicket = true;

if (age >= 18 && hasTicket)
{
    Console.WriteLine("入場できます");
}

このコードでは、次の2つの条件を確認しています。

C#
age >= 18
hasTicket

age >= 18は「年齢が18歳以上であること」、hasTicketは「チケットを持っていること」を意味します。&&でつながれているため、両方の条件がtrueのときだけ、if文の中身が実行されます。

つまり、AND条件は次のような考え方です。

C#
条件A && 条件B

条件Aと条件Bの両方がtrueなら、全体もtrueになります。どちらか一方でもfalseなら、全体はfalseです。

1-2. C#でAND条件を書く主な方法は「&&」「&」「LINQ」

C#でAND条件を書く方法は、主に次の3つです。

C#
// 1. && を使う
if (age >= 20 && isMember)
{
}

// 2. & を使う
if (age >= 20 & isMember)
{
}

// 3. LINQのWhereで使う
var result = users.Where(user => user.Age >= 20 && user.IsActive);

最もよく使われるのは&&です。通常のif文で複数条件を判定する場合は、基本的に&&を使うと考えて問題ありません。

&もbool型に対して使うとAND条件として動作しますが、&&とは評価のされ方が異なります。初心者のうちは、特別な理由がない限り&&を使うのがおすすめです。

LINQでは、リストや配列などのデータから条件に合う要素を絞り込むときにAND条件を使います。

C#
var adults = users.Where(user => user.Age >= 20 && user.IsActive);

この例では、「20歳以上、かつ有効なユーザー」だけを取り出しています。

1-3. 初心者が混同しやすい「AND」と「OR」の違い

AND条件と一緒に覚えておきたいのがOR条件です。

AND条件は「すべて満たす」です。

C#
if (age >= 20 && isMember)
{
    Console.WriteLine("20歳以上かつ会員です");
}

OR条件は「どれか1つでも満たす」です。

C#
if (age >= 20 || isMember)
{
    Console.WriteLine("20歳以上、または会員です");
}

&&はAND、||はORです。

次のように考えるとわかりやすいです。

C#
// AND条件
// 年齢が20歳以上 かつ 会員である
age >= 20 && isMember

// OR条件
// 年齢が20歳以上 または 会員である
age >= 20 || isMember

AND条件では、片方だけ条件を満たしていても不十分です。すべての条件を満たした場合にだけtrueになります。

2. C#で最もよく使うAND条件「&&」の基本

2-1. &&演算子の書き方と基本構文

C#でAND条件を表す基本的な演算子は&&です。読み方は「論理AND」や「条件AND」と呼ばれます。

基本構文は次のとおりです。

C#
条件式1 && 条件式2

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

C#
int score = 85;
bool submitted = true;

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

このコードでは、「点数が80点以上」かつ「提出済み」である場合に、合格ですと表示されます。

&&の左側と右側には、最終的にbool型になる式を書きます。つまり、trueまたはfalseになる式です。

C#
score >= 80      // true または false
submitted        // true または false

この2つを&&でつなぐことで、「両方trueかどうか」を判定できます。

2-2. if文で複数条件を判定するサンプルコード

&&はif文で非常によく使われます。次の例では、ユーザー名とパスワードの両方が一致するかどうかを判定しています。

C#
string inputUserName = "taro";
string inputPassword = "pass123";

string correctUserName = "taro";
string correctPassword = "pass123";

if (inputUserName == correctUserName && inputPassword == correctPassword)
{
    Console.WriteLine("ログイン成功");
}
else
{
    Console.WriteLine("ログイン失敗");
}

この場合、ユーザー名とパスワードの両方が一致したときだけログイン成功になります。

ユーザー名だけ合っていても、パスワードが違えば失敗です。逆に、パスワードだけ合っていても、ユーザー名が違えば失敗です。

このように、AND条件は「両方必要」「すべて必要」という判定に向いています。

2-3. bool型の変数を使ったAND条件の書き方

条件式をそのままif文に書くこともできますが、bool型の変数に分けると読みやすくなる場合があります。

C#
int age = 22;
bool hasLicense = true;

bool isAdult = age >= 18;
bool canDrive = hasLicense;

if (isAdult && canDrive)
{
    Console.WriteLine("運転できます");
}

このコードでは、age >= 18という条件をisAdultという変数に入れています。hasLicenseもcanDriveという意味のある名前にしています。

条件が短い場合は直接書いても問題ありません。

C#
if (age >= 18 && hasLicense)
{
    Console.WriteLine("運転できます");
}

ただし、条件が複雑になる場合は、bool変数に分けることでコードの意図が伝わりやすくなります。

C#
bool isAdult = age >= 18;
bool hasValidLicense = license != null && license.IsValid;

if (isAdult && hasValidLicense)
{
    Console.WriteLine("運転できます");
}

2-4. 3つ以上の条件を&&でつなぐ方法

AND条件は2つだけでなく、3つ以上つなぐこともできます。

C#
if (age >= 20 && isMember && hasCoupon)
{
    Console.WriteLine("割引対象です");
}

この例では、次の3つの条件をすべて満たす必要があります。

C#
age >= 20
isMember
hasCoupon

3つ以上の条件でも、すべてがtrueなら全体がtrueになります。1つでもfalseがあれば、全体はfalseです。

ただし、条件が増えるとコードが読みにくくなりやすいので注意が必要です。

C#
if (age >= 20 && isMember && hasCoupon && totalPrice >= 5000 && !isExpired)
{
    Console.WriteLine("割引できます");
}

このような場合は、意味のあるbool変数に分けると読みやすくなります。

C#
bool isEligibleAge = age >= 20;
bool canUseCoupon = isMember && hasCoupon && !isExpired;
bool meetsMinimumPrice = totalPrice >= 5000;

if (isEligibleAge && canUseCoupon && meetsMinimumPrice)
{
    Console.WriteLine("割引できます");
}

3. &&と&の違いを初心者向けに解説

3-1. &&は短絡評価される論理AND

C#では、&&と&のどちらもbool型に対してAND条件として使えます。しかし、動作には大きな違いがあります。

&&は短絡評価される論理ANDです。

短絡評価とは、左側の条件だけで結果が決まる場合、右側の条件を評価しない仕組みのことです。

AND条件では、左側がfalseなら、右側がtrueでもfalseでも、全体の結果は必ずfalseになります。そのため、&&では左側がfalseだった時点で右側を評価しません。

C#
bool result = false && SomeMethod();

この場合、左側がfalseなので、SomeMethod()は呼び出されません。

この性質は、nullチェックなどで非常に重要です。

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

user != nullがfalseの場合、user.IsActiveは評価されません。そのため、null参照例外を防げます。

3-2. &は両方の条件を必ず評価する論理AND

一方、&をbool型に対して使うと、両方の条件を必ず評価します。

C#
bool result = false & SomeMethod();

この場合、左側がfalseでもSomeMethod()は呼び出されます。最終的な結果はfalseですが、右側の処理は実行される点が&&と異なります。

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

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

bool result1 = false && Check();
bool result2 = false & Check();

false && Check()では、Check()は呼ばれません。

false & Check()では、左側がfalseでもCheck()が呼ばれます。

このように、&は結果だけを見るとAND条件として動作しますが、評価のされ方が&&とは異なります。

3-3. &&と&で結果が変わるケース

単純な条件だけであれば、&&と&の最終的な真偽値は同じになることが多いです。

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

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

しかし、右側にメソッド呼び出しやプロパティアクセスがある場合、動作が変わることがあります。

C#
User user = null;

if (user != null && user.IsActive)
{
    Console.WriteLine("有効です");
}

このコードは安全です。user != nullがfalseなので、user.IsActiveは評価されません。

しかし、次のように&を使うと問題が起きます。

C#
User user = null;

if (user != null & user.IsActive)
{
    Console.WriteLine("有効です");
}

&は両方の条件を必ず評価するため、userがnullでもuser.IsActiveを見に行きます。その結果、null参照例外が発生します。

また、右側に副作用のある処理を書いた場合も違いが出ます。

C#
int count = 0;

bool Increment()
{
    count++;
    return true;
}

bool result1 = false && Increment();
Console.WriteLine(count); // 0

bool result2 = false & Increment();
Console.WriteLine(count); // 1

&&ではIncrement()が呼ばれないためcountは増えません。&ではIncrement()が呼ばれるためcountが増えます。

3-4. 基本的には&&を使うべき理由

C#でAND条件を書く場合、基本的には&&を使うべきです。

理由は、&&のほうが一般的で、意図が伝わりやすく、不要な処理を避けられるからです。また、nullチェックのように、左側の条件で安全性を確認してから右側を評価したい場面でも役立ちます。

C#
if (user != null && user.IsActive)
{
    Console.WriteLine("処理を実行します");
}

この書き方はC#で非常によく使われます。

&をbool型の条件式で使う場面は限られます。右側の条件も必ず評価したい明確な理由がある場合にのみ使うとよいでしょう。

初心者のうちは、次のように覚えておくと安心です。

C#
// 通常のAND条件はこれを使う
&&

// 特別な理由があるときだけ使う
&

4. C#のAND条件で短絡評価を理解する

4-1. 短絡評価とは何か

短絡評価とは、条件式の結果が途中で確定した場合に、残りの条件式を評価しない仕組みです。

AND条件では、1つでもfalseがあれば全体はfalseです。そのため、&&では左側がfalseになった時点で右側を評価しません。

C#
bool result = condition1 && condition2;

このとき、condition1がfalseなら、condition2は評価されません。

逆に、condition1がtrueの場合は、condition2も評価されます。なぜなら、右側を見ないと全体がtrueかfalseか決まらないからです。

C#
bool condition1 = true;
bool condition2 = false;

bool result = condition1 && condition2; // false

短絡評価は、C#のAND条件を理解するうえでとても重要です。特に、nullチェックや重い処理を含む条件式では、短絡評価の有無が安全性やパフォーマンスに関わります。

4-2. nullチェックで&&がよく使われる理由

C#では、オブジェクトがnullの状態でプロパティやメソッドにアクセスすると、null参照例外が発生します。

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

C#
User user = null;

if (user.IsActive)
{
    Console.WriteLine("有効なユーザーです");
}

userがnullなので、user.IsActiveにアクセスした時点で例外が発生します。

そこで、&&を使って先にnullチェックを行います。

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

このコードでは、user != nullがfalseなら、user.IsActiveは評価されません。そのため、安全に判定できます。

このように、&&は「先に安全確認をしてから、次の条件を評価する」ためによく使われます。

4-3. &&を使うとエラーを防げる典型例

&&でエラーを防げる典型例として、文字列のnullチェックがあります。

C#
string name = null;

if (name != null && name.Length > 0)
{
    Console.WriteLine("名前が入力されています");
}

name != nullがfalseの場合、name.Length > 0は評価されません。そのため、例外は発生しません。

ただし、文字列が空でないかを判定するだけなら、実務では次のように書くことも多いです。

C#
if (!string.IsNullOrEmpty(name))
{
    Console.WriteLine("名前が入力されています");
}

配列やリストでも同じ考え方が使えます。

C#
List<string> items = null;

if (items != null && items.Count > 0)
{
    Console.WriteLine("要素があります");
}

itemsがnullでない場合だけ、items.Countを評価します。

また、ネストしたプロパティにアクセスする場合も注意が必要です。

C#
if (user != null && user.Profile != null && user.Profile.IsPublic)
{
    Console.WriteLine("公開プロフィールです");
}

このように、左から順番に安全性を確認していくことで、null参照例外を防げます。

4-4. 副作用のある処理を条件式に書くときの注意点

短絡評価を理解していないと、副作用のある処理で思わぬバグが起きることがあります。

副作用とは、変数の値を変更したり、ログを書いたり、データベースを更新したりするような、結果を返す以外の影響を持つ処理のことです。

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

C#
bool isValid = false;

if (isValid && SaveLog())
{
    Console.WriteLine("処理完了");
}

isValidがfalseの場合、SaveLog()は実行されません。もし「ログは必ず保存したい」と思っていた場合、このコードは意図と違う動作になります。

同じように、カウントアップする処理を条件式に入れると、短絡評価によって実行されない場合があります。

C#
int count = 0;

bool AddCount()
{
    count++;
    return true;
}

if (false && AddCount())
{
}

Console.WriteLine(count); // 0

AddCount()は呼ばれないため、countは増えません。

条件式の中に副作用のある処理を書くと、コードの動きがわかりにくくなります。基本的には、条件判定と処理を分けて書くのがおすすめです。

C#
if (isValid)
{
    SaveLog();
    Console.WriteLine("処理完了");
}

5. LINQでAND条件を使う方法

5-1. Where句でAND条件を書く基本

LINQでAND条件を使う場合も、基本的には&&を使います。

たとえば、ユーザー一覧から「20歳以上、かつ有効なユーザー」を取り出す場合は、次のように書きます。

C#
var result = users.Where(user => user.Age >= 20 && user.IsActive);

Whereの中には、各要素に対する条件式を書きます。この条件式がtrueになった要素だけが結果に残ります。

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

C#
public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
    public bool IsActive { get; set; }
}

このとき、AND条件で絞り込むコードは次のようになります。

C#
List<User> users = new List<User>
{
    new User { Name = "Taro", Age = 25, IsActive = true },
    new User { Name = "Hanako", Age = 17, IsActive = true },
    new User { Name = "Jiro", Age = 30, IsActive = false }
};

var activeAdults = users.Where(user => user.Age >= 20 && user.IsActive);

foreach (var user in activeAdults)
{
    Console.WriteLine(user.Name);
}

この例では、Taroだけが条件に一致します。Hanakoは20歳未満なので除外され、Jiroは有効ユーザーではないため除外されます。

5-2. 複数条件を&&でつなぐLINQのサンプル

LINQでは、3つ以上の条件も&&でつなげます。

C#
var result = products.Where(product =>
    product.Price >= 1000 &&
    product.Price <= 5000 &&
    product.InStock);

この例では、次の条件をすべて満たす商品だけを取り出しています。

C#
価格が1000円以上
価格が5000円以下
在庫がある

商品クラスを使った具体例を見てみましょう。

C#
public class Product
{
    public string Name { get; set; }
    public int Price { get; set; }
    public bool InStock { get; set; }
    public string Category { get; set; }
}

C#
var products = new List<Product>
{
    new Product { Name = "Mouse", Price = 1500, InStock = true, Category = "PC" },
    new Product { Name = "Keyboard", Price = 6000, InStock = true, Category = "PC" },
    new Product { Name = "Notebook", Price = 300, InStock = true, Category = "Stationery" },
    new Product { Name = "Monitor", Price = 12000, InStock = false, Category = "PC" }
};

var result = products.Where(product =>
    product.Category == "PC" &&
    product.Price <= 5000 &&
    product.InStock);

foreach (var product in result)
{
    Console.WriteLine(product.Name);
}

この場合、Mouseだけが条件に一致します。

5-3. Whereを複数回書く方法との違い

LINQでは、1つのWhereの中で&&を使う方法だけでなく、Whereを複数回書く方法もあります。

C#
var result1 = users.Where(user => user.Age >= 20 && user.IsActive);

これは、次のようにも書けます。

C#
var result2 = users
    .Where(user => user.Age >= 20)
    .Where(user => user.IsActive);

どちらも「20歳以上、かつ有効なユーザー」を絞り込むという意味では同じです。

条件が短く、ひとまとまりの判定として読みやすい場合は、1つのWhereにまとめてもよいでしょう。

C#
var result = users.Where(user => user.Age >= 20 && user.IsActive);

一方、条件の意味を分けて読みやすくしたい場合は、Whereを複数回に分けるのも有効です。

C#
var result = users
    .Where(user => user.Age >= 20)
    .Where(user => user.IsActive)
    .Where(user => user.HasPermission);

実務では、条件の複雑さや読みやすさに応じて使い分けます。重要なのは、後から読んだ人が「何を条件に絞り込んでいるのか」を理解しやすい形にすることです。

5-4. LINQでAND条件とOR条件を組み合わせる方法

LINQでも、AND条件とOR条件を組み合わせることがあります。

たとえば、「有効なユーザーで、かつ管理者または20歳以上」という条件は次のように書けます。

C#
var result = users.Where(user =>
    user.IsActive && (user.IsAdmin || user.Age >= 20));

ここで重要なのが括弧です。

C#
user.IsActive && (user.IsAdmin || user.Age >= 20)

この条件は、次の意味になります。

C#
有効なユーザーであり、
さらに
管理者である、または20歳以上である

括弧がないと、演算子の優先順位によって意図しない判定になることがあります。

C#
var result = users.Where(user =>
    user.IsActive && user.IsAdmin || user.Age >= 20);

この場合、次のように解釈されます。

C#
(user.IsActive && user.IsAdmin) || user.Age >= 20

つまり、「有効な管理者」または「20歳以上のユーザー」という意味になり、意図と違う結果になる可能性があります。

AND条件とOR条件を組み合わせるときは、括弧を使って条件のまとまりを明確にしましょう。

6. C#のAND条件でよくあるエラーと注意点

6-1. 「and」と書くとエラーになる理由

C#で通常のAND条件を書くときに、次のようにandと書くとエラーになります。

C#
if (age >= 20 and isMember)
{
}

通常の論理ANDでは、C#はandではなく&&を使います。

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

C#
if (age >= 20 && isMember)
{
}

ただし、C# 9.0以降のパターンマッチングでは、andパターンが使えます。

C#
if (age is >= 20 and <= 65)
{
    Console.WriteLine("20歳以上65歳以下です");
}

このandは、通常のif文で使う&&の代わりではありません。パターンマッチングの中で使う特別な書き方です。

初心者のうちは、まず次のように覚えておくとよいでしょう。

C#
// 通常のAND条件
if (age >= 20 && isMember)

// パターンマッチングでのand
if (age is >= 20 and <= 65)

検索で「c# and」と調べている場合、この違いで混乱しやすいので注意してください。

6-2. =と==を間違えるケース

C#の条件式でよくあるミスが、=と==の間違いです。

=は代入です。

C#
age = 20;

==は等しいかどうかの比較です。

C#
age == 20;

たとえば、次のように書くと意図と違います。

C#
if (isActive = true && age >= 20)
{
}

isActive = trueは比較ではなく代入です。bool型の場合はコンパイルできてしまうこともあるため、バグの原因になります。

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

C#
if (isActive == true && age >= 20)
{
}

ただし、bool型の変数は== trueを書かずに、そのまま使うことが多いです。

C#
if (isActive && age >= 20)
{
}

falseかどうかを判定したい場合は、!を使います。

C#
if (!isDeleted && isActive)
{
    Console.WriteLine("有効なデータです");
}

6-3. 条件式の括弧が足りず意図しない判定になるケース

AND条件とOR条件を組み合わせるときは、括弧が重要です。

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

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

この条件は、次のように解釈されます。

C#
if (isAdmin || (isMember && isActive))
{
}

なぜなら、&&は||より優先順位が高いからです。

もし意図が「管理者または会員で、かつ有効なユーザー」なら、次のように括弧を書く必要があります。

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

この2つは意味が違います。

C#
isAdmin || (isMember && isActive)

これは、「管理者なら有効でなくてもOK、または有効な会員ならOK」という意味になります。

C#
(isAdmin || isMember) && isActive

これは、「管理者または会員であり、さらに有効である」という意味になります。

条件式が少しでも複雑になったら、括弧を使って意図を明確にしましょう。

6-4. null参照例外を防ぐAND条件の書き方

C#でAND条件を書くときは、nullチェックの順番に注意が必要です。

安全な書き方は次のとおりです。

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

危険な書き方は次のとおりです。

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

この場合、最初にuser.IsActiveへアクセスしているため、userがnullだと例外になります。

AND条件では、左から右へ評価されます。そのため、先に安全性を確認する条件を書き、その後にプロパティやメソッドへアクセスする条件を書くのが基本です。

C#
if (order != null && order.Customer != null && order.Customer.IsActive)
{
    Console.WriteLine("有効な顧客の注文です");
}

また、null条件演算子を使って書く方法もあります。

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

この書き方では、userがnullの場合でも例外になりません。

7. 実務でよく使うAND条件の具体例

7-1. 入力値が空でないかチェックする

実務では、フォームやAPIで受け取った入力値をチェックする場面がよくあります。

たとえば、名前とメールアドレスの両方が入力されているかを確認する場合は、次のように書けます。

C#
if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(email))
{
    Console.WriteLine("入力されています");
}

空白だけの文字列も未入力として扱いたい場合は、string.IsNullOrWhiteSpaceを使うのがおすすめです。

C#
if (!string.IsNullOrWhiteSpace(name) && !string.IsNullOrWhiteSpace(email))
{
    Console.WriteLine("有効な入力です");
}

パスワードの長さも一緒にチェックするなら、次のように書けます。

C#
if (!string.IsNullOrWhiteSpace(password) && password.Length >= 8)
{
    Console.WriteLine("パスワードは有効です");
}

この場合、passwordがnullや空白でないことを確認してから、password.Lengthを評価しています。&&の短絡評価により、安全に判定できます。

7-2. 数値の範囲を判定する

数値が一定の範囲内にあるかどうかを判定する場合も、AND条件を使います。

C#
if (score >= 0 && score <= 100)
{
    Console.WriteLine("有効な点数です");
}

この例では、scoreが0以上かつ100以下の場合に有効としています。

年齢の範囲チェックもよくあります。

C#
if (age >= 18 && age <= 65)
{
    Console.WriteLine("対象年齢です");
}

日付の範囲チェックでもAND条件は使えます。

C#
DateTime today = DateTime.Today;
DateTime startDate = new DateTime(2026, 1, 1);
DateTime endDate = new DateTime(2026, 12, 31);

if (today >= startDate && today <= endDate)
{
    Console.WriteLine("キャンペーン期間中です");
}

このように、「下限以上、かつ上限以下」という条件は、AND条件の代表的な使い方です。

7-3. ユーザー権限とログイン状態を判定する

Webアプリケーションや業務システムでは、ログイン状態や権限をAND条件で判定することがよくあります。

C#
if (isLoggedIn && hasPermission)
{
    Console.WriteLine("操作できます");
}

このコードでは、ログインしていて、かつ権限を持っている場合だけ操作できます。

管理者だけが実行できる処理なら、次のように書けます。

C#
if (isLoggedIn && userRole == "Admin")
{
    Console.WriteLine("管理者メニューを表示します");
}

さらに、アカウントが有効かどうかも確認する場合は、条件を追加します。

C#
if (isLoggedIn && userRole == "Admin" && isAccountActive)
{
    Console.WriteLine("管理者操作を実行できます");
}

ただし、条件が長くなってきたら、bool変数に分けたほうが読みやすくなります。

C#
bool isAdmin = userRole == "Admin";
bool canAccessAdminMenu = isLoggedIn && isAdmin && isAccountActive;

if (canAccessAdminMenu)
{
    Console.WriteLine("管理者メニューを表示します");
}

7-4. リストや配列から複数条件でデータを絞り込む

リストや配列から複数条件に合うデータを取り出す場合は、LINQのWhereでAND条件を使います。

C#
var result = employees.Where(employee =>
    employee.Department == "Sales" &&
    employee.Age >= 30);

この例では、「営業部、かつ30歳以上」の社員だけを取り出しています。

在庫管理の例も見てみましょう。

C#
var availableProducts = products.Where(product =>
    product.InStock &&
    product.Price <= 3000 &&
    product.Category == "Book");

このコードでは、「在庫があり、価格が3000円以下で、カテゴリがBookの商品」を絞り込んでいます。

検索条件をユーザーが入力する場合は、条件を動的に追加することもあります。

C#
IEnumerable<Product> query = products;

if (!string.IsNullOrWhiteSpace(category))
{
    query = query.Where(product => product.Category == category);
}

if (maxPrice.HasValue)
{
    query = query.Where(product => product.Price <= maxPrice.Value);
}

if (onlyInStock)
{
    query = query.Where(product => product.InStock);
}

このように、条件が可変の場合はWhereを複数回追加する書き方が便利です。

8. AND条件を読みやすく書くコツ

8-1. 条件が長いときは変数に分ける

AND条件が長くなると、1行で何を判定しているのかわかりにくくなります。

C#
if (user != null && user.IsActive && user.Age >= 20 && user.HasPermission && !user.IsLocked)
{
    Console.WriteLine("処理できます");
}

このような場合は、意味のあるbool変数に分けると読みやすくなります。

C#
bool isValidUser = user != null && user.IsActive;
bool isAdult = user != null && user.Age >= 20;
bool canUseService = user != null && user.HasPermission && !user.IsLocked;

if (isValidUser && isAdult && canUseService)
{
    Console.WriteLine("処理できます");
}

ただし、同じuser != nullを何度も書くのは冗長です。先にnullチェックを済ませてから、条件を分ける方法もあります。

C#
if (user == null)
{
    return;
}

bool isValidUser = user.IsActive;
bool isAdult = user.Age >= 20;
bool canUseService = user.HasPermission && !user.IsLocked;

if (isValidUser && isAdult && canUseService)
{
    Console.WriteLine("処理できます");
}

この書き方は、条件の意味が明確になり、後から修正しやすくなります。

8-2. 括弧を使って条件の優先順位を明確にする

AND条件とOR条件を組み合わせる場合は、括弧を使って優先順位を明確にしましょう。

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

このコードは、「管理者または所有者であり、かつ有効である」という意味です。

括弧がないと、意図しない判定になる可能性があります。

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

この場合、&&が先に評価されるため、次のように扱われます。

C#
if (isAdmin || (isOwner && isActive))
{
}

これは「管理者なら有効でなくてもアクセスできる」という意味になる可能性があります。

コードの読み手に誤解を与えないためにも、複雑な条件では括弧を省略しないほうが安全です。

8-3. メソッド化して意味のある名前を付ける

条件が複雑な場合は、メソッドに切り出すのも効果的です。

C#
if (CanAccessAdminPage(user))
{
    Console.WriteLine("管理画面を表示します");
}

メソッドの中でAND条件を判定します。

C#
bool CanAccessAdminPage(User user)
{
    return user != null &&
           user.IsActive &&
           user.Role == "Admin" &&
           !user.IsLocked;
}

このようにすると、if文を読むだけで「管理画面にアクセスできるかどうかを判定している」とわかります。

条件式をそのまま書くよりも、意図が明確になります。

C#
if (user != null && user.IsActive && user.Role == "Admin" && !user.IsLocked)
{
}

この書き方でも動作はしますが、条件が増えるほど読みづらくなります。実務では、業務ルールを表す条件ほどメソッド化すると保守しやすくなります。

8-4. 複雑なAND条件を避けるリファクタリング例

複雑なAND条件は、早期returnを使うと読みやすくなることがあります。

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

C#
if (user != null && user.IsActive && user.HasPermission && !user.IsLocked)
{
    Execute();
}

短い条件なら問題ありませんが、条件が増えると読みづらくなります。

早期returnを使うと、次のように書けます。

C#
if (user == null)
{
    return;
}

if (!user.IsActive)
{
    return;
}

if (!user.HasPermission)
{
    return;
}

if (user.IsLocked)
{
    return;
}

Execute();

この書き方では、「処理できない条件」を先に除外しています。条件ごとにエラーメッセージを変えたい場合にも便利です。

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

if (!user.IsActive)
{
    Console.WriteLine("ユーザーが無効です");
    return;
}

if (!user.HasPermission)
{
    Console.WriteLine("権限がありません");
    return;
}

Execute();

また、業務ルールとして再利用するなら、メソッド化するのがよいでしょう。

C#
if (!CanExecute(user))
{
    return;
}

Execute();

bool CanExecute(User user)
{
    return user != null &&
           user.IsActive &&
           user.HasPermission &&
           !user.IsLocked;
}

AND条件は便利ですが、長くなりすぎると可読性が下がります。変数化、メソッド化、早期returnを使って、読みやすい形に整えることが大切です。

9. C#のAND条件に関するよくある質問

9-1. C#にandキーワードはある？

C#には、通常の論理ANDとして使うandキーワードはありません。if文などでAND条件を書く場合は、基本的に&&を使います。

C#
if (age >= 20 && isMember)
{
    Console.WriteLine("条件を満たしています");
}

次のように書くと、通常はエラーになります。

C#
if (age >= 20 and isMember)
{
}

ただし、C# 9.0以降のパターンマッチングでは、andパターンがあります。

C#
if (age is >= 20 and <= 65)
{
    Console.WriteLine("対象年齢です");
}

これは通常の&&の代わりではなく、パターンマッチング専用の書き方です。

9-2. &&と&はどちらを使えばいい？

通常のAND条件では、&&を使うのがおすすめです。

C#
if (condition1 && condition2)
{
}

&&は短絡評価されるため、左側の条件がfalseなら右側を評価しません。そのため、nullチェックや不要な処理の回避に役立ちます。

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

&は両方の条件を必ず評価します。

C#
if (condition1 & condition2)
{
}

bool型に対して使うことはできますが、特別な理由がない限り、if文のAND条件では&&を使いましょう。

9-3. LINQのAND条件はSQLのANDと同じ？

LINQのAND条件は、考え方としてはSQLのANDに近いです。

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

SQL
SELECT *
FROM Users
WHERE Age >= 20 AND IsActive = 1;

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

C#
var result = users.Where(user => user.Age >= 20 && user.IsActive);

どちらも、「年齢が20歳以上、かつ有効なユーザー」を絞り込む条件です。

ただし、LINQにはLINQ to Objects、LINQ to SQL、Entity Frameworkなどの種類があり、実行される場所やSQLへの変換のされ方が異なります。メモリ上のリストに対するLINQであればC#の条件式として評価されます。Entity Frameworkなどでは、条件式がSQLに変換されてデータベース側で実行されることがあります。

基本的な考え方は同じですが、実行環境によって細かな挙動や使えるメソッドに違いがある点は覚えておきましょう。

9-4. AND条件とOR条件を同時に使うときの注意点

AND条件とOR条件を同時に使うときは、括弧を使って条件のまとまりを明確にすることが重要です。

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

この条件は、「管理者またはマネージャーであり、かつ有効なユーザー」という意味です。

括弧を省略すると、意図しない結果になる可能性があります。

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

この場合、&&が||より優先されるため、次のように解釈されます。

C#
if (isAdmin || (isManager && isActive))
{
}

つまり、「管理者なら有効でなくてもアクセスできる」という意味になる可能性があります。

AND条件とOR条件を組み合わせる場合は、たとえ優先順位を覚えていても、括弧を書いておくほうが読みやすく安全です。

9-5. 条件が多い場合のおすすめの書き方

条件が多い場合は、1行にすべて書かず、読みやすく分けるのがおすすめです。

C#
if (user != null &&
    user.IsActive &&
    user.Age >= 20 &&
    user.HasPermission &&
    !user.IsLocked)
{
    Console.WriteLine("処理できます");
}

このように改行するだけでも見やすくなります。

さらに読みやすくするなら、bool変数に分けます。

C#
bool isAdult = user.Age >= 20;
bool isAvailable = user.IsActive && !user.IsLocked;
bool canExecute = user.HasPermission;

if (isAdult && isAvailable && canExecute)
{
    Console.WriteLine("処理できます");
}