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 can be separated into different categories. Some of them are listed below:

• Arithmetic Operator
• Relational Operator
• Boolean Logical Operator
• Assignment Operators

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)

C# 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

C# 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

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

C# 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

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

C# 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

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

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.

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.

C# 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#

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

• C# Operators