C# Operators

Operators are the foundation of any programming language, the program is incomplete without the operators as we use them in all of our programs.

Operators are the symbol that performs a specific mathematical or logical operation on operands.
Example: Addition : 2 + 3, where 2 and 3 are the operands and + is the operator.

Following are the types of Operators in C#.

Arithmetic Operators
Assignment Operators
Relational Operators
Logical Operators
Unary Operators
Bitwise Operators
Ternary or Conditional Operator
Miscellaneous Operators

C# Arithmetic Operators

Arithmetic Operators are used to perform mathematical operations on operands such as addition, subtraction, multiplication, division etc.

operator	description
`+`	addition adds two operands. eg, a+b.
`-`	subtraction subtracts two operands. eg, a-b.
`*`	multiplication multiplies two operands. eg, a*b.
`/`	division divides the operand by the second. eg, a/b.
`%`	modulo returns the remainder when the first operand is divided by the second. For example, a%b.

Click Here for example of Arithmetic Operators operators.

C# Assignment Operators

These operators are used in a program to assign a value of the right-hand side to the left-hand side as shown below.

//10 is assign to the variable a
int a = 5;

//the value of b (10) is assigned to a
int b = 10;
int a = b;
int a += 2; //a=a+2

You can combine write in short version such as instead of writing, int a = a+5, you can write it as a += 5.

Following are the list of assignment operators used in C#.

Operator	Description
=	Simple assignment operator, Assigns values from right side operands to left side operand. `a = b + c;`
+=	Add AND assignment operator, It adds the right operand to the left operand and assigns the result to the left operand. `a += b`
-=	Subtract AND assignment operator, It subtracts the right operand from the left operand and assigns the result to the left operand. `a -= b`
*=	Multiply AND assignment operator, It multiplies the right operand with the left operand and assigns the result to the left operand. `a *= b`
/=	Divide AND assignment operator, It divides left operand with the right operand and assigns the result to the left operand. `a /= b`
%=	Modulus AND assignment operator, It takes modulus using two operands and assigns the result to the left operand. `a %= b`
<<=	Left shift AND assignment operator. `a <<= 2`
>>=	Right shift AND assignment operator. `a >>= 2` or `a = a >> 2`
&=	Bitwise AND assignment operator. `a &= 2` or `a = a & 2`
^=	Bitwise exclusive OR and assignment operator. `a ^= 2` or `a = a ^ 2`
\|=	Bitwise inclusive OR and assignment operator. `a \|= 2` or `a = a \| 2`

Click Here for example of Assignment Operators operators.

C# Relational Operators

These operators are used in a program to check the relationship between two operands and accordingly, it returns boolean values, true or false. These are used with loops and Decision-Making Statements during condition checking.

List of relational operators in C#:

Operator	Name	Example
==	Equal to.	`A == B`
!=	Not equal.	`A != B`
>	Greater than.	`A > B`
<	Less than.	`A < B`
>=	Greater than or equal to.	`A >= B`
<=	Less than or equal to.	`A <= B`

Click Here for example of Relational Operators operators.

C# Logical Operators

These operators are used to compute the logical operation in a program such as &&, || and !. They are used to evaluate the condition.

The following are the C# Logical Operators. Assume X holds the value 1 and Y holds 0

Operator	Description	Example
&& (logical and)	If both the operands are non-zero, then the condition becomes true.	`(X && Y) is false`
\|\| (logical or)	If any of the two operands are non-zero, then the condition becomes true.	`(X \|\| Y) is true`
! (logical not)	Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false.	`!(X && Y) is true`

Click Here for example of Logical Operators operators.

C# Unary Operators

These operators are the Increment and Decrement Operators. They operate on a single operand. They are ++ and -- operators. ++ is used to increase the value by 1 and — is used to decrease the value by 1.

Post-Increment or Post-Decrement:
First, the value is used for operation and then incremented or decremented. Represented as a++ or a–.
Pre-Increment Pre-Decrement:
Here First the value is incremented or decremented then used for the operation. Represented as ++a or –a.

Click Here for example of Unary Operators operators.

C# Bitwise Operators

Bitwise operators are used to perform a bit-level operation on operands. They are used in testing, setting, or shifting the actual bits in a program.

You can see the truth table below.

p	q	p & q	p \| q	p ^ q	~p
0	0	0	0	0	1
0	1	0	1	1	1
1	1	1	1	0	0
1	0	0	1	1	0

Below are the list of Bitwise operators:

Operators	Name of operators
&	Bitwise AND
\|	Bitwise OR
^	Bitwise XOR
~	Bitwise complement
<<	Shift left
>>	Shift right

Click Here for example of Bitwise Operators operators.

C# Ternary or Conditional Operator (`?:`)

It is a short-hand version of the if-else statement that operates on three operands. The ternary operator (or Conditional operator) returns a true or false after checking the condition.

Syntax of ternary operator:

//syntax
condition ? expression1 : expression2;

Explanation:

condition: It checks the condition for a true or false value.
expression1: If the condition is true expression1 is evaluated.
expression2: If the condition is false expression2 is evaluated.

Example of Ternary Operator in C#

using System;

namespace Operator
{
   class TernaryOperator
   {
      public static void Main(string[] args)
      {
         int num = 10;
         string result;

         result = (num % 2 == 0) ? "Even Number" : "Odd Number";
         Console.WriteLine("{0} is {1}", num, result);
      }
   }
}

Output:

15 is Odd Number

Miscellaneous Operators

Apart from the above operators, there are various other operators used in C# programming and they are:

`sizeof()`	It returns the size of a variable, constant, array, etc. `sizeof` is a keyword in C#. Example: `sizeof(int);` // returns 4
`typeof()`	Returns the type of a class Example: `typeof(StreamReader);`
`&`	This is a pointer operator, used to point the address of a variable, or we can say that it represents the memory address of the operand to which it points. Example: `&a;`, This points to the actual address of the variable a.
*``**	This is also a pointer variable, Indirection Operator. It returns the value of the variable that it points to.
`is`	This operator checks an object is of a certain type. Example: `If(mercedes is Car)` // checks if Mercedes is an object of the Car class.
`as`	This operator cast without raising an exception Example: `Object ob = new StringReader("World"); StringReader r = ob as StringReader;`

Operator Precedence in C#

In a program, there may be an expression that uses more than one operator, in such case operator precedence determines which is to be evaluated first and next.

Let us take an example:

int result = 10 + 5 * 10; 

//Output:
60

The output of the above expression is 60 because the precedence of multiplication is higher than the addition. So first (5 * 10) is evaluated and then 10 is added to the result.

The following shows the precedence and associativity of C# operators:

Associativity refers to the direction of the operators to be evaluated first and next. It may be right to left or left to right.

Category	Operator	Associativity
Postfix	() [] -> . ++ – –	Left to right
Unary	+ – ! ~ ++ – – (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ –	Right to left
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=/td>	Right to left
Bitwise AND	&	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	\|	Right to left
Logical AND	&&	Left to right
Logical OR	\|\|	Left to right
Conditional	?:	Right to left
Assignment	= += -= *= /= %=>>= <<= &= ^= \|=	Right to left
Comma	,	Left to right