C#

C# Operators

In C#, symbols such as +, –, *, and / are called operators because they operate, or perform calculations, on one or more variables (operands) in an expression to produce the required results. Basically, C# operators provide syntax for the compiler on how to process data types within the calculation.

C# operators

C# Operators can be separated into different categories. Some of them are listed below:

C# Operators are generally classified into three categories based on the number of arguments they can take:

  • Unary ( ++ ) — increment operator that take single operand.
  • Binary ( +,-,*, / ) — arithmetic operators that take two operands (left-associative).
  • Ternary ( ? : ) — conditional operator that take three operands (right-associative)

Expressions

Expressions can be transformed by combining operators with one or more variables (operands) and literal values. You can create expressions to evaluate the result from simple or complicated statements.

int i = 4; 
int j = (i * 4) + 3; 

Console.WriteLine(j);

Run Demo

OUTPUT

19

Arithmetic Operators

C# arithmetic operators are the same ones you use on numeric values in math to perform mathematical operations such as addition, subtraction, multiplication, or division. Most of the operators in the below table are binary operators because they operate on two operands. C# uses infix notation for binary operators; the operator appears between the left and right operands. One thing to note is that all binary operators are left-associative, which means that operations are performed left to right except for the assignment and C# conditional operator (? :), which are performed right to left.

C# Arithmetic Operators

Operator Description Examples
+ Add Add two operands together. a + b
Subtract Subtract the value of right-hand operand from left-hand operand. a – b
* Multiply Multiplies both operands. a * b
/ Division Divide the left-hand operand with the right-hand operand (numerator by de-numerator) a / b
% Modulo Divide the left-hand operand by the right operand and then returns the remainder. a % b
++ Increment Increase the value of the operand by 1. a++
– – Decrement Decrease the value of the operand by 1. a – –

Note:

  • Integer division by 0 throws runtime exception DivideByZeroException.
  • The + sign is used for both addition and string concatenation.

Increment and Decrement Operators (++, –)

Increment and decrement operators are considered unary, which means that they can only be used on one operand. You can also use them as a prefix or postfix operator depending on whether you want the variable to be updated before or after the expression is evaluated. For example:

int a = 3;
a++; // 3 
--a; // Still 3 
++a; // 4

int a = 0;

Console.WriteLine($"a is now {a}");
Console.WriteLine($"a++ : Outputs {a++}, a is now {a}");
Console.WriteLine($"++a : Outputs {++a}, a is now {a}");
Console.WriteLine($"--a : Outputs {--a}, a is now {a}");

Run Demo

OUTPUT

a is now 0
a++ : Outputs 0, a is now 1
++a : Outputs 2, a is now 2
— a : Outputs 1, a is now 1

Modulus (%)

This name comes from the term modulo used in a branch of mathematics known as modular arithmetic. Modulo is the remainder after division. So, the % operator gives us the remainder, as if a division has taken place.

The result a % b is evaluated as a - (a / b) * b using integer operations. If b is zero, a DivideByZeroException is thrown. This is not used with floating-point numbers because you have no remainder after the division of floating-point values. For example:

int a = 13 % 3;
int b = 30 % 7;

Console.WriteLine($"remainder : {a}");
Console.WriteLine($"remainder : {b}");
OUTPUT

remainder : 1
remainder : 2

int a = 30;
int b = 7;
int c = a - (a / b) * b;

Console.WriteLine($"a – (a / b) * b : remainder is {c}");
Console.WriteLine($"a % b : remainder is {a % b}");

Run Demo

OUTPUT

a – (a / b) * b : remainder is 2
a % b : remainder is 2

More Examples:

int addition = 20 + 10;
int subtraction = 20 - 10;
int multiplication = 20 * 10;
int division = 20 / 10;
int modulus_1 = 7 % 3;
double modulus_2 = 14.9 % 3.9;

Console.WriteLine($"addition: {addition}");
Console.WriteLine($"subtraction: {subtraction}");
Console.WriteLine($"multiplication: {multiplication}");
Console.WriteLine($"division: {division}");
Console.WriteLine($"modulus_1: {modulus_1}");
Console.WriteLine($"modulus_2: {modulus_2}");

Run Demo

OUTPUT

addition: 30
subtraction: 10
multiplication: 200
division: 2
modulus_1: 1
modulus_2: 3.2

Relational Operators

C# relational operators, also called comparison operators, are used to compare two or more values (operands) and always return a Boolean type. That is, the result of the comparison is either True or False. Because of this, they are good when used for decision making.

C# Relational Operators

Operator Description Examples
> Greater than Return true, if operand on the left is greater than the operand on the right. Otherwise, return false. a > b
< Less than Return true, if operand on the left side is less than the operand on the right side. Otherwise, return false. a < b
== Equal to Return true, if operand on the left side is equal to the operand on the right side. Otherwise, return false. a == b
!= Not equal to Return true, if operand on the left side is not equal to the operand on the right side. Otherwise, return false. a != b
>= Greater than or equal to Return true, if operand on the left side is greater than, or equal to, the operand on the right side. Otherwise, return false. a >= b
<= Less than or equal to Return true, if operand on the left side is less than or equal to the operand on the right side. Otherwise, return false. a <= b

Examples:

Suppose variable a has a value of 1, and variable b has a value of 2:

int a = 1;
int b = 2;

// True if a is equal to b
Console.WriteLine($"a == b : {a == b}");

// True if a is not equal to b
Console.WriteLine($"a != b : {a != b }");

// True if a is less than b 
Console.WriteLine($"a < b : {a < b}");

// True if a is less than or equal to b
Console.WriteLine($"a <= b : {a <= b}");

// True if a is greater than b 
Console.WriteLine($"a > b : {a > b}");

// True if a is greater than or equal to b
Console.WriteLine($"a >= b : {a >= b}");

Run Demo

OUTPUT

a == b : False
a != b : True
a < b : True
a <= b : True
a > b : False
a >= b : False

Logical Operators

C# logical operators, also called C# Boolean operators, accept two bool values and return a Boolean result (True/False). This enables you to form more complex conditions by combining simple conditions. Some logical operators supported by C# are described in the following table.

C# Boolean Logical Operators

Operator Description Examples
&& Conditional AND Condition becomes true if both operands are true. Otherwise, return false. (a && a)
|| Conditional OR Condition becomes true if at least one of your operands is true. Otherwise, return false. (a || b)
! Logical NOT (Negation) Reverse the value of your Boolean variable, meaning If the condition is true then the operator will make it false and vice versa. !(a && b)
^ Logical XOR Returns true if one of the two operands has a true value. It also returns true if the operands have different values. (a ^ b)

Note: || and && are referred to as short-circuit operators.

Examples:

Possible Combinations for && (Logical AND) Operator:

Console.WriteLine($"false && false: {false && false}");
Console.WriteLine($"false && true: {false && true}");
Console.WriteLine($"true && false: {true && false}");
Console.WriteLine($"true && true: {true && true}");
OUTPUT

false && false: False
false && true: False
true && false: False
true && true: True

Possible Combinations for || (Logical OR) Operator:

Console.WriteLine($"false || false: {false || false}");
Console.WriteLine($"false || true: {false || true}");
Console.WriteLine($"true || false: {true || false}");
Console.WriteLine($"true || true: {true || true}");
OUTPUT

false || false: False
false || true: True
true || false: True
true || true: True

Possible Combinations for ! (Logical NOT) Operator:

Console.WriteLine($"!false: {!false}");
Console.WriteLine($"!true: {!true}");
OUTPUT

!false: True
!true: False

Possible Combinations for ^ (Exclusive OR) Operator:

Console.WriteLine($"false ^ false: {false ^ false}");
Console.WriteLine($"false ^ true: {false ^ true}");
Console.WriteLine($"true ^ false: {true ^ false}");
Console.WriteLine($"true ^ true: {true ^ true}");

Run Demo

OUTPUT

false ^ false: False
false ^ true: True
true ^ false: True
true ^ true: False

Note: The && operator avoids evaluating both expressions unnecessarily.

C# short-circuits

The part of an expression containing the && operator is evaluated only until it’s known whether the condition is true or false. Thus, evaluation of the expression (UserName == “Admin” && password == “Admin123”) stops immediately if UserName is not equal to “Admin” and continues only if UserName is equal to “Admin” (meaning true). Then C# evaluates password == “Admin123”. The if statement considers the combined condition that is true if and only if both conditions are true. The && operator uses a short-circuit evaluation because it short-circuits around the second Boolean expression, if necessary.

Assignment Operators

C# assignment operators are used to assign a new value to a variable. This operator simply assigns whatever value is on the right to the variable on the left. Make sure that the data type of the right-hand operand is the same as the data type of the left-hand operand.

The = operator is called the simple assignment operator. It assigns the value of the right operand to the variable on the left side of the assignment.

The compound assignment operator combines assignment with another operator to perform operations. The compound operators are the following:

+=  -=  *=  /=  %=  &=  |=  ^=  <<=  >>=

Syntax:

Compound-assignment expression such as

expression1 += expression2

is equivalent to

expression1 = expression1 + expression2

Commonly used Assignment Operators in C#

Operator Description Examples
= Assign Assign values to the left operand a = 6
+= Plus AND assign Adds right and left operand and assign the result to the left operand a += 6 means a = a + 6
-= Minus AND assign Subtracts right and left operand and assign the result to the left operand a -= 6 means a = a – 6
*= Multiply AND assign Multiplies right and left operand and assign the result to the left operand a *= 6 means a = a * 6
/= Divide AND assign Divides right and left operand and assign the result to the left operand a /= 6 means a = a / 6
%= Modulus AND assign Modulus on two operands and assign the result to the left operand a %= 6 means a = a % 6

Examples:

int a, b, c;

// Syntax to initialize multiple values
a = b = c = 6;
 
Console.WriteLine(a += 1); // means a=a+1;    
Console.WriteLine(a -= 2); // means a=a-2;    
Console.WriteLine(a *= 3); // means a=a*3; 
Console.WriteLine(a /= 3); // means a=a/3;    
Console.WriteLine(a %= 3); // means a=a%3;

Run Demo

OUTPUT

7
5
15
5
2

C# Reference | Microsoft Docs

Tagged in :