Ясное, объяснение неспециалистом различия между | и || в c#?

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

Это означает, что второй операнд всегда оценивается с помощью | оператор, но использование || оператор второй операнд только оценен, если первый операнд оценивает ко лжи.

Результатом выражения всегда является то же для обоих operatrors, но если оценка второго операнда заставляет что-то еще изменяться, который, как только гарантируют, произойдет, если Вы будете использовать | оператор.

Пример:

int a = 0;
int b = 0;

bool x = (a == 0 || ++b != 0);

// here b is still 0, as the "++b != 0" operand was not evaluated

bool y = (a == 0 | ++b != 0);

// here b is 1, as the "++b != 0" operand was evaluated.

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

if (str == null) {
   Console.WriteLine("String has to be at least three characters.");
} else {
   if (str.Length < 3) {
      Console.WriteLine("String has to be at least three characters.");
   } else{
      Console.WriteLine(str);
   }
}

Можно записать как это:

if (str == null || str.Length < 3) {
   Console.WriteLine("String has to be at least three characters.");
} else{
   Console.WriteLine(str);
}

Второй операнд только оценен, если первой является ложь, таким образом, Вы знаете, что можно безопасно использовать строковую ссылку во втором операнде, поскольку это не может быть пустым, если второй операнд оценен.

В большинстве случаев Вы хотели бы использовать || оператор, а не | оператор. Если первый операнд является ложью, нет никакой потребности оценить второй операнд для получения результата. Кроме того, много людей (очевидно) не знает, что можно использовать | оператор с булевыми операндами, таким образом, они запутались бы при наблюдении его, использовал тот путь в коде.

Они не то же. Каждый - битовое "ИЛИ", и каждый логичен ИЛИ.

X || Y, логическое или, означает то же как "X или Y" и относится к значениям bool. Это используется в условных выражениях или тестах. X и Y в этом случае могут быть заменены любым выражением, которое оценивает к bool. Пример:

if (File.Exists("List.txt")  ||  x > y )  { ..}

Пункт оценивает к истинному, если любое из этих двух условий верно. Если первое условие верно (если файл существует), то второе условие нужно не и не будет оценено.

Единственный канал (|) является битовым "ИЛИ". Для знания, что это означает, необходимо быть, понимают, как числа хранятся в компьютере. Предположим, что у Вас есть 16-разрядное количество (Int16), который содержит значение 15. Это на самом деле хранится как 0x000F (в шестнадцатеричном числе), который совпадает с 0000 0000 0000 1111 в двоичном файле. Битовое "ИЛИ" берет два количества и каждую пару OR соответствующих битов вместе, так, чтобы, если бит 1 в любом количестве, это было 1 в результате. Поэтому, если = 0101 0101 0101 0101 (который оценивает к 0x5555 в шестнадцатеричном числе) и b = 1010 1010 1010 1010 (который является 0xAAAA), затем | b = 1111 1111 года 1111 года 1111 = 0xFFFF.

Можно использовать битовое "ИЛИ" (единственный канал) в C#, чтобы протестировать, если один или несколько из определенного набора битов включен. Вы могли бы сделать это, если у Вас есть, скажем, 12 булевских переменных или двоичные значения для тестирования на, и они - весь независимый политик. Предположим, что у Вас есть студенческая база данных. Ряд независимых булевских переменных мог бы быть вещами как, штекер/розетка, home/on-campus, current/not-current, enrolled/not-enrolled, и т.д. Вместо того, чтобы хранить булево поле для каждого из тех значений, Вы могли сохранить просто единственный бит для каждого. Штекер/розетка мог бы быть битом 1. зарегистрированный/не мог бы быть бит 2.

Затем можно использовать

 if ((bitfield | 0x0001) == 0x0001) { ... }

поскольку тест, чтобы видеть, не включены ли никакие биты, кроме "студента, является штекерным" битом, который проигнорирован. Ха? Ну, битовое "ИЛИ" возвращает 1 для каждого бита, который идет в любом числе. Если результат битового "ИЛИ" выше = 0x0001, который означает, нет никаких битов, включенных в битовом поле, кроме, возможно, первого бита (0x0001), но Вы не можете сказать наверняка, идет ли первый бит, потому что это это маскируется.

Существует соответствующий && и и, который логичен И и поразрядно И. У них есть аналогичное поведение.

Можно использовать

 if ((bitfield &  0x0001) == 0x0001) { ... }

видеть, включен ли первый бит в битовом поле.

Править: Я не могу полагать, что был провален для этого!

Хорошие ответы, но позволяют мне добавить что выражения правой стороны для || не оценен, если выражение левой стороны true. Имейте это в виду для случаев, где условия оценки b) a) интенсивный производительностью или b) произведите (редкие) побочные эффекты.

В отличие от того, что до сих пор говорит большинство ответов, значение не является точно тем же как в C++.

Для любых двух выражений A и B, оценивающего к булевским переменным, || B и |, B делают почти то же самое.

| B оценивает и A и B, и если один из них оценивает к истинному, результат верен.

|| B делает почти то же самое, кроме него оценивает первое, и затем только оценивает B, если это необходимо. Так как все выражение верно, если или A или B верны, B не должен быть протестирован вообще, если A верен. Так || короткие замыкания и пропуски, оценивая второй операнд, если это возможно, где | оператор будет всегда оценивать обоих.

| оператор не часто используется, и часто это не будет иметь значения. Единственный общий падеж, о котором я могу думать, где это имело бы значение, является этим:

if ( foo != null || foo.DoStuff()){ // assuming DoStuff() returns a bool

}

Это работает, потому что DoStuff () функцию членства никогда не называют, если левый тест перестал работать. Таким образом, если нечто является пустым, мы не называем DoStuff на нем. (который дал бы нам NullReferenceException).

Если бы мы использовали | оператор, DoStuff () назвали бы независимо от того, было ли нечто пустым или нет.

На целых числах только | оператор определяется и является битовым "ИЛИ", как другие ответы описывают. || оператор не определяется для целых типов, хотя, таким образом, трудно перепутать их в C#.

| оператор битового "ИЛИ" (числовой, целочисленный). это работает путем преобразования чисел в двоичный файл и выполнения ИЛИ для каждой из соответствующих цифр. с другой стороны числа уже представлены в двоичном файле в компьютере, таким образом, никакое такое преобразование действительно не происходит во времени выполнения ;)

|| логическая операция ИЛИ (булевская переменная). это только работает над истинными и ложными значениями.

Следующее работало бы в C/C++, потому что это не имеет никакой поддержки первого класса булевских переменных, это рассматривает каждое выражение с "на", обдумал их как верных иначе ложь. На самом деле следующий код не работал бы в C# или Java, если X и Y имеют числовые типы.

if (x | y) 

Таким образом, явная версия вышеупомянутого кода:

if ( (x | y) != 0)

В C любое выражение, которое имело бы "На", обдумало их, результаты к истинному

интервал i = 8;

если (i)//допустимый в C, результатах к истинному

международная радость =-10;

если (радость)//допустимый в C, результатах к истинному

Теперь, назад к C#

Если X и Y имеют числовой тип, Ваш код: если (x | y) не будет работать. Вы попытались компилировать его?Ничего не выйдет

Но для Вашего кода, который я мог принять, X и Y имеют булевы типы, таким образом, он будет работать, таким образом, различие между | и || для булевых типов, || будет закорочено, | не. Вывод следующего:

    static void Main()
    {


        if (x | y)
            Console.WriteLine("Get");

        Console.WriteLine("Yes");

        if (x || y)
            Console.WriteLine("Back");

        Console.ReadLine();
    }


    static bool x
    {
        get { Console.Write("Hey");  return true; }
    }

    static bool y
    {
        get { Console.Write("Jude"); return false; }
    }

:

HeyJudeGet
Yes
HeyBack

Jude не будет распечатан дважды, || булев оператор, много булевых операторов языков C-derived закорачиваются, булевы выражения более производительны, если они закорачиваются.

Что касается условий неспециалиста, когда Вы говорите закороченный, например, в || (или оператор), если первое выражение уже верно, никакая потребность оценить второе выражение. Пример: если (отвечают == 'y' || ответ == 'Y'), если пользовательское нажатие маленький y, программа не должна оценивать второе выражение (ответ == 'Y'). Это - короткое замыкание.

На моем примере кода выше, X верно, таким образом, Y на || оператор не будет оценен далее, следовательно никакой второй "Jude" не произвел.

Не используйте этот вид кода в C#, даже если X и Y имеют булевы типы: если (x | y). Не производительный.

Первый, побитовый оператор работает над двумя численными значениями и результатами в третьем.

Если у Вас есть двоичные переменные

a = 0001001b;
b = 1000010b;

затем

a | b == 1001011b;

Таким образом, немного в результате 1, если это также 1 в любом из операндов. (Мой пример использует 8-разрядные числа для пользы ясности),

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

Не копаясь в деталях всегда, форме, или форме, вот версия настоящего неспециалиста.

Думайте "|" как прямое "или" на английском языке; думайте "||" как "или иначе" на английском языке.

Так же думайте "и" как "и" на английском языке; думайте о "&&" как "и также" на английском языке.

Если Вы читаете выражение в себя использующий эти термины, они часто имеют намного больше смысла.

Хотя это уже сказали и ответили правильно, что я думал, что добавлю ответ настоящего неспециалиста с большого количества времени, это - то, чему я чувствую себя подобно на этом сайте :). Плюс я добавлю пример и по сравнению с &&, так как это - то же понятие

| по сравнению с ||

В основном Вы склонны использовать || когда Вы только wnat для оценки второй части ЕСЛИ первая часть это ЛОЖЬ. Так это:

if (func1() || func2()) {func3();}

совпадает с

if (func1())
{
    func3();
}
else 
{
    if (func2()) {func3();}
}

Это может быть способом сохранить время обработки. Если бы func2 () занял много времени для обработки, то Вы не хотели бы делать это, если бы func1 () был уже верен.

И по сравнению с &&

В случае и по сравнению с && это - аналогичная ситуация, где Вы только оцениваете вторую часть, ЕСЛИ первой частью является TRUE. Например, это:

if (func1() && func2()) {func3();}

совпадает с

if (func1())
{
    if (func2()) {func3();}}
}

Это может быть необходимо, так как func2 () может зависеть от func1 () сначала быть верным. Если бы Вы использовали и и func1 () оцененный ко лжи, и выполнили бы func2 () так или иначе, который мог вызвать ошибку периода выполнения.

Jeff неспециалист