// Option 1: Mutable properties (not safe)
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

var person = new Person { Name = "Alice", Age = 30 };
person.Age = 31;  //  Works, but object is mutable

// Option 2: Read-only with constructor (verbose)
public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

var person = new Person("Alice", 30);  // Can't use object initializer 

// Option 3: Private setter (still allows mutation in class)
public class Person
{
    public string Name { get; private set; }
    public int Age { get; private set; }
}

// All have tradeoffs!

//  Best of both worlds!
public class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

// Can use object initializer
var person = new Person 
{ 
    Name = "Alice", 
    Age = 30 
};

// But can't modify after construction
person.Age = 31;  //  Compile error: Init-only property can only be set in initializer

// Perfect for immutable objects!

With Constructor

public class Person
{
    public string Name { get; init; }
    public int Age { get; init; }
    public DateTime CreatedAt { get; init; }

    public Person()
    {
        CreatedAt = DateTime.UtcNow;  //  Can set in constructor
    }
}

var person = new Person 
{ 
    Name = "Alice",
    Age = 30
};

Console.WriteLine(person.CreatedAt);  // Set automatically in constructor
// But CreatedAt can also be overridden in initializer if needed

public class Email
{
    private string _value;

    public string Value
    {
        get => _value;
        init
        {
            if (string.IsNullOrWhiteSpace(value))
                throw new ArgumentException("Email cannot be empty");
            
            if (!value.Contains('@'))
                throw new ArgumentException("Invalid email format");
            
            _value = value;
        }
    }
}

var email = new Email { Value = "alice@example.com" };  //  Valid
var invalid = new Email { Value = "not-an-email" };      //  Throws exception

// After creation, immutable
// email.Value = "new@example.com";  //  Compile error

// Combine init with required
public class User
{
    public required string Email { get; init; }
    public required string Name { get; init; }
    public string? PhoneNumber { get; init; }  // Optional
}

//  Must set required properties
var user = new User 
{ 
    Email = "alice@example.com",
    Name = "Alice"
};

//  Compile error: Required member 'Email' must be set
var invalid = new User { Name = "Alice" };

DTOs and API Models

// Perfect for API request/response DTOs
public class CreateUserRequest
{
    public required string Email { get; init; }
    public required string Password { get; init; }
    public required string Name { get; init; }
    public string? PhoneNumber { get; init; }
}

public class UserResponse
{
    public required int Id { get; init; }
    public required string Email { get; init; }
    public required string Name { get; init; }
    public required DateTime CreatedAt { get; init; }
}

// Controller
[HttpPost("users")]
public async Task CreateUser(CreateUserRequest request)
{
    var user = await _userService.CreateAsync(request);
    
    return new UserResponse
    {
        Id = user.Id,
        Email = user.Email,
        Name = user.Name,
        CreatedAt = user.CreatedAt
    };
}

// Response is immutable - thread-safe!

// Records have init by default
public record Person(string Name, int Age);

// Same as:
public record Person
{
    public string Name { get; init; }
    public int Age { get; init; }
    
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

// Use with expressions for non-destructive mutation
var person1 = new Person("Alice", 30);
var person2 = person1 with { Age = 31 };

// person1 unchanged, person2 has new age

Benefits

• Object initializer syntax: Clean, readable
• Immutability: Thread-safe, predictable
• Required members: Compiler enforces initialization
• Validation: Can validate in init setter
• No constructor bloat: Avoid 10-parameter constructors

Best Practices

• Use for DTOs: API models, configuration objects
• Combine with required: Enforce mandatory properties
• Add validation: In init setters when needed
• Prefer records: For data-centric types
• Document intent: Use init to signal immutability

Real-World Example

// Configuration object
public class DatabaseConfig
{
    public required string ConnectionString { get; init; }
    public required string DatabaseName { get; init; }
    public int MaxPoolSize { get; init; } = 100;
    public int CommandTimeout { get; init; } = 30;
    public bool EnableRetry { get; init; } = true;
}

// Usage
var config = new DatabaseConfig
{
    ConnectionString = "Server=localhost;Database=mydb",
    DatabaseName = "mydb",
    MaxPoolSize = 200
};

// Immutable after creation - safe to pass around
await InitializeDatabaseAsync(config);

// Can't accidentally change config
// config.MaxPoolSize = 300;  //  Compile error

// Value object
public class Money
{
    public required decimal Amount { get; init; }
    public required string Currency { get; init; }

    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException("Currency mismatch");
        
        return new Money 
        { 
            Amount = Amount + other.Amount,
            Currency = Currency
        };
    }
}

var price1 = new Money { Amount = 100m, Currency = "USD" };
var price2 = new Money { Amount = 50m, Currency = "USD" };
var total = price1.Add(price2);

// All Money objects immutable - safe!

//  Traditional method syntax
public string GetFullName()
{
    return $"{FirstName} {LastName}";
}

//  Expression-bodied method
public string GetFullName() => $"{FirstName} {LastName}";

// More examples
public int Add(int a, int b) => a + b;

public bool IsAdult() => Age >= 18;

public void PrintMessage() => Console.WriteLine("Hello");

public async Task GetUserAsync(int id) => await _repository.GetByIdAsync(id);

Expression-Bodied Properties

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }

    //  Traditional read-only property
    public string FullName
    {
        get
        {
            return $"{FirstName} {LastName}";
        }
    }

    //  Expression-bodied property
    public string FullName => $"{FirstName} {LastName}";

    // More examples
    public int Age => (int)((DateTime.Now - BirthDate).TotalDays / 365.25);
    
    public bool IsAdult => Age >= 18;
    
    public string Initials => $"{FirstName[0]}{LastName[0]}";
}

// Expression-bodied getter and setter (C# 7+)
private string _name;

public string Name
{
    get => _name;
    set => _name = value?.Trim() ?? throw new ArgumentNullException();
}

public class Point
{
    public int X { get; }
    public int Y { get; }

    //  Traditional constructor
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    //  Expression-bodied constructor
    public Point(int x, int y) => (X, Y) = (x, y);
}

// More examples
public class Logger
{
    private readonly ILoggerFactory _factory;

    public Logger(ILoggerFactory factory) => _factory = factory ?? throw new ArgumentNullException(nameof(factory));
}

// Expression-bodied finalizer
~MyClass() => Console.WriteLine("Finalizing");

// Expression-bodied indexer
public class Collection
{
    private readonly T[] _items;

    public Collection(T[] items) => _items = items;

    //  Traditional indexer
    public T this[int index]
    {
        get { return _items[index]; }
        set { _items[index] = value; }
    }

    //  Expression-bodied indexer
    public T this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }
}

Complete Class Example

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public decimal Cost { get; set; }
    public int Stock { get; set; }

    // Expression-bodied properties
    public decimal Margin => Price - Cost;
    public decimal MarginPercent => (Margin / Price) * 100;
    public bool InStock => Stock > 0;
    public bool LowStock => Stock < 10 && Stock > 0;

    // Expression-bodied methods
    public decimal CalculateRevenue(int quantity) => Price * quantity;
    
    public decimal CalculateProfit(int quantity) => Margin * quantity;
    
    public bool CanFulfillOrder(int quantity) => Stock >= quantity;
    
    public void Restock(int amount) => Stock += amount;
    
    public void Sell(int quantity) => Stock -= quantity;

    // ToString
    public override string ToString() => $"Product: {Name} (${Price:F2})";
}

// Usage
var product = new Product 
{ 
    Name = "Widget", 
    Price = 100m, 
    Cost = 60m, 
    Stock = 50 
};

Console.WriteLine(product.Margin);         // 40
Console.WriteLine(product.MarginPercent);  // 40
Console.WriteLine(product.LowStock);       // false
Console.WriteLine(product.CalculateProfit(10));  // 400

When to Use

• Single-expression methods: One return statement
• Read-only properties: Computed values
• Simple getters/setters: Validation, transformation
• Factory methods: new Constructor(params)
• LINQ projections: Clean Select() statements

When NOT to Use

• Multiple statements: Stick to traditional syntax
• Complex logic: Readability over conciseness
• Long expressions: Line gets too long (> 120 chars)
• Debugging: Can’t set breakpoint inside expression

Before & After Comparison

//  Before: 30 lines
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Subtract(int a, int b)
    {
        return a - b;
    }

    public int Multiply(int a, int b)
    {
        return a * b;
    }

    public double Divide(int a, int b)
    {
        return (double)a / b;
    }

    public bool IsEven(int number)
    {
        return number % 2 == 0;
    }

    public int Square(int number)
    {
        return number * number;
    }
}

//  After: 10 lines
public class Calculator
{
    public int Add(int a, int b) => a + b;
    public int Subtract(int a, int b) => a - b;
    public int Multiply(int a, int b) => a * b;
    public double Divide(int a, int b) => (double)a / b;
    public bool IsEven(int number) => number % 2 == 0;
    public int Square(int number) => number * number;
}

// 67% less code, same functionality!

// Before nullable reference types
public class UserService
{
    public string GetUserName(int userId)
    {
        var user = _repository.GetById(userId);  // Could return null!
        return user.Name;  //  NullReferenceException if user is null
    }
}

// No compiler warning!
// Crashes at runtime
// "The billion dollar mistake" - Tony Hoare

  
    net8.0
    enable  
  



#nullable enable  // At top of .cs file

// After enabling nullable reference types
public class UserService
{
    // Non-nullable: Must never be null
    public string GetUserName(int userId)
    {
        User? user = _repository.GetById(userId);  // User? = nullable
        return user.Name;  //  Compiler warning: Possible null reference
    }
    
    // Fixed version
    public string GetUserName(int userId)
    {
        User? user = _repository.GetById(userId);
        
        if (user == null)
        {
            throw new UserNotFoundException(userId);
        }
        
        return user.Name;  //  No warning - null checked
    }
    
    // Or return nullable
    public string? GetUserName(int userId)
    {
        User? user = _repository.GetById(userId);
        return user?.Name;  //  Returns null if user is null
    }
}

Nullable Syntax

// Non-nullable reference type (default)
string name = "Alice";
name = null;  //  Warning: Cannot assign null

// Nullable reference type (explicit ?)
string? name = null;  //  OK
name = "Alice";      //  OK

// Non-nullable in method signatures
public void ProcessUser(User user)  // user cannot be null
{
    Console.WriteLine(user.Name);  //  No null check needed
}

// Nullable in method signatures
public void ProcessUser(User? user)  // user might be null
{
    if (user != null)
    {
        Console.WriteLine(user.Name);  //  Null checked
    }
}

// Return types
public User GetUser(int id)      // Never returns null
public User? FindUser(int id)    // Might return null

User? user = FindUser(123);

// 1. Null check
if (user != null)
{
    Console.WriteLine(user.Name);
}

// 2. Null-conditional operator
Console.WriteLine(user?.Name);  // Returns null if user is null

// 3. Null-coalescing operator
string name = user?.Name ?? "Unknown";

// 4. Throw if null
User nonNullUser = user ?? throw new ArgumentNullException(nameof(user));

// 5. Pattern matching
if (user is { Name: var name })
{
    Console.WriteLine(name);  // user is not null here
}

// 6. Null-forgiving operator (! - use sparingly!)
Console.WriteLine(user!.Name);  // Tell compiler: "I know it's not null"
// Use only when you're 100% sure

public class User
{
    //  Warning: Non-nullable property must be initialized
    public string Name { get; set; }
    
    //  Fixed: Initialize in constructor
    public User(string name)
    {
        Name = name;
    }
}

// Or use required (C# 11)
public class User
{
    public required string Name { get; set; }
    public string? Email { get; set; }  // Optional, can be null
}

var user = new User { Name = "Alice" };  //  OK
var user2 = new User { Email = "test@example.com" };  //  Error: Name required

// Or default value
public class User
{
    public string Name { get; set; } = string.Empty;
    public List Orders { get; set; } = new();
}

Suppress Warnings (When Needed)

// Null-forgiving operator !
string GetName(User? user)
{
    // You KNOW user is not null (e.g., validated earlier)
    return user!.Name;  // Suppresses warning
}

// Pragma directive (suppress for block)
#pragma warning disable CS8600  // Converting null literal
string? name = null;
#pragma warning restore CS8600

// Attribute (for methods that ensure non-null)
public static bool TryGetUser(int id, [NotNullWhen(true)] out User? user)
{
    user = FindUser(id);
    return user != null;
}

if (TryGetUser(123, out var user))
{
    Console.WriteLine(user.Name);  //  Compiler knows user is not null
}

Benefits

• Catch bugs early: At compile-time, not runtime
• Self-documenting: API clearly shows what can be null
• Better tooling: IDE shows nullable warnings
• Safer code: Forces you to handle null cases
• Fewer crashes: NullReferenceException reduced dramatically

Migration Strategy

• Enable gradually: Per-file with #nullable enable
• Start with new code: Don’t rewrite everything at once
• Fix warnings systematically: Don’t suppress blindly
• Use analyzers: Enable all nullable warnings
• Team buy-in: Everyone must understand nullable

Real-World Example

#nullable enable

public class OrderService
{
    private readonly IOrderRepository _repository;
    private readonly IEmailService _emailService;

    public OrderService(IOrderRepository repository, IEmailService emailService)
    {
        _repository = repository;
        _emailService = emailService;
    }

    // Clear contract: Never returns null
    public Order GetOrder(int id)
    {
        Order? order = _repository.FindById(id);
        
        if (order == null)
        {
            throw new OrderNotFoundException($"Order {id} not found");
        }
        
        return order;  //  Guaranteed non-null
    }

    // Clear contract: Might return null
    public Order? FindOrder(int id)
    {
        return _repository.FindById(id);  //  Nullable return
    }

    public async Task ProcessOrder(Order order, string? promoCode)
    {
        // order is non-nullable - no need to check
        order.Status = OrderStatus.Processing;

        // promoCode is nullable - must check
        if (promoCode != null)
        {
            ApplyPromoCode(order, promoCode);
        }

        await _repository.SaveAsync(order);
        
        // Email might be null, handle gracefully
        await _emailService.SendConfirmationAsync(order.CustomerEmail ?? "no-reply@store.com");
    }
}

//  Traditional class - Lots of boilerplate
public class PersonClass
{
    public string Name { get; init; }
    public int Age { get; init; }
    
    public PersonClass(string name, int age)
    {
        Name = name;
        Age = age;
    }
    
    // Manual Equals
    public override bool Equals(object? obj)
    {
        if (obj is not PersonClass other) return false;
        return Name == other.Name && Age == other.Age;
    }
    
    // Manual GetHashCode
    public override int GetHashCode()
    {
        return HashCode.Combine(Name, Age);
    }
    
    // Manual ToString
    public override string ToString()
    {
        return $"PersonClass {{ Name = {Name}, Age = {Age} }}";
    }
    
    // Manual copy with changes
    public PersonClass WithAge(int newAge)
    {
        return new PersonClass(Name, newAge);
    }
}

// 40+ lines for simple data object!

//  Record - One line!
public record Person(string Name, int Age);

// That's it! Auto-generates:
// - Constructor
// - Properties (init-only)
// - Equals() and GetHashCode() (value-based)
// - ToString()
// - Deconstruct()
// - With expressions

Record Features

public record Person(string Name, int Age);

// Value-based equality
var person1 = new Person("Alice", 30);
var person2 = new Person("Alice", 30);

Console.WriteLine(person1 == person2);  // True! (value equality)
// With classes: False (reference equality)

// Auto ToString()
Console.WriteLine(person1);  // Person { Name = Alice, Age = 30 }

// With expressions (non-destructive mutation)
var person3 = person1 with { Age = 31 };
Console.WriteLine(person3);  // Person { Name = Alice, Age = 31 }
// person1 unchanged (immutable)

// Deconstruction
var (name, age) = person1;
Console.WriteLine($"{name} is {age}");  // Alice is 30

// Pattern matching
var message = person1 switch
{
    { Age: < 18 } => "Minor",
    { Age: >= 18 and < 65 } => "Adult",
    _ => "Senior"
};

// Record (reference type, immutable by default)
public record Person(string Name, int Age);

// Record struct (value type, C# 10+)
public record struct Point(int X, int Y);

// Class (reference type, mutable)
public class PersonClass
{
    public string Name { get; set; }
    public int Age { get; set; }
}

// When to use what?
// Record: DTOs, value objects, immutable data
// Record struct: Small data (< 16 bytes), high-performance scenarios
// Class: Entities with behavior, mutable state

// Additional properties and methods
public record Person(string Name, int Age)
{
    // Computed property
    public string DisplayName => $"{Name} ({Age})";
    
    // Validation
    public Person
    {
        if (Age < 0) throw new ArgumentException("Age cannot be negative");
    }
    
    // Additional methods
    public bool IsAdult() => Age >= 18;
}

// Inheritance (records can inherit from records)
public record Employee(string Name, int Age, string Department) 
    : Person(Name, Age);

var emp = new Employee("Bob", 25, "IT");
Console.WriteLine(emp);  
// Employee { Name = Bob, Age = 25, Department = IT }

// With expression works with derived records
var emp2 = emp with { Department = "HR" };

Perfect for DTOs

// API Request/Response DTOs
public record CreateUserRequest(
    string Email,
    string Name,
    string Password
);

public record UserResponse(
    int Id,
    string Email,
    string Name,
    DateTime CreatedAt
);

// API Controller
[HttpPost("users")]
public async Task CreateUser(CreateUserRequest request)
{
    var user = await _userService.CreateAsync(request);
    return new UserResponse(
        user.Id,
        user.Email,
        user.Name,
        user.CreatedAt
    );
}

// Clean, immutable, perfect for data transfer

// Positional record (concise)
public record Person(string Name, int Age);

// Nominal record (traditional property syntax)
public record Person
{
    public string Name { get; init; }
    public int Age { get; init; }
}

// Mix both
public record Person(string Name, int Age)
{
    public string Email { get; init; } = string.Empty;
    public DateTime CreatedAt { get; init; } = DateTime.UtcNow;
}

var person = new Person("Alice", 30)
{
    Email = "alice@example.com"
};

Benefits of Records

• Less code: 90% less boilerplate than classes
• Immutable by default: Thread-safe, predictable
• Value semantics: Equality based on data, not reference
• With expressions: Easy non-destructive updates
• Pattern matching: Works beautifully with switch
• Auto ToString(): Great for debugging

Best Practices

• Use for DTOs: API requests/responses, messages
• Use for value objects: Money, Address, Coordinate
• Add validation: In constructor or properties
• Keep immutable: Use init, not set
• Prefer positional: More concise for simple records

Real-World Example

// Domain value objects
public record Money(decimal Amount, string Currency)
{
    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException("Currency mismatch");
        return this with { Amount = Amount + other.Amount };
    }
}

public record Address(
    string Street,
    string City,
    string State,
    string ZipCode,
    string Country
);

public record CustomerDto(
    int Id,
    string Name,
    Address Address,
    Money Balance
);

// Usage
var addr = new Address("123 Main St", "NYC", "NY", "10001", "USA");
var balance = new Money(1000m, "USD");
var customer = new CustomerDto(1, "Alice", addr, balance);

// Update address
var updated = customer with 
{ 
    Address = customer.Address with { City = "Boston" }
};

// Value equality
var addr2 = new Address("123 Main St", "NYC", "NY", "10001", "USA");
Console.WriteLine(addr == addr2);  // True!

--  Nested subqueries - Unreadable!
SELECT 
  customer_name,
  total_orders,
  avg_order_value
FROM (
  SELECT 
    c.name AS customer_name,
    COUNT(o.id) AS total_orders,
    AVG(o.total) AS avg_order_value
  FROM customers c
  JOIN (
    SELECT * 
    FROM orders 
    WHERE status = 'completed'
  ) o ON c.id = o.customer_id
  WHERE c.created_at > '2024-01-01'
  GROUP BY c.id, c.name
) customer_stats
WHERE total_orders > 5
ORDER BY avg_order_value DESC;

-- Hard to read, maintain, debug

--  CTE - Step by step, readable
WITH completed_orders AS (
  SELECT * 
  FROM orders 
  WHERE status = 'completed'
),
recent_customers AS (
  SELECT * 
  FROM customers 
  WHERE created_at > '2024-01-01'
),
customer_stats AS (
  SELECT 
    c.id,
    c.name AS customer_name,
    COUNT(o.id) AS total_orders,
    AVG(o.total) AS avg_order_value
  FROM recent_customers c
  JOIN completed_orders o ON c.id = o.customer_id
  GROUP BY c.id, c.name
)
SELECT 
  customer_name,
  total_orders,
  avg_order_value
FROM customer_stats
WHERE total_orders > 5
ORDER BY avg_order_value DESC;

-- Each step has a name!
-- Easy to understand flow
-- Easy to debug each CTE separately

Multiple CTEs

-- Define multiple CTEs with comma separation
WITH 
-- CTE 1: Sales by product
product_sales AS (
  SELECT 
    product_id,
    SUM(quantity) AS total_quantity,
    SUM(total_price) AS total_revenue
  FROM order_items
  WHERE order_date >= '2024-01-01'
  GROUP BY product_id
),
-- CTE 2: Top products
top_products AS (
  SELECT 
    product_id,
    total_revenue
  FROM product_sales
  WHERE total_revenue > 10000
),
-- CTE 3: Product details
product_details AS (
  SELECT 
    p.id,
    p.name,
    p.category,
    tp.total_revenue
  FROM products p
  JOIN top_products tp ON p.id = tp.product_id
)
-- Final query uses all CTEs
SELECT 
  category,
  COUNT(*) AS product_count,
  SUM(total_revenue) AS category_revenue
FROM product_details
GROUP BY category
ORDER BY category_revenue DESC;

-- Hierarchical data: Employee org chart
WITH RECURSIVE employee_hierarchy AS (
  -- Base case: Top-level managers (no manager)
  SELECT 
    id,
    name,
    manager_id,
    1 AS level,
    name AS path
  FROM employees
  WHERE manager_id IS NULL
  
  UNION ALL
  
  -- Recursive case: Employees with managers
  SELECT 
    e.id,
    e.name,
    e.manager_id,
    eh.level + 1,
    eh.path || ' > ' || e.name
  FROM employees e
  JOIN employee_hierarchy eh ON e.manager_id = eh.id
)
SELECT 
  id,
  name,
  level,
  path
FROM employee_hierarchy
ORDER BY level, name;

-- Result:
-- id | name    | level | path
-- 1  | CEO     | 1     | CEO
-- 2  | CTO     | 2     | CEO > CTO
-- 3  | CFO     | 2     | CEO > CFO
-- 4  | Dev1    | 3     | CEO > CTO > Dev1
-- 5  | Dev2    | 3     | CEO > CTO > Dev2

Generate Number Series

-- Generate numbers 1 to 100
WITH RECURSIVE numbers AS (
  SELECT 1 AS n
  UNION ALL
  SELECT n + 1
  FROM numbers
  WHERE n < 100
)
SELECT n FROM numbers;

-- Generate date range
WITH RECURSIVE date_range AS (
  SELECT DATE('2024-01-01') AS date
  UNION ALL
  SELECT DATE(date, '+1 day')
  FROM date_range
  WHERE date < '2024-12-31'
)
SELECT date FROM date_range;

-- Use case: Fill gaps in data
WITH RECURSIVE all_months AS (
  SELECT DATE('2024-01-01') AS month
  UNION ALL
  SELECT DATE(month, '+1 month')
  FROM all_months
  WHERE month < '2024-12-01'
)
SELECT 
  am.month,
  COALESCE(s.revenue, 0) AS revenue
FROM all_months am
LEFT JOIN monthly_sales s ON am.month = s.month;

Dashboard Query

WITH 
-- Today's sales
today_sales AS (
  SELECT SUM(total) AS today_total
  FROM orders
  WHERE DATE(created_at) = CURRENT_DATE
),
-- Yesterday's sales
yesterday_sales AS (
  SELECT SUM(total) AS yesterday_total
  FROM orders
  WHERE DATE(created_at) = CURRENT_DATE - INTERVAL '1 day'
),
-- This month's sales
month_sales AS (
  SELECT SUM(total) AS month_total
  FROM orders
  WHERE DATE_TRUNC('month', created_at) = DATE_TRUNC('month', CURRENT_DATE)
),
-- Active users today
active_users AS (
  SELECT COUNT(DISTINCT user_id) AS active_count
  FROM user_sessions
  WHERE DATE(created_at) = CURRENT_DATE
)
-- Combine all metrics
SELECT 
  ts.today_total,
  ys.yesterday_total,
  ts.today_total - ys.yesterday_total AS daily_change,
  ms.month_total,
  au.active_count
FROM today_sales ts, yesterday_sales ys, month_sales ms, active_users au;

Benefits of CTEs

• Readability: Named steps are self-documenting
• Maintainability: Easy to modify individual steps
• Debugging: Test each CTE separately
• Reusability: Reference same CTE multiple times
• Recursion: Handle hierarchical data

Pro Tips

• Name meaningfully: recent_customers, not temp1
• One CTE per logical step: Don't try to do everything in one
• Debug incrementally: Run each CTE separately first
• Consider performance: CTEs not always faster than subqueries
• Use for recursion: Perfect for trees, graphs

--  Old way: Can't number rows easily
SELECT name, salary, department
FROM employees
ORDER BY salary DESC;

--  Window function: Add row numbers
SELECT 
  ROW_NUMBER() OVER (ORDER BY salary DESC) AS row_num,
  name,
  salary,
  department
FROM employees;

-- Result:
-- row_num | name    | salary | department
-- 1       | Alice   | 120000 | Engineering
-- 2       | Bob     | 110000 | Engineering
-- 3       | Charlie | 100000 | Sales
-- 4       | David   | 95000  | Marketing

-- Row number per department
SELECT 
  ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank,
  name,
  salary,
  department
FROM employees;

-- Result: Separate numbering per department
-- dept_rank | name    | salary | department
-- 1         | Alice   | 120000 | Engineering
-- 2         | Bob     | 110000 | Engineering
-- 1         | Charlie | 100000 | Sales
-- 1         | David   | 95000  | Marketing

RANK() and DENSE_RANK()

-- RANK() - Gaps in ranking for ties
SELECT 
  RANK() OVER (ORDER BY score DESC) AS rank,
  name,
  score
FROM students;

-- score: 100, 100, 95, 90
-- rank:  1,   1,   3,  4  (gap at 2!)

-- DENSE_RANK() - No gaps
SELECT 
  DENSE_RANK() OVER (ORDER BY score DESC) AS rank,
  name,
  score
FROM students;

-- score: 100, 100, 95, 90
-- rank:  1,   1,   2,  3  (no gap)

-- Top 3 salaries per department
SELECT *
FROM (
  SELECT 
    name,
    salary,
    department,
    RANK() OVER (PARTITION BY department ORDER BY salary DESC) AS dept_rank
  FROM employees
) ranked
WHERE dept_rank <= 3;

-- Running total of sales
SELECT 
  order_date,
  amount,
  SUM(amount) OVER (ORDER BY order_date) AS running_total
FROM orders;

-- Result:
-- order_date | amount | running_total
-- 2024-01-01 | 100    | 100
-- 2024-01-02 | 150    | 250  (100 + 150)
-- 2024-01-03 | 200    | 450  (100 + 150 + 200)

-- Running total per customer
SELECT 
  customer_id,
  order_date,
  amount,
  SUM(amount) OVER (
    PARTITION BY customer_id 
    ORDER BY order_date
  ) AS customer_running_total
FROM orders;

-- Separate running total for each customer

-- Compare with previous day
SELECT 
  order_date,
  revenue,
  LAG(revenue) OVER (ORDER BY order_date) AS prev_day_revenue,
  revenue - LAG(revenue) OVER (ORDER BY order_date) AS daily_change
FROM daily_revenue;

-- Result:
-- order_date | revenue | prev_day_revenue | daily_change
-- 2024-01-01 | 1000    | NULL             | NULL
-- 2024-01-02 | 1200    | 1000             | 200
-- 2024-01-03 | 950     | 1200             | -250

-- LEAD() for next row
SELECT 
  order_date,
  revenue,
  LEAD(revenue) OVER (ORDER BY order_date) AS next_day_revenue
FROM daily_revenue;

-- LAG with offset (2 days ago)
SELECT 
  order_date,
  revenue,
  LAG(revenue, 2) OVER (ORDER BY order_date) AS two_days_ago
FROM daily_revenue;

Moving Averages

-- 7-day moving average
SELECT 
  order_date,
  revenue,
  AVG(revenue) OVER (
    ORDER BY order_date
    ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
  ) AS moving_avg_7day
FROM daily_revenue;

-- 3-month moving average
SELECT 
  month,
  total_sales,
  AVG(total_sales) OVER (
    ORDER BY month
    ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
  ) AS moving_avg_3month
FROM monthly_sales;

-- Divide customers into 4 quartiles by spend
SELECT 
  customer_id,
  total_spend,
  NTILE(4) OVER (ORDER BY total_spend DESC) AS quartile
FROM customer_totals;

-- Result:
-- customer_id | total_spend | quartile
-- 101         | 50000       | 1  (top 25%)
-- 102         | 48000       | 1
-- 103         | 30000       | 2
-- 104         | 28000       | 2
-- 105         | 15000       | 3
-- 106         | 12000       | 3
-- 107         | 5000        | 4  (bottom 25%)
-- 108         | 3000        | 4

-- Use case: Segment customers
SELECT quartile, COUNT(*) as customer_count
FROM (
  SELECT NTILE(4) OVER (ORDER BY total_spend DESC) AS quartile
  FROM customer_totals
) quartiles
GROUP BY quartile;

Real-World Examples

Pagination

-- Page 2, 10 items per page
SELECT *
FROM (
  SELECT 
    ROW_NUMBER() OVER (ORDER BY created_at DESC) AS row_num,
    *
  FROM posts
) numbered
WHERE row_num BETWEEN 11 AND 20;

Top N Per Group

-- Top 5 products per category by sales
SELECT category, product_name, total_sales
FROM (
  SELECT 
    category,
    product_name,
    total_sales,
    ROW_NUMBER() OVER (
      PARTITION BY category 
      ORDER BY total_sales DESC
    ) AS rank
  FROM product_sales
) ranked
WHERE rank <= 5;

Percentage of Total

SELECT 
  product,
  sales,
  sales * 100.0 / SUM(sales) OVER () AS pct_of_total
FROM product_sales;

-- Result:
-- product | sales | pct_of_total
-- A       | 5000  | 50.0
-- B       | 3000  | 30.0
-- C       | 2000  | 20.0

Window Function Syntax

 OVER (
  [PARTITION BY column]   -- Optional: Group by
  [ORDER BY column]       -- Optional: Sort order
  [ROWS/RANGE clause]     -- Optional: Frame specification
)

-- Common functions:
-- ROW_NUMBER(), RANK(), DENSE_RANK()
-- SUM(), AVG(), MIN(), MAX(), COUNT()
-- LAG(), LEAD()
-- FIRST_VALUE(), LAST_VALUE()
-- NTILE()

public class EmailProcessorService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _serviceProvider;

    public EmailProcessorService(
        ILogger logger,
        IServiceProvider serviceProvider)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Email Processor Service started");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Create scope for scoped services
                using var scope = _serviceProvider.CreateScope();
                var emailService = scope.ServiceProvider.GetRequiredService();

                // Process pending emails
                await emailService.ProcessPendingEmailsAsync();

                _logger.LogInformation("Processed emails at {Time}", DateTime.UtcNow);

                // Wait 1 minute before next run
                await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing emails");
                await Task.Delay(TimeSpan.FromSeconds(30), stoppingToken);
            }
        }

        _logger.LogInformation("Email Processor Service stopped");
    }
}

// Register in Program.cs
builder.Services.AddHostedService();

Timed Background Service

public class CleanupService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _serviceProvider;
    private Timer? _timer;

    public CleanupService(
        ILogger logger,
        IServiceProvider serviceProvider)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Cleanup Service started");

        // Run every hour
        _timer = new Timer(
            DoWork,
            null,
            TimeSpan.Zero,  // Start immediately
            TimeSpan.FromHours(1));  // Run every hour

        return Task.CompletedTask;
    }

    private async void DoWork(object? state)
    {
        _logger.LogInformation("Cleanup running at {Time}", DateTime.UtcNow);

        try
        {
            using var scope = _serviceProvider.CreateScope();
            var dbContext = scope.ServiceProvider.GetRequiredService();

            // Delete old records
            var cutoffDate = DateTime.UtcNow.AddDays(-30);
            var oldRecords = await dbContext.Logs
                .Where(l => l.CreatedAt < cutoffDate)
                .ToListAsync();

            dbContext.Logs.RemoveRange(oldRecords);
            await dbContext.SaveChangesAsync();

            _logger.LogInformation("Deleted {Count} old records", oldRecords.Count);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error during cleanup");
        }
    }

    public override Task StopAsync(CancellationToken cancellationToken)
    {
        _timer?.Change(Timeout.Infinite, 0);
        _logger.LogInformation("Cleanup Service stopped");
        return base.StopAsync(cancellationToken);
    }

    public override void Dispose()
    {
        _timer?.Dispose();
        base.Dispose();
    }
}

public class OrderProcessingService : BackgroundService
{
    private readonly ILogger _logger;
    private readonly IServiceProvider _serviceProvider;

    public OrderProcessingService(
        ILogger logger,
        IServiceProvider serviceProvider)
    {
        _logger = logger;
        _serviceProvider = serviceProvider;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                using var scope = _serviceProvider.CreateScope();
                var orderQueue = scope.ServiceProvider.GetRequiredService();
                var orderService = scope.ServiceProvider.GetRequiredService();

                // Dequeue and process orders
                var order = await orderQueue.DequeueAsync(stoppingToken);

                if (order != null)
                {
                    _logger.LogInformation("Processing order {OrderId}", order.Id);

                    await orderService.ProcessAsync(order);
                    await orderQueue.CompleteAsync(order.Id);

                    _logger.LogInformation("Order {OrderId} processed", order.Id);
                }
                else
                {
                    // No orders in queue, wait a bit
                    await Task.Delay(TimeSpan.FromSeconds(5), stoppingToken);
                }
            }
            catch (OperationCanceledException)
            {
                // Expected when stopping
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error processing order");
                await Task.Delay(TimeSpan.FromSeconds(10), stoppingToken);
            }
        }
    }
}

Health Check Integration

public class MonitoringService : BackgroundService
{
    private readonly ILogger _logger;
    private DateTime _lastRunTime = DateTime.MinValue;
    public bool IsHealthy { get; private set; } = true;

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                // Do monitoring work
                await MonitorSystemAsync();

                _lastRunTime = DateTime.UtcNow;
                IsHealthy = true;

                await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Monitoring failed");
                IsHealthy = false;
            }
        }
    }

    private async Task MonitorSystemAsync()
    {
        // Check system health
        _logger.LogInformation("System healthy at {Time}", DateTime.UtcNow);
    }
}

// Health check
public class BackgroundServiceHealthCheck : IHealthCheck
{
    private readonly MonitoringService _monitoringService;

    public BackgroundServiceHealthCheck(MonitoringService monitoringService)
    {
        _monitoringService = monitoringService;
    }

    public Task CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        if (_monitoringService.IsHealthy)
        {
            return Task.FromResult(HealthCheckResult.Healthy("Monitoring service running"));
        }

        return Task.FromResult(HealthCheckResult.Unhealthy("Monitoring service failed"));
    }
}

// Register
builder.Services.AddSingleton();
builder.Services.AddHostedService(sp => sp.GetRequiredService());
builder.Services.AddHealthChecks()
    .AddCheck("monitoring-service");

Common Use Cases

• Email queue processing: Send emails asynchronously
• Data cleanup: Delete old logs, cache entries
• Report generation: Generate daily/weekly reports
• Cache warming: Preload cache on schedule
• Health monitoring: Check external service health
• Batch processing: Process large datasets in background

Best Practices

• Use IServiceProvider: Create scopes for scoped services
• Handle CancellationToken: Graceful shutdown support
• Add error handling: Don't let exceptions stop service
• Log everything: Track service lifecycle and errors
• Use delays, not while(true): Avoid CPU spinning
• Dispose resources: Override Dispose() when needed

//  Traditional Controller (verbose)
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
    
    public UsersController(IUserService userService)
    {
        _userService = userService;
    }
    
    [HttpGet]
    public async Task>> GetUsers()
    {
        var users = await _userService.GetAllAsync();
        return Ok(users);
    }
    
    [HttpGet("{id}")]
    public async Task> GetUser(int id)
    {
        var user = await _userService.GetByIdAsync(id);
        if (user == null) return NotFound();
        return Ok(user);
    }
    
    [HttpPost]
    public async Task> CreateUser(User user)
    {
        var created = await _userService.CreateAsync(user);
        return CreatedAtAction(nameof(GetUser), new { id = created.Id }, created);
    }
}

// Many files, boilerplate code, ceremony

//  Minimal API (concise!)
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddScoped();

var app = builder.Build();

app.MapGet("/api/users", async (IUserService service) => 
    await service.GetAllAsync());

app.MapGet("/api/users/{id}", async (int id, IUserService service) =>
{
    var user = await service.GetByIdAsync(id);
    return user is not null ? Results.Ok(user) : Results.NotFound();
});

app.MapPost("/api/users", async (User user, IUserService service) =>
{
    var created = await service.CreateAsync(user);
    return Results.Created($"/api/users/{created.Id}", created);
});

app.Run();

// Everything in Program.cs, minimal code!

Complete CRUD Example

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddDbContext();
builder.Services.AddScoped();

var app = builder.Build();

// GET all users
app.MapGet("/api/users", async (IUserRepository repo) =>
{
    var users = await repo.GetAllAsync();
    return Results.Ok(users);
})
.WithName("GetUsers")
.Produces>(200);

// GET user by ID
app.MapGet("/api/users/{id:int}", async (int id, IUserRepository repo) =>
{
    var user = await repo.GetByIdAsync(id);
    return user is not null 
        ? Results.Ok(user) 
        : Results.NotFound(new { message = "User not found" });
})
.WithName("GetUser")
.Produces(200)
.Produces(404);

// POST create user
app.MapPost("/api/users", async (User user, IUserRepository repo) =>
{
    if (string.IsNullOrWhiteSpace(user.Name))
        return Results.BadRequest(new { message = "Name is required" });
    
    var created = await repo.CreateAsync(user);
    return Results.CreatedAtRoute("GetUser", new { id = created.Id }, created);
})
.Accepts("application/json")
.Produces(201)
.Produces(400);

// PUT update user
app.MapPut("/api/users/{id:int}", async (int id, User user, IUserRepository repo) =>
{
    var existing = await repo.GetByIdAsync(id);
    if (existing is null)
        return Results.NotFound();
    
    user.Id = id;
    await repo.UpdateAsync(user);
    return Results.NoContent();
})
.Produces(204)
.Produces(404);

// DELETE user
app.MapDelete("/api/users/{id:int}", async (int id, IUserRepository repo) =>
{
    var deleted = await repo.DeleteAsync(id);
    return deleted 
        ? Results.NoContent() 
        : Results.NotFound();
})
.Produces(204)
.Produces(404);

app.Run();

// Services automatically injected from DI
app.MapGet("/api/products", async (
    IProductService productService,  // Injected
    ILogger logger,          // Injected
    HttpContext context) =>           // Also available
{
    logger.LogInformation("Getting products for user {User}", context.User.Identity?.Name);
    return await productService.GetAllAsync();
});

// Multiple services
app.MapPost("/api/orders", async (
    Order order,
    IOrderService orderService,
    IInventoryService inventoryService,
    IEmailService emailService) =>
{
    var created = await orderService.CreateAsync(order);
    await inventoryService.UpdateStockAsync(order.Items);
    await emailService.SendOrderConfirmationAsync(created);
    return Results.Created($"/api/orders/{created.Id}", created);
});

Authentication & Authorization

// Add auth services
builder.Services.AddAuthentication()
    .AddJwtBearer();
builder.Services.AddAuthorization();

var app = builder.Build();

app.UseAuthentication();
app.UseAuthorization();

// Require authentication
app.MapGet("/api/profile", async (HttpContext context) =>
{
    return Results.Ok(new { user = context.User.Identity?.Name });
})
.RequireAuthorization();  // Requires authenticated user

// Require specific role
app.MapDelete("/api/users/{id}", async (int id, IUserRepository repo) =>
{
    await repo.DeleteAsync(id);
    return Results.NoContent();
})
.RequireAuthorization("AdminOnly");

// Require policy
app.MapPost("/api/admin/config", async (Config config) =>
{
    // Admin action
})
.RequireAuthorization(policy => policy.RequireRole("Admin"));

// Install: FluentValidation.AspNetCore
builder.Services.AddValidatorsFromAssemblyContaining();

// Validator
public class CreateUserValidator : AbstractValidator
{
    public CreateUserValidator()
    {
        RuleFor(x => x.Email).NotEmpty().EmailAddress();
        RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
        RuleFor(x => x.Age).GreaterThan(0).LessThan(150);
    }
}

// Endpoint with validation
app.MapPost("/api/users", async (
    CreateUserDto dto,
    IValidator validator,
    IUserService service) =>
{
    var validationResult = await validator.ValidateAsync(dto);
    if (!validationResult.IsValid)
    {
        return Results.ValidationProblem(validationResult.ToDictionary());
    }
    
    var user = await service.CreateAsync(dto);
    return Results.Created($"/api/users/{user.Id}", user);
});

// Global exception handler
app.UseExceptionHandler(exceptionHandlerApp =>
{
    exceptionHandlerApp.Run(async context =>
    {
        context.Response.StatusCode = 500;
        context.Response.ContentType = "application/json";
        
        var error = context.Features.Get();
        if (error != null)
        {
            await context.Response.WriteAsJsonAsync(new
            {
                error = "An error occurred",
                detail = error.Error.Message
            });
        }
    });
});

Benefits of Minimal APIs

• Less code: 50-70% less boilerplate than controllers
• Faster startup: Reduced overhead
• Easy to understand: Everything in one place
• Perfect for microservices: Lightweight, focused
• Modern C# features: Top-level statements, implicit usings

Pro Tips

• Use route groups: Group related endpoints
• Add Swagger: builder.Services.AddEndpointsApiExplorer()
• Organize endpoints: Use extension methods for large apps
• Add filters: .AddEndpointFilter() for cross-cutting concerns
• Use Results: Results.Ok(), Results.NotFound() for typed responses

When to Use Minimal APIs

Use Minimal APIs	Use Controllers
Microservices	Large monolithic apps
Simple CRUD APIs	Complex business logic
Prototypes, POCs	Team prefers MVC patterns
Serverless functions	Need attribute routing features
Quick HTTP services	Established codebase with controllers

# Scenario: Bug fix on wrong branch
git branch
* feature-login
  main
  hotfix

# You committed bug fix to feature-login
# But it needs to be on hotfix branch too!

git log --oneline
a1b2c3d Fix critical security bug  ← Need this on hotfix!
d4e5f6g Add login form
g7h8i9j Update styles

# Don't want to merge entire feature branch
# Just need the security fix

# Switch to target branch
git checkout hotfix

# Cherry-pick the commit
git cherry-pick a1b2c3d

# Done! Commit copied to hotfix branch
git log --oneline
a1b2c3d Fix critical security bug  ← Same commit, now on hotfix!
x7y8z9a Previous hotfix commit

Common Use Cases

1. Bug Fix on Wrong Branch

# Fixed bug on feature branch, need on main
git checkout main
git cherry-pick abc123

# Or cherry-pick from another person's branch
git cherry-pick origin/their-branch-name~2  # 2 commits ago

2. Apply Multiple Commits

# Cherry-pick range of commits
git cherry-pick abc123..def456

# Cherry-pick multiple specific commits
git cherry-pick abc123 def456 ghi789

# Cherry-pick all commits from another branch
git cherry-pick feature-branch

3. Hotfix to Multiple Versions

# Apply same fix to v1.0, v2.0, v3.0 branches
git checkout v1.0-stable
git cherry-pick abc123

git checkout v2.0-stable
git cherry-pick abc123

git checkout v3.0-stable
git cherry-pick abc123

# Same fix on all versions!

git cherry-pick abc123

# If conflicts:
# CONFLICT (content): Merge conflict in file.js

# Fix conflicts
vim file.js  # Resolve conflicts

# Mark as resolved
git add file.js

# Continue cherry-pick
git cherry-pick --continue

# Or abort
git cherry-pick --abort

Advanced Options

# Cherry-pick without committing (stage changes only)
git cherry-pick -n abc123
# Make modifications, then commit manually

# Cherry-pick and edit commit message
git cherry-pick -e abc123

# Add 'cherry picked from' note to commit message
git cherry-pick -x abc123
# Adds: (cherry picked from commit abc123)

# Cherry-pick but with different author
git cherry-pick abc123
git commit --amend --author="John Doe "

# Cherry-pick only the changes, not the commit
git cherry-pick -n abc123
git reset  # Unstage
# Now you have changes in working directory

Production Hotfix Workflow

# Bug found in production!
# Create hotfix branch from main
git checkout main
git checkout -b hotfix-critical-bug

# Fix bug, commit
git commit -m "Fix critical login bug"
# Commit hash: xyz789

# Deploy hotfix to production
git checkout main
git merge hotfix-critical-bug
git push

# Now cherry-pick to development branch
git checkout develop
git cherry-pick xyz789

# Now cherry-pick to all active feature branches
git checkout feature-new-ui
git cherry-pick xyz789

git checkout feature-api-v2
git cherry-pick xyz789

# Same fix everywhere!

When to Use Cherry-Pick

• Bug fixes: Apply to multiple branches/versions
• Backporting: Bring new features to old versions
• Mistakes: Commit on wrong branch, move it
• Selective merging: Want some commits, not all
• Team collaboration: Grab colleague’s commit

Caveats

• Creates duplicate commits: Same change, different hash
• Can cause conflicts: If code has diverged
• Loses context: Commit might not make sense alone
• Tracking is harder: Git doesn’t track cherry-picks automatically
• Prefer merge when possible: Cherry-pick is for exceptions

Pro Tips

# Find commits to cherry-pick
git log --oneline --graph branch-name

# Cherry-pick from reflog (even deleted commits!)
git reflog
git cherry-pick abc123

# Test before cherry-picking
git show abc123  # View commit changes

# Cherry-pick merge commit (requires -m)
git cherry-pick -m 1 merge-commit-hash
# -m 1 means use first parent

# Undo cherry-pick
git reset --hard HEAD~1  # If not pushed
git revert commit-hash   # If already pushed

Cheat Sheet

Command	Action
git cherry-pick abc123	Apply single commit
git cherry-pick abc..def	Apply range of commits
git cherry-pick -n abc123	Don’t commit (stage only)
git cherry-pick -x abc123	Add source note to message
git cherry-pick --continue	Continue after conflict
git cherry-pick --abort	Cancel cherry-pick

git log --oneline

a1b2c3d fix typo
d4e5f6g WIP
g7h8i9j oops forgot file
j1k2l3m fix typo again
m4n5o6p actually fix the bug
p7q8r9s Add feature X

# 6 commits for 1 feature!
# Confusing for code review
# Clutters git history

# Rebase last 6 commits
git rebase -i HEAD~6

# Or rebase from specific commit
git rebase -i a1b2c3d

# Editor opens with commit list:
pick a1b2c3d fix typo
pick d4e5f6g WIP
pick g7h8i9j oops forgot file
pick j1k2l3m fix typo again
pick m4n5o6p actually fix the bug
pick p7q8r9s Add feature X

# Commands available:
# pick   = use commit
# reword = use commit, but edit message
# edit   = use commit, but stop for amending
# squash = use commit, combine with previous
# fixup  = like squash, discard commit message
# drop   = remove commit

Common Rebase Actions

1. Squash Commits

# Combine multiple commits into one
pick p7q8r9s Add feature X
squash m4n5o6p actually fix the bug
squash j1k2l3m fix typo again
squash g7h8i9j oops forgot file
squash d4e5f6g WIP
squash a1b2c3d fix typo

# Save and close
# New editor opens for combined commit message
# Result: 6 commits → 1 clean commit

2. Fixup (Squash Without Message)

pick p7q8r9s Add feature X
fixup m4n5o6p actually fix the bug
fixup j1k2l3m fix typo again
fixup g7h8i9j oops forgot file
fixup d4e5f6g WIP
fixup a1b2c3d fix typo

# Like squash, but automatically uses first commit's message
# No need to edit combined message

3. Reword Commit Messages

reword a1b2c3d fix typo
pick d4e5f6g Add authentication

# Editor opens for each 'reword'
# Change message, save, continue

4. Reorder Commits

# Just reorder lines
pick d4e5f6g Add tests
pick a1b2c3d Add feature
pick g7h8i9j Update docs

# Changes order in history

5. Drop Commits

pick a1b2c3d Add feature
drop d4e5f6g debug logging
pick g7h8i9j Update docs

# Or just delete the line (same effect)
pick a1b2c3d Add feature
pick g7h8i9j Update docs

Before PR Cleanup

# You've been working on feature branch
git log --oneline
a1b2c3d fix lint error
d4e5f6g remove console.log
g7h8i9j WIP save work
j1k2l3m add login component
m4n5o6p fix button style
p7q8r9s add logout
q1r2s3t initial auth setup

# Clean up before PR
git rebase -i HEAD~7

# In editor:
pick q1r2s3t initial auth setup
fixup j1k2l3m add login component
fixup p7q8r9s add logout
fixup m4n5o6p fix button style
fixup g7h8i9j WIP save work
fixup d4e5f6g remove console.log
fixup a1b2c3d fix lint error

# Save, close
# Result: 1 clean commit "Add authentication system"

git log --oneline
t4u5v6w Add authentication system

# Beautiful history for PR!

# If conflicts during rebase
git rebase -i HEAD~5

# Git stops:
# CONFLICT (content): Merge conflict in file.js

# Fix conflicts in file
vim file.js  # Resolve conflicts

# Mark as resolved
git add file.js

# Continue rebase
git rebase --continue

# Or abort if things go wrong
git rebase --abort

When to Use Interactive Rebase

• Before PR/MR: Clean up feature branch history
• WIP commits: Squash ‘work in progress’ commits
• Fix commit messages: Typos, unclear messages
• Reorder logical flow: Tests before implementation
• Remove sensitive data: Accidentally committed secrets

Important Rules

• Never rebase public branches: Only rebase local/feature branches
• Don’t rebase after push: Rewrites history, breaks others’ work
• Force push required: git push –force-with-lease after rebase
• Communicate with team: If others are working on same branch
• Keep backups: git branch backup-branch before rebase

Pro Tips

# Auto-squash: Prepare commits for easy squashing
git commit --fixup a1b2c3d  # Creates fixup! commit
git rebase -i --autosquash HEAD~10  # Auto-arranges fixups

# Set autosquash as default
git config --global rebase.autosquash true

# Use different editor
git config --global core.editor "code --wait"

# Rebase onto different branch
git rebase -i main  # Rebase current branch onto main

# Split a commit
# 1. Mark commit as 'edit'
# 2. Git stops at that commit
# 3. git reset HEAD^
# 4. git add -p (stage hunks separately)
# 5. git commit (multiple times)
# 6. git rebase --continue

Cheat Sheet

Command	Action
git rebase -i HEAD~N	Rebase last N commits
pick	Keep commit as-is
squash	Combine with previous
fixup	Squash, discard message
reword	Edit commit message
drop	Remove commit
git rebase --abort	Cancel rebase