Easy Learn C#

Arithmetic Operators Example:

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 truncates decimal part)
int remainder = a % b;  // 1

int c = 5;
int d = c++;  // d = 5, c = 6 (postfix: assign then increment)
int e = 5;
int f = ++e;  // f = 6, e = 6 (prefix: increment then assign)
                            

Assignment Operators Example:

int x = 10;

x += 5;  // x is now 15 (10 + 5)
x -= 3;  // x is now 12 (15 - 3)
x *= 2;  // x is now 24 (12 * 2)
x /= 4;  // x is now 6 (24 / 4)
x %= 4;  // x is now 2 (6 % 4)

// Compound assignment operators are more concise and often more efficient
// than their expanded forms
                            

Comparison Operators Example:

int a = 5, b = 10;

bool isEqual = (a == b);           // false
bool isNotEqual = (a != b);        // true
bool isGreater = (a > b);          // false
bool isLess = (a < b);             // true
bool isGreaterOrEqual = (a >= b);  // false
bool isLessOrEqual = (a <= b);     // true

// Comparison operators are commonly used in conditional statements
if (a < b)
{
    Console.WriteLine("a is less than b");
}
                            

Logical Operators Example:

bool isAdult = true;
bool hasLicense = false;

bool canDrive = isAdult && hasLicense;  // false (both must be true)
bool isEligible = isAdult || hasLicense;  // true (at least one is true)
bool isMinor = !isAdult;  // false (reverse of isAdult)

// Logical operators are often used in conditional statements
if (isAdult && hasLicense)
{
    Console.WriteLine("You can drive");
}
else
{
    Console.WriteLine("You cannot drive");
}
                            

Bitwise Operators Example:

/* Understanding binary representation:
   5 in binary is 0101
   3 in binary is 0011 */

// Bitwise AND (&)
int result1 = 5 & 3;   // 0101 & 0011 = 0001 (decimal: 1)

// Bitwise OR (|)
int result2 = 5 | 3;   // 0101 | 0011 = 0111 (decimal: 7)

// Bitwise XOR (^)
int result3 = 5 ^ 3;   // 0101 ^ 0011 = 0110 (decimal: 6)

// Bitwise NOT (~)
int result4 = ~5;      // ~0101 = 1010 (with sign extension: decimal: -6)

// Left shift (<<)
int result5 = 5 << 1;  // 0101 << 1 = 1010 (decimal: 10)

// Right shift (>>)
int result6 = 5 >> 1;  // 0101 >> 1 = 0010 (decimal: 2)
                            

Ternary Operator Syntax:

// Syntax: condition ? expression1 : expression2
// If condition is true, expression1 is evaluated and becomes the result
// If condition is false, expression2 is evaluated and becomes the result

int age = 20;
string message = (age >= 18) ? "Adult" : "Minor";
Console.WriteLine(message);  // Output: "Adult"

// Equivalent if-else statement:
string message2;
if (age >= 18)
{
    message2 = "Adult";
}
else
{
    message2 = "Minor";
}
                            

Null-related Operators Example:

// Null-coalescing operator (??)
string name = null;
string displayName = name ?? "Guest";  // If name is null, use "Guest"
Console.WriteLine(displayName);  // Output: "Guest"

// Null-conditional operator (?.)
Person person = null;
int? age = person?.Age;  // No NullReferenceException, age will be null
Console.WriteLine(age);  // Output: nothing (null)

// With actual object
Person john = new Person { Name = "John", Age = 30 };
int? johnsAge = john?.Age;  // johnsAge will be 30
Console.WriteLine(johnsAge);  // Output: 30

// Null-coalescing assignment (??=)
string message = null;
message ??= "Default message";  // Assigns only if message is null
Console.WriteLine(message);  // Output: "Default message"

// Already has a value, won't change
message ??= "New message";
Console.WriteLine(message);  // Output: "Default message" (unchanged)

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
                            

Type Testing Operators Example:

// is operator
object obj = "Hello";
if (obj is string)
{
    Console.WriteLine("obj is a string");
    
    // Pattern matching with is (C# 7.0+)
    if (obj is string str)
    {
        Console.WriteLine($"String length: {str.Length}");
    }
}

// as operator
object obj2 = "World";
string str2 = obj2 as string;  // If obj2 is not a string, str2 will be null
if (str2 != null)
{
    Console.WriteLine($"String: {str2}");
}

// Instead of using cast which throws an exception if fails:
// string str3 = (string)obj2;  // Would throw InvalidCastException if obj2 is not a string

// typeof operator
Type stringType = typeof(string);
Console.WriteLine($"Type name: {stringType.Name}");  // Output: "String"
Console.WriteLine($"Is value type: {stringType.IsValueType}");  // Output: "False"
                            

Operator Precedence (from highest to lowest):

1. Primary operators: x.y, f(x), a[i], x++, x--, new, typeof, checked, unchecked
2. Unary operators: +, -, !, ~, ++x, --x, (T)x
3. Multiplicative operators: *, /, %
4. Additive operators: +, -
5. Shift operators: <<, >>
6. Relational operators: <, >, <=, >=, is, as
7. Equality operators: ==, !=
8. Bitwise AND: &
9. Bitwise XOR: ^
10. Bitwise OR: |
11. Logical AND: &&
12. Logical OR: ||
13. Conditional operator: ?:
14. Assignment operators: =, +=, -=, etc.

Examples of Precedence:

// Arithmetic precedence
int result = 5 + 3 * 2;  // 3 * 2 is evaluated first, then added to 5
Console.WriteLine(result);  // Output: 11

// Using parentheses to change precedence
int result2 = (5 + 3) * 2;  // 5 + 3 is evaluated first, then multiplied by 2
Console.WriteLine(result2);  // Output: 16

// Complex expression
bool result3 = 10 > 5 && 3 < 7 || 4 == 4;  // Evaluated as: (10 > 5 && 3 < 7) || 4 == 4
Console.WriteLine(result3);  // Output: True