Логические операторы — AND, OR, NOT, XOR

Логические логические операторы выполняют логические операции с логическими операндами. Операторы включают унарное логическое отрицание (!), двоичное логическое И (), OR (&|) и монопольное ИЛИ (^), а также двоичный условный логический и () и OR (&&||).

Унарный ! (логическое отрицание) оператор.
Бинарные & (логическое И), | (логическое ИЛИ), а также ^ (логическое исключающее ИЛИ) операторы. Эти операторы всегда обрабатывают оба операнда.
Бинарные && (условное логическое И) и || (условное логическое ИЛИ) операторы. Эти операторы вычисляют правый операнд, только если это необходимо.

Для операндов целочисленных типов операторы &, | и ^ выполняют побитовые логические операции. Дополнительные сведения см. в разделе Побитовые операторы и операторы сдвига.

Справочные документы по языку C# описывают последнюю выпущенную версию языка C#. Она также содержит начальную документацию по функциям в общедоступных предварительных версиях для предстоящего языкового выпуска.

Документация определяет любую функцию, впервые представленную в последних трех версиях языка или в текущих общедоступных предварительных версиях.

Подсказка

Чтобы узнать, когда функция впервые появилась в C#, ознакомьтесь со статьей об истории версий языка C#.

Оператор логического отрицания !

Унарный оператор префикса ! вычисляет логическое отрицание операнда. Он создает, true если операнд оценивается, и false если операнд falseоценивается следующим trueобразом:

bool passed = false;
Console.WriteLine(!passed);  // output: True
Console.WriteLine(!true);    // output: False

Унарный оператор постфикса ! является оператором, допускающим значение NULL.

Логический оператор AND &

Оператор & вычисляет логическое И для всех своих операндов. Результат x & y — true, если x и y равны true. В противном случае результат будет false.

Оператор & всегда вычисляет оба операнда. Если операнд слева, результат false операции зависит от значения правого операндаfalse. Однако правый операнд по-прежнему оценивается.

В следующем примере правый операнд & оператора является вызовом метода, который выполняется независимо от значения левого операнда:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false & SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// False

bool b = true & SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Условный логический оператор&& AND также вычисляет логические И его операнды, но он не оценивает правый операнд, если левый операнд является false.

Для операндов целочисленных типов оператор & вычисляет побитовое логическое И своих операндов. Унарный оператор & является оператором AddressOf.

Оператор логического исключения ИЛИ ^

Оператор ^ вычисляет логическое исключение ИЛИ для всех своих операндов, Результатом x ^ y является true, если x равен true и y равен false, или x равен false и y равен true. В противном случае результат будет false. Для bool операндов оператор вычисляет тот же результат, ^ что и оператор!= неравенства.

Console.WriteLine(true ^ true);    // output: False
Console.WriteLine(true ^ false);   // output: True
Console.WriteLine(false ^ true);   // output: True
Console.WriteLine(false ^ false);  // output: False

Для операндов целочисленных типов оператор ^ вычисляет побитовое исключающее ИЛИ своих операндов.

Оператор логического ИЛИ |

Оператор | вычисляет логическое ИЛИ для всех своих операндов. Результат операции x | y принимает значение true, если хотя бы один из операторов x или y имеет значение true. В противном случае результат будет false.

Оператор | всегда вычисляет оба операнда. При оценке trueлевого операнда результат true операции независимо от значения правого операнда. Однако, даже тогда, правый операнд оценивается.

В следующем примере правый операнд оператора | является вызовом метода, который выполняется независимо от значения левого операнда:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true | SecondOperand();
Console.WriteLine(a);
// Output:
// Second operand is evaluated.
// True

bool b = false | SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Условный логический ОПЕРАТОР OR|| также вычисляет логический ИЛИ его операнды, но не вычисляет правый операнд, если левый операнд оценивается true.

Для операндов целочисленных типов оператор | вычисляет побитовое логическое ИЛИ своих операндов.

Условный оператор логического И `&&`

Условный оператор логического И && (оператор короткого замыкания) вычисляет логическое И для своих операндов. Результат операции x && y принимает значение true, если оба оператора x и y имеют значение true. В противном случае результат будет false. Если x вычисляется falseзначение , y не вычисляется.

В следующем примере правый операнд оператора && является вызовом метода, который не выполняется, если левый операнд имеет значение false:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = false && SecondOperand();
Console.WriteLine(a);
// Output:
// False

bool b = true && SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Логический оператор& AND также вычисляет логические И его операнды, но всегда вычисляет оба операнда.

Условный оператор логического ИЛИ `||`

Условный оператор логического ИЛИ || (оператор короткого замыкания) вычисляет логическое ИЛИ для своих операндов. Результат операции x || y принимает значение true, если хотя бы один из операторов x или y имеет значение true. В противном случае результат будет false. Если x вычисляется trueзначение , y не вычисляется.

В следующем примере правый операнд оператора || является вызовом метода, который не выполняется, если левый операнд имеет значение true:

bool SecondOperand()
{
    Console.WriteLine("Second operand is evaluated.");
    return true;
}

bool a = true || SecondOperand();
Console.WriteLine(a);
// Output:
// True

bool b = false || SecondOperand();
Console.WriteLine(b);
// Output:
// Second operand is evaluated.
// True

Оператор логического ИЛИ| также вычисляет логическое ИЛИ для своих операндов, но всегда вычисляет оба операнда.

Операторы, допускающие логическое значение NULL

Для bool? операндов операторы & (логические И) и | (логические ИЛИ) поддерживают трехзначную логику следующим образом:

Оператор & возвращается true только в том случае, если оба операнда оцениваются true. Если значение равно или xyfalseоценивается, x & y возвращается false (даже если другой операнд оценивается).null В противном случае выражение x & y будет иметь значение null.
Оператор | возвращает false только в том случае, если оба операнда имеют значение false. Если x или y имеет значение true, оператор x | y возвращает true (даже если другой операнд имеет значение null). В противном случае выражение x | y будет иметь значение null.

Эта семантика описывается в следующей таблице:

x	г	x и y	x \| Y
правда	правда	правда	правда
правда	неправда	неправда	правда
правда	ноль	ноль	правда
неправда	правда	неправда	правда
неправда	неправда	неправда	неправда
неправда	ноль	неправда	ноль
ноль	правда	ноль	правда
ноль	неправда	неправда	ноль
ноль	ноль	ноль	ноль

Поведение этих операторов отличается от типичного поведения операторов, допускающих значение NULL. Как правило, оператор, определенный для операндов типа значения, также можно использовать с операндами соответствующего типа значения, допускающего значение NULL. Такой оператор возвращает null, если какой-либо из операндов имеет значение null. При этом операторы & и | могут возвращать отличное от NULL значение, даже если один из операндов имеет значение null. См. подробнее о поведении операторов, допускающих значение NULL, в разделе Операторы с нулификацией в статье Типы, допускающие значение NULL.

Вы также можете также использовать операторы ! и ^ с операндами bool?, как показано в следующем примере:

bool? test = null;
Display(!test);         // output: null
Display(test ^ false);  // output: null
Display(test ^ null);   // output: null
Display(true ^ null);   // output: null

void Display(bool? b) => Console.WriteLine(b is null ? "null" : b.Value.ToString());

Условные логические операторы && и || не поддерживают операнды типа bool?.

Составное присваивание

Для бинарного оператора op выражение составного присваивания в форме

x op= y

Эквивалентен

x = x op y

За исключением того, что x оценивается только один раз.

Операторы &, | и ^ поддерживают составное присваивание, как показано в следующем примере:

bool test = true;
test &= false;
Console.WriteLine(test);  // output: False

test |= true;
Console.WriteLine(test);  // output: True

test ^= false;
Console.WriteLine(test);  // output: True

Примечание.

Условные логические операторы && и || не поддерживают составное присваивание.

Приоритет операторов

В следующем списке перечислены логические операторы в порядке убывания приоритета:

Оператор логического отрицания. !
Оператор логического И &
Оператор логического исключающего ИЛИ ^
Оператор логического ИЛИ |
Условный оператор логического И &&
Условный оператор логического ИЛИ ||

Порядок вычисления, определяемый приоритетом операторов, можно изменить с помощью скобок (()).

Console.WriteLine(true | true & false);   // output: True
Console.WriteLine((true | true) & false); // output: False

bool Operand(string name, bool value)
{
    Console.WriteLine($"Operand {name} is evaluated.");
    return value;
}

var byDefaultPrecedence = Operand("A", true) || Operand("B", true) && Operand("C", false);
Console.WriteLine(byDefaultPrecedence);
// Output:
// Operand A is evaluated.
// True

var changedOrder = (Operand("A", true) || Operand("B", true)) && Operand("C", false);
Console.WriteLine(changedOrder);
// Output:
// Operand A is evaluated.
// Operand C is evaluated.
// False

Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.

Возможность перегрузки оператора

Определяемый пользователем тип может перегружать операторы !, &, | и ^. При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Начиная с C# 14, определяемый пользователем тип может явно перегружать операторы составного назначения, чтобы обеспечить более эффективную реализацию. Как правило, тип перегружает эти операторы, так как значение можно обновить на месте, а не распределить новый экземпляр для хранения результата двоичной операции. Если тип не предоставляет явной перегрузки, компилятор создает неявную перегрузку.

Определяемый пользователем тип не может перегружать условные логические операторы && и ||. При этом, если определяемый пользователем тип каким-либо образом перегружает операторы true и false и операторы & и |, операция && или || может быть применена для операндов этого типа. Дополнительные сведения см. в разделе Пользовательские условные логические операторы в Спецификации языка C#.

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

См. также

Обратная связь

Были ли сведения на этой странице полезными?

Last updated on 2026-01-24