Operators are fundamental building blocks in C#. They allow you to perform operations on variables and values. Whether you are assigning values, comparing data, performing arithmetic, evaluating conditions, or manipulating bits, operators are everywhere in C# programming.

Understanding operators in depth is essential because:

They define how expressions are computed
They influence program logic
They help build readable and efficient code
They are frequently used in interview questions
They form the core of decision-making, looping, calculations, and expressions

This article provides a complete, descriptive, and practical guide to all operators in C#, covering everything from basic arithmetic to advanced operator overloading.

What Are Operators in C#?

Operators are special symbols that tell the compiler what kind of operation to perform on operands (variables or values).

Example

int result = 5 + 3;

Here:

+ is the operator
5 and 3 are operands
result holds the output

C# provides a rich set of operators grouped into categories based on their purpose.

1. Arithmetic Operators

Arithmetic operators perform basic mathematical operations on numeric data.

These operators are used for computations such as addition, subtraction, multiplication, division, and modulus operations.
They are frequently used in programs involving calculations, loops, and data processing.
Division (/) behaves differently for integers (produces integer division) and floating-point values (produces decimal results).
The modulus operator (%) returns the remainder after division, which is often used in logical calculations such as even/odd checks.

Operator	Description	Example
+	Addition	a + b
-	Subtraction	a - b
*	Multiplication	a * b
/	Division	a / b
%	Modulus (remainder)	a % b

Example

int a = 10;
int b = 3;

Console.WriteLine(a + b); // 13
Console.WriteLine(a % b); // 1

2. Assignment Operators

Assignment operators assign values to variables.

The basic assignment operator (=) sets the value of the right-hand expression into the left-hand variable.
Compound assignment operators like +=, -=, *= simplify writing repetitive expressions (e.g., x = x + 5 becomes x += 5).
They improve code readability and reduce duplication, especially in loops or repeated operations.
These operators work with numbers, strings, and other types based on how the operator is overloaded.

Operator	Description	Example
=	Assign value	a = 10
+=	Add and assign	a += 5
-=	Subtract and assign	a -= 5
*=	Multiply and assign	a *= 2
/=	Divide and assign	a /= 2
%=	Modulus and assign	a %= 2

Example

int x = 10;
x += 5; // x = x + 5

3. Comparison (Relational) Operators

Used to compare two values. They return true or false.

Relational operators are primarily used in decision-making, such as if, while, and for loops.
They compare values numerically or lexicographically, depending on the data type.
== and != compare equality, while >, <, >=, and <= evaluate relative ordering.
Comparing reference types usually checks memory references, not values (except for strings, which override comparison behavior).

Operator	Meaning	Example
==	Equal to	a == b
!=	Not equal to	a != b
>	Greater than	a > b
<	Less than	a < b
>=	Greater than or equal	a >= b
<=	Less than or equal	a <= b

Example

int a = 5, b = 10;
Console.WriteLine(a < b); // true

4. Logical Operators

Used for combining Boolean expressions.

&& (AND) returns true only when both conditions are true. Useful for multi-step validations.
|| (OR) returns true if at least one condition is true, commonly used in optional-check logic.
! (NOT) negates a boolean value, flipping true ↔ false.
Logical operators use short-circuit evaluation, meaning unnecessary conditions are not evaluated, improving performance.

Operator	Meaning	Example
&&	Logical AND	cond1 && cond2
`		`
!	Logical NOT	!cond

Example

bool isLogin = true;
bool isAdmin = false;

Console.WriteLine(isLogin && isAdmin); // false

5. Unary Operators

Unary operators require only one operand.

Unary plus (+) and minus (-) express sign, although unary minus is more commonly used to negate values.
Increment (++) and decrement (--) operators modify values by 1 and exist in both prefix and postfix form.
Prefix modifies the value before use, while postfix modifies after use.
Logical NOT (!) is a unary operator that flips boolean expressions.

Operator	Meaning	Example
+	Unary plus	+a
-	Unary minus	-a
++	Increment	a++ or ++a
--	Decrement	a-- or --a
!	Logical NOT	!flag

Example

int a = 5;
Console.WriteLine(++a); // 6

6. Bitwise Operators

Used to manipulate bits at the low level.

Used in low-level programming, encryption algorithms, graphics, and performance-critical applications.
Bitwise AND, OR, XOR manipulate individual bits of numeric types.
Shift operators (<<, >>) move bits left or right, multiplying or dividing by powers of two.
They are extremely fast and efficient, but require a deeper understanding of binary representation.

Operator	Meaning	Example
&	Bitwise AND	a & b
`	`	Bitwise OR
^	Bitwise XOR	a ^ b
~	Bitwise NOT	~a
<<	Left shift	a << 1
>>	Right shift	a >> 1

Example

int a = 5;  // 0101
int b = 3;  // 0011
int c = a & b; // 0001 -> 1

7. Conditional (Ternary) Operator

Short form of if-else.

Evaluates a condition and returns one of two values depending on the result.
Improves code compactness and readability when simple conditions exist.
Useful for inline assignments, UI messages, and logging statements.
Should not be overused in complex conditions to avoid reduced readability.

condition ? value_if_true : value_if_false;

Example

int age = 20;
string message = age >= 18 ? "Adult" : "Minor";

8. Null-Coalescing Operators

Used when working with nullable values.

1. Null Coalescing: `??`

Returns a fallback value if the left side is null.

Provides a fallback value if the left operand is null.
Prevents null reference exceptions in safe and clean code.
Frequently used when working with user input, configurations, or optional fields.
Helps avoid verbose null-checking logic.

string name = inputName ?? "Unknown";

2. Null Coalescing Assignment: `??=`

Assigns a value only if the variable is null.

Assigns a value only if the variable is null.
Useful for initialising default values.
Improves code readability by reducing if(variable == null) checks.
Often used in constructors, methods, or caching logic.

name ??= "Guest";

9. Null-Conditional Operator `?.`

Safely access a member without throwing null exceptions.

Allows safe access to members without throwing a null exception.
If the left operand is null, the entire expression evaluates to null.
Reduces verbose null-check patterns like if(x != null).
Commonly used when dealing with data from APIs, databases, or optional parameters.

string name = person?.FullName;

10. Type Check Operators

1. `is` Operator

Checks whether an object is of a certain type.

Checks if an object is of a specified type.
Can match patterns for additional validation.
Used in type-safe casting without risk of exception.
Helpful in polymorphism and pattern matching.

if (obj is string)

2. `as` Operator

Converts type safely; returns null if conversion fails.

Attempts safe casting; returns null instead of throwing exceptions.
Useful when you are unsure of the object's type.
Prevents runtime errors during invalid casts.
Works only with reference types.

string data = obj as string;

11. Type Conversion Operators

`typeof`

Returns the Type object.

Returns the System.Type object for a given type name.
Helpful in reflection, attributes, and dependency injection.
Allows inspecting metadata about classes.
Commonly used in logging and diagnostics.

Type t = typeof(string);

`sizeof`

Returns the size of value types.

Returns the size of value types in bytes.
Used primarily in unsafe code and performance-sensitive operations.
The size of types is fixed and determined by the runtime.
Helps in low-level memory manipulation.

int size = sizeof(int); // 4

12. Member Access Operator `.`

Used to access fields, methods, and properties.

Used to access members of a class or object (methods, fields, properties).
Enables chaining operations—for example, person.Address.City.
Foundation of object-oriented programming in C#.
Works with static and instance members.

person.Name

13. Indexer Operator `[]`

Used for accessing elements in arrays and collections.

Used to access elements of arrays, lists, and dictionaries.
Enables random access to collection elements.
Index must be a valid integer or key (for dictionaries).
Supports slicing with C# range operator.

int value = arr[0];

14. Lambda Operator `=>`

Used in lambda expressions.

Used to define anonymous functions in a compact form.
Essential for functional programming and LINQ expressions.
Improves readability when defining small pieces of logic.
Often used in event handlers, delegates, and filtering operations.

(x, y) => x + y

15. Range Operator `..` (C# 8+)

Used for slicing arrays.

Enables slicing arrays and sequences more cleanly.
Supports start and end boundaries.
Very useful in high-level data manipulation.
Works well with the Index and Range types introduced in modern C#.

var slice = arr[1..4];

16. Pattern Matching Operators (Modern C#)

Extend the power of the is and switch operators.
Allow matching values, types, conditions, and shapes.
Improve clarity and reduce boilerplate code.
Useful in modern object-oriented and functional styles of coding.

`is` Expression Patterns

if (item is int number)

`switch` Expression Patterns

var result = input switch
{
    > 0 => "Positive",
    < 0 => "Negative",
    _ => "Zero"
};

17. Operator Overloading

C# allows custom operators in your classes.

Allows custom types to behave like built-in types using operators.
Useful in mathematical models, vectors, matrices, coordinates, etc.
Improves readability of domain-specific operations.
Should be used carefully to avoid confusing behavior.

Example

public static Point operator +(Point a, Point b)
{
    return new Point(a.X + b.X, a.Y + b.Y);
}

Operator overloading is powerful in mathematical and domain-driven models.

18. Precedence and Associativity

C# follows strict rules for evaluating expressions.

Operator precedence defines the order in which operators are evaluated.
Multiplication, division, and modulus have higher precedence than addition and subtraction.
Parentheses override natural precedence to form clear expressions.
Understanding precedence is essential for writing correct expressions.
For example:

int result = 10 + 20 * 2; // Multiplication happens first

Always remember

Multiplication/division happens before addition/subtraction
Parentheses override precedence

What Are Operators in C#?

1. Arithmetic Operators

2. Assignment Operators

3. Comparison (Relational) Operators

4. Logical Operators

5. Unary Operators

6. Bitwise Operators

7. Conditional (Ternary) Operator

8. Null-Coalescing Operators

1. Null Coalescing: ??

2. Null Coalescing Assignment: ??=

9. Null-Conditional Operator ?.

10. Type Check Operators

1. is Operator

2. as Operator

11. Type Conversion Operators

typeof

sizeof

12. Member Access Operator .

13. Indexer Operator []

14. Lambda Operator =>

15. Range Operator .. (C# 8+)

16. Pattern Matching Operators (Modern C#)

is Expression Patterns

switch Expression Patterns

17. Operator Overloading

18. Precedence and Associativity

1. Null Coalescing: `??`

2. Null Coalescing Assignment: `??=`

9. Null-Conditional Operator `?.`

1. `is` Operator

2. `as` Operator

`typeof`

`sizeof`

12. Member Access Operator `.`

13. Indexer Operator `[]`

14. Lambda Operator `=>`

15. Range Operator `..` (C# 8+)

`is` Expression Patterns

`switch` Expression Patterns