C# Operators

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations between the two operands. For example, in mathematics the plus symbol (+) signifies the sum of the left and right numbers. Similarly, in C#, we can do addition operation by using '+' operand.

In C#, there are several operators to perform various operations between multiple operands. C# has many operators that have different meanings based on the data types of the operands.

C# operators can be divided into following categories:

1. Arithematic Operators
2. Assignment Operators
3. Relational Operators
4. Logical Operators
5. Bitwise and Shift Operators

Arithematic Operators in C#

Arithmetic operators are used to perform common mathematical operations:

For all these example, let's assume x= 10, y =5:

There are certain operators which have different meanings based on the datatype of the operand.

For example, if the + operator is used with numbers, it will add the numbers but if it is used with strings, it will concatenate the two strings.

string x="Hello";
string y = "World";

string z= x+y;

Console.WriteLine(z); //output = Hello World

Assignment Operators in C#

Assignment operators are used to assign values to variables. "=" is called the assignment operator. "=" assigns the variable in the left of it with the value on the right of it. Basically, it provides the data on its R.H.S. to the variable in its L.H.S.

Example:

int x=5;

take a look at more complete example

    using System;
    namespace Operator
    {
    	class AssignmentOperatorInCsharp
    	{
    		public static void Main(string[] args)
    		{
    			int FirstInt, SecondInt;
    			// Assigning a constant to variable
    			FirstInt = 5;
    			Console.WriteLine("First number = " + FirstInt);
    			// Assigning a variable to another variable
    			SecondInt = FirstInt;
    			Console.WriteLine("Second number = "+ SecondInt);
    		}
    	}
    }

Output :

First number = 5
Second number = 5

Relational Operators in C#

Relational operators are used to compare values, basically they check the relation between two data, and always return boolean results ( true or false)

Let's take a sample example program for above explained operators

using System;
					
public class Program
{
	public static void Main()
	{
		    Console.WriteLine(3 < 4);
            Console.WriteLine(3 == 4);
            Console.WriteLine(4 >= 3);
            Console.WriteLine(4 != 3);
		    Console.WriteLine(4 <= 3);
	}
}

Output

True
False
True
True
False

In the above code example, we have 5 expressions. These expressions compare integer values.

The result of each of the expressions is either true or false.

Logical operators in C#

Logical operators in C# are used to perform operations like AND, OR , NOT operations on any given operands. Here is the list of C# logical operators with meaning

Let's take a look at the complete example which uses all three operators

using System;
					
public class LogicalOperatorProgram
{
	public static void Main()
	{
            bool result;
			int FirstInt = 20, secondInt = 30;
			// OR operator
			result = (FirstInt == secondInt) || (FirstInt > 5);
			Console.WriteLine(result);
		
			// AND operator
			result = (FirstInt == secondInt) && (FirstInt > 5);
			Console.WriteLine(result);
		
		   bool ThirdValue=false;
		   result = !ThirdValue;
		   Console.WriteLine(result);
	}
}

Output

True
False
True

Bitwise and shift Operators in C#

Bitwise operators are used to perform operations in bits and and perform bit by bit operation. Bitwise and shift operations never cause overflow and produce the same results in checked and unchecked contexts.

Here is the table for it.

Let's take a look at complete example which includes all of the above operators

using System;
					
public class BitwWiseProgram
{
	public static void Main()
	{
		        int FirstValue = 10;
			int SecondValue = 20;
			int result;
			result = ~FirstValue;
			Console.WriteLine("~{0} = {1}", FirstValue, result);
			result = FirstValue & SecondValue;
			Console.WriteLine("{0} & {1} = {2}", FirstValue,SecondValue, result);
			result = FirstValue | SecondValue;
			Console.WriteLine("{0} | {1} = {2}", FirstValue,SecondValue, result);
			result = FirstValue ^ SecondValue;
			Console.WriteLine("{0} ^ {1} = {2}", FirstValue,SecondValue, result);
			result = FirstValue << 2;
			Console.WriteLine("{0} << 2 = {1}", FirstValue, result);
			result = FirstValue >> 2;
			Console.WriteLine("{0} >> 2 = {1}", FirstValue, result);
	}
}

Output

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

Ternary operator in C# (? :)

The conditional operator ?:, also known as the ternary conditional operator, evaluates a Boolean expression and returns the result of one of the two expressions.

The ternary operator ? : operates on three operands.

Syntax for

result = condition ? expression1 : expression2

The condition expression must evaluate to true or false. If condition evaluates to true, the expression1 is evaluated, and its result becomes the result of the operation.

If condition evaluates to false, the alternative expression2 is evaluated, and its result becomes the result of the operation. Only consequent or alternative is evaluated.

Example:

using System;
					
public class TernaryOperatorProgram
{
	public static void Main()
	{
	   int input = new Random().Next(-5, 5);

       string classify;


        classify = (input >= 0) ? "nonnegative" : "negative";

		Console.WriteLine("Input ="+input);
		Console.WriteLine("Classify ="+ classify);
	}
}

Output

Input =-3
Classify =negative