Is it ok to use bitwise operator in place of a logical operator like OR

Question

This may be stupid.but i have a simple doubt Suppose i have the following check in a function

bool Validate(string a , string b)
{
    if(a == null || b == null)
    {
        throw new NullReferenceException();
    }
    else
    {
    }
}

Is it ok to use bitwise OR for validation as shown below

if(a == null | b == null)

Answer 1

In boolean expressions (rather than integers etc), the main difference is: short-circuiting. || short-circuits. | does not. In most cases you want short-circuiting, so || is much much more common. In your case, it won't matter, so || should probably be used as the more expected choice.

The times it matters is:

if(politics.IsCeasefire() | army.LaunchTheRockets()) {
    // ...
}

vs:

if(politics.IsCeasefire() || army.LaunchTheRockets()) {
    // ...
}

The first always does both (assuming there isn't an exception thrown); the second doesn't launch the rockets if a ceasefire was called.

Answer 2

In this case (with bool arguments) the | operator is not a bitwise operator. It's just a non-short-circuiting version of the logical or ( || ).

The same goes for & vs. && - it's just a non-short-circuiting version of logical and .

The difference can be seen with side-effects, for example in

bool Check()
{
    Console.WriteLine("Evaluated!");
    return true;
}

// Short-circuits, only evaluates the left argument.
if (Check() || Check()) { ... }

// vs.

// No short circuit, evaluates both.
if (Check() | Check()) { ... }

Answer 3

This should work, because when used on things that evaluate to bool , the "bitwise" operators carry out logical operations just the same. You might find it less efficient, though. The logical operators in C# will short-circuit, meaning they'll skip evaluation of the second expression if the answer can be deduced from the first. So in your example, if a == null turns out to be true, then || would return true immediately, while | would go ahead and check b == null anyway.

Answer 4

As has been commented upon, the code is indeed 'ok'.

Using the single pipe '|' will evaluate all expressions before returning the result. '||' can be more efficient, since it ceases as soon as an expression evaluates to true.