The symbols that tell C# what to do with your data.

Imagine you want to build a simple calculator application. You need a way to add two numbers, compare which one is larger, and decide what to do based on a condition. Without symbols like +, >, and &&, you'd have to write thousands of lines of low-level code just to add 2 + 3.

Operators are the shorthand that makes programming practical. They are the verbs in your code sentences — they act on values and produce results. Understanding operators is foundational because every single program uses them constantly.

In this lesson, you'll learn the different categories of operators, how they work, precedence rules, and common pitfalls.

What Is It?

The Simple Explanation

An operator is a symbol that tells the compiler to perform a specific operation on one or more values (called operands).

The Technical Definition

In C#, operators are special symbols that perform operations on operands. C# supports a rich set of operators, which can be classified into:

• Arithmetic — perform mathematical calculations (+, -, *, /, %)
• Comparison (relational) — compare values and return a bool (==, !=, <, >, <=, >=)
• Logical — combine or negate boolean values (&&, ||, !)
• Assignment — assign values to variables (=, +=, -=, *=, etc.)
• Bitwise — operate on individual bits (&, |, ^, ~, <<, >>)
• Null-coalescing — handle null values (??, ??=)
• Conditional (ternary) — condition ? trueValue : falseValue
• Type operators — is, as, typeof, sizeof
• Member access — . (dot) and [] (indexer)
• Pointer-related — only in unsafe contexts

Why Does It Exist?

The Problem

Programs need to manipulate data. Without operators, you would have to call methods for every operation:

int result = Add(2, 3);          // instead of 2 + 3
bool isEqual = AreEqual(a, b);   // instead of a == b

This would make code verbose, hard to read, and error-prone. Operators provide a concise, universally understood syntax.

The Solution

C# defines a set of built-in operators that map directly to CPU instructions or common patterns. They allow you to write expressions naturally:

int result = 2 + 3;
bool isEqual = a == b;

Additionally, C# allows you to overload many operators for your own custom types, enabling intuitive syntax like vector1 + vector2.

Big Picture

Operators are the glue in expressions. They determine how data flows and transforms:

How It Works

Let's trace how the compiler and runtime evaluate an expression with multiple operators:

Step 1 — Tokenization

The compiler scans the source code and identifies operators and operands. For a + b * c, it sees + and *.

Step 2 — Precedence and Associativity

Each operator has a precedence. * has higher precedence than +, so b * c is evaluated first. If operators have the same precedence, associativity (left-to-right or right-to-left) determines order.

Step 3 — Operand Evaluation

Operands are evaluated, possibly involving function calls, variable reads, or side effects. For ++i, the increment happens before the value is used; for i++, after.

Step 4 — Apply Operator

The operator's underlying implementation is invoked: either a built-in CPU instruction (e.g., add) or an overloaded method for custom types.

Step 5 — Short-Circuiting (for logical operators)

For && and ||, the right operand is not evaluated if the left operand determines the result. This is crucial for code like if (obj != null && obj.IsValid).

Step 6 — Produce Result

The resulting value is used in the outer expression or assigned to a variable.

Simple Example

using System;

int a = 10;
int b = 3;

int sum = a + b;              // 13
int difference = a - b;       // 7
int product = a * b;          // 30
int quotient = a / b;         // 3 (integer division)
int remainder = a % b;        // 1

bool isGreater = a > b;       // true
bool isEqual = a == b;        // false

bool bothPositive = (a > 0) && (b > 0);  // true
bool eitherNegative = (a < 0) || (b < 0); // false

string? name = null;
string displayName = name ?? "Guest";   // "Guest"

// Conditional operator
int max = (a > b) ? a : b;   // 10

Console.WriteLine($"sum={sum}, quotient={quotient}, max={max}, displayName={displayName}");

Code → Meaning → Result

• + adds, - subtracts, * multiplies, / divides (note integer division truncates), % gives remainder.
• > and == compare and return bool.
• && and || combine booleans with short-circuiting.
• ?? returns the left operand if not null, otherwise the right.
• ?: returns one of two values based on a condition.

Real-World Example

Consider an e-commerce order processing function that calculates discount based on membership level and order total:

decimal orderTotal = 250.00m;
bool isMember = true;
bool hasCoupon = false;

decimal discount = 0m;

// Apply member discount: 10%
if (isMember)
{
    discount += orderTotal * 0.10m;
}

// Apply coupon discount: fixed $20 if coupon available and total > 100
if (hasCoupon && orderTotal > 100)
{
    discount += 20m;
}

// Ensure discount doesn't exceed total
discount = Math.Min(discount, orderTotal);

decimal finalTotal = orderTotal - discount;

Console.WriteLine($"Order total: {orderTotal:C}, Discount: {discount:C}, Final: {finalTotal:C}");

This uses arithmetic operators (*, +, -), comparison (>), logical (&&), assignment (+=), and method call Math.Min. It's typical in any business application.

Analogy

Under the Hood

What actually happens when you use operators?

Common Confusion

1. = vs ==

= is assignment; == is equality comparison.

int x = 5;    // assign 5 to x
if (x == 5) { /* true */ }  // compare x to 5

Using = in an if condition is a compile error in C# (unlike C/C++ where it's allowed and often a bug).

2. && vs &, || vs |

&& and || are short-circuiting logical operators. They evaluate the second operand only if necessary. & and | are non-short-circuiting; they always evaluate both operands and also perform bitwise operations when used with integers.

3. / with integers vs floating-point

Integer division truncates toward zero: 7 / 2 yields 3, not 3.5. To get floating-point division, at least one operand must be a floating-point type: 7.0 / 2 or (double)7 / 2.

4. Operator precedence

Multiplication and division have higher precedence than addition and subtraction. Use parentheses to make your intent explicit when in doubt.

int result = 2 + 3 * 4;   // 14, not 20
int better = (2 + 3) * 4; // 20

5. Ternary vs if-else

The ternary operator ?: is an expression, not a statement. It returns a value and cannot contain statements. Use it for simple conditional value assignments; use if-else for complex logic.

Common Mistakes

Mistake 1 — Integer division without casting

double average = sum / count; — if both are int, division is integer, then converted to double (already truncated).

double average = (double)sum / count; or double average = sum * 1.0 / count;

Mistake 2 — Forgetting short-circuit side effects

if (CheckSomething() && CheckAnother()) — if CheckSomething() returns false, CheckAnother() is not called. This is usually desired but can cause missed side effects if you intended both to run.

If you need both to execute, call them separately and store results.

Mistake 3 — Using == for reference equality on strings

Actually == is overloaded for strings to compare values, so it's fine. But for other reference types, == compares references. Use .Equals() or override == if you need value comparison.

Mistake 4 — Overloading == without != (or vice versa)

If you overload ==, you must also overload != (and it's good practice to override Equals and GetHashCode). Similarly for < and >, <= and >=.

Mistake 5 — Confusing ?? with || for null checks

?? returns the right operand only if the left is null; it doesn't treat other falsy values like false or 0 as null.

When Should I Use It?

You use operators in virtually every line of C# code. Specific guidance:

Use arithmetic operators when:

• Performing calculations, totals, averages.
• Incrementing/decrementing counters (++, --).

Use comparison operators when:

• Making decisions in if statements, loops, sorting.
• Checking equality, range, ordering.

Use logical operators when:

• Combining multiple conditions.
• Using short-circuit for null checks and validation.

Use null-coalescing operators when:

• Providing default values for nullable types.
• Handling potentially null references in a concise way.

Use bitwise operators when:

• Working with flags (enum with [Flags]).
• Low-level protocols, cryptography, performance optimizations.

Avoid overusing complex expressions:

• If an expression is too long or confusing, break it into multiple statements.
• Prefer readability over cleverness.

Mental Model

Key Takeaway

Check Your Understanding

You've seen how operators work, why precedence matters, and how to avoid common pitfalls. Let's test your understanding.

int result = 7 / 2;

bool a = true;
bool b = false;
bool result = a || b && false;
Console.WriteLine(result);

You've now mastered the fundamentals of C# operators — the building blocks of all logic!

dotnetmadeeasy.com — Learn C# and .NET, the right way.