What is the difference between & and && operators in C#

Question

I am trying to understand the difference between & and &&operators in C#. I searched on the internet without success. Can somebody please explain with an example?

Answer 1

Strongly recommend this article.

• && is short-circuit logical operator

For AND operations if any of the operand evaluated to false then total expression evaluated to false, so there is no need to evaluate remaining expressions, similarly in OR operation if any of the operand evaluated to true then remaining evaluation can be skipped

• & operator can be used as either unary or binary operator. that is, unary & can be used to get address of it’s operand in unsafe context.

Answer 2

Below example and explanation's may help.

Example:

    public static bool Condition1()
    {
        Console.WriteLine("Condition1 is evaluated.");
        return false;
    }

    public static bool Condition2()
    {
        Console.WriteLine("Condition2 is evaluated.");
        return true;
    }

1. Logical Operator

& (ampersand) Logical AND operator

| (pipeline) Logical OR operator

Used for ensuring all operands are evaluated.

if(Condition1() & Condition2())
{
  Console.WriteLine("This will not print");

  //because if any one operand evaluated to false ,  
  //thus total expression evaluated to false , but both are operand are evaluated.
}

 if (Condition2() | Condition1())
 {
   Console.WriteLine("This will print");

   //because any one operand evaluated to true ,  
  //thus total expression evaluated to true , but both are operand are evaluated.
 }

2. Conditional Short Circuit Operator

&& (double ampersand) Conditional AND operator

|| (double pipeline) Conditional OR operator

Used for Skipping the right side operands , Has Side effects so use carefully

if (Condition1() && Condition2())
{
   Console.WriteLine("This will not print");

   //because if any one operand evaluated to false,
   //thus total expression evaluated to false , 
   //and here the side effect is that second operand is skipped 
   //because first operand evaluates to false.
}

if (Condition2() || Condition1())
{
   Console.WriteLine("This will print");

  //because any one operand evaluated to true 
  //thus remaining operand evaluations can be skipped.
}

Note:

To get better understanding test it in console sample.

References

dotnetmob.com

wikipedia.org

stackoverflow.com

Answer 3

& can be used on either integral types (like int, long etc.) or on bool.

When used on an integral type, it performs a bitwise AND and gives you the result of that. When used on a bool, it performs a logical AND on BOTH its operands and gives you the result.

&& is not used as a bitwise AND. It is used as a logical AND, but it does not necessarily check both its operands. If the left operand evaluates to false, then it doesn't check the right operand.

Example where this matters:

void Action() 
{
    string name = null;
    if(name != null && name.EndsWith("ack"))
    {
        SomeOtherAction();
    }
}

If name is null, then name.EndsWith("ack") will never get executed. It is smart enough to know if the left operand is false, then the right operand doesn't need to be evaluated (aka "short-circuiting"). That's good because calling a method on null will throw a NullReferenceException.

If you changed it into if(name != null & name.EndsWith("ack")), both sides would get evaluated and it would throw a NullReferenceException.

One detail: & can also be a unary operator (so it has one operand) in an unsafe context. It will give the address of a value or object. It's not important though, as most people don't ever have to touch this part of the language.

Answer 4

According to - C# 4.0 The Complete Reference by Herbert Schildt

& - Logical AND Operator
| - Logical OR Operator

&& - Short Circuited AND Operator
|| - Short Circuited OR Operator

A simple example can help understand the phenomena

using System;

class SCops {
    static void Main() {
        int n, d;
        n = 10;
        d = 2;

        if(d != 0 && (n % d) == 0)
            Console.WriteLine(d + " is a factor of " + n);
        d = 0; // now, set d to zero

        // Since d is zero, the second operand is not evaluated.
        if(d != 0 && (n % d) == 0)
            Console.WriteLine(d + " is a factor of " + n);
        // Now, try the same thing without the short-circuit operator.
        // This will cause a divide-by-zero error.
        if(d != 0 & (n % d) == 0)
            Console.WriteLine(d + " is a factor of " + n);
    }
}

Here the & operator checks each and every operand and && checks only the first operand.

As you might notice for 'AND' operations any operand which is false will evaluate the whole expression to false irrespective of any other operands value in the expression. This short circuited form helps evaluate the first part and is smart enough to know if the second part will be necessary.

Running the program will throw a divide-by-zero error for the last if condition where both the operands are checked for & operator and no exception handling is done to tackle the fact that 'd' can be 0 at any point of time.

The same case applies to '|' in C#.

This is slightly different than C or C++ where '&' and '|' were bitwise AND and OR operators. However C# also applies the bitwise nature of & and | for int variables only.

Answer 5

& is the bitwise AND operator. For operands of integer types, it'll calculate the bitwise-AND of the operands and the result will be an integer type. For boolean operands, it'll compute the logical-and of operands. && is the logical AND operator and doesn't work on integer types. For boolean types, where both of them can be applied, the difference is in the "short-circuiting" property of &&. If the first operand of && evaluates to false, the second is not evaluated at all. This is not the case for &:

 bool f() {
    Console.WriteLine("f called");
    return false;
 }
 bool g() {
    Console.WriteLine("g called");
    return false;
 }
 static void Main() {
    bool result = f() && g(); // prints "f called"
    Console.WriteLine("------");
    result = f() & g(); // prints "f called" and "g called"
 }

|| is similar to && in this property; it'll only evaluate the second operand if the first evaluates to false.

Of course, user defined types can overload these operators making them do anything they want.

Answer 6

Easy way to look it is logical & will evaluate both sides of the & regardless if the left side is false, whereas the short-circuit && will only evaluate the right side if the left is true.

d=0;
n=10;

// this throws divide by 0 exception because it evaluates the 
//      mod even though "d != 0" is false
if ( (d != 0) & (n % d) == 0 ) 
   Console.Writeline( d + " is a factor of " + n);

// This will not evaluate the mod.
if ( (d != 0) && (n % d) == 0 ) 
   Console.Writeline( d + " is a factor of " + n);

Answer 7

Hai Friend, The Operator &&(Logical Operator) is used in conditional statements. For Instance

if(firstName == 'Tilsan' && lastName == 'Fighter')
{
      Response.Write("Welcome Tilsan The Fighter!");
}

the Response.Write statement will run only if both variables firstName and lastName match to their condition.

Whereas & (Bitwise Operator)operator is used for Binary AND operations, i.e., if we write:

bool a, b, c;

a = true;
b = false;

c = a & b;

Response.Write(c); // 'False' will be written to the web page

Here first Binary And operation will be performed on variables a and b, and the resultant value will be stored in variable c.

Answer 8

& is a bitwise operator and && is a logical operator that applies to bool operands.

Answer 9

The first one is bitwise and the second one is boolean and.