C# ref vs out — Silent Data Corruption from Wrong Keyword

using System;

class GreetingApp
{
    // This method has no parameters and returns nothing (void).
    // It just performs an action — printing a greeting.
    static void PrintWelcomeMessage()
    {
        Console.WriteLine("Welcome to TheCodeForge!");
        Console.WriteLine("Let's learn C# methods together.");
    }

    static void Main(string[] args)
    {
        // Calling the method — C# jumps up, runs the code, then comes back here.
        PrintWelcomeMessage();

        Console.WriteLine("Back in Main after the method finished.");

        // You can call the same method as many times as you want.
        // This is the whole point — write once, reuse everywhere.
        PrintWelcomeMessage();
    }
}

using System;

class CafeOrderCalculator
{
    // This method takes two parameters:
    // - itemPrice: the cost of one item (a decimal number)
    // - quantity: how many the customer wants (a whole number)
    // It returns a double — the total cost before tax.
    static double CalculateSubtotal(double itemPrice, int quantity)
    {
        double subtotal = itemPrice * quantity; // core calculation
        return subtotal; // hand the result back to whoever called us
    }

    // This method takes a subtotal and applies a tax rate percentage.
    // taxRatePercent is passed as a number like 8.5 meaning 8.5%.
    static double ApplyTax(double subtotal, double taxRatePercent)
    {
        double taxAmount = subtotal * (taxRatePercent / 100);
        return subtotal + taxAmount; // total including tax
    }

    // Formats the final bill as a readable string for the receipt.
    static string FormatReceiptLine(string itemName, double totalCost)
    {
        // $ before the variable name is NOT a C# thing — this is inside a string.
        // The colon F2 means: format as a number with 2 decimal places.
        return $"{itemName}: ${totalCost:F2}";
    }

    static void Main(string[] args)
    {
        // "coffeePrice" and "numberOfCoffees" are ARGUMENTS — real values passed in.
        double coffeePrice = 3.50;
        int numberOfCoffees = 4;

        // The return value of CalculateSubtotal is stored in a new variable.
        double coffeeSubtotal = CalculateSubtotal(coffeePrice, numberOfCoffees);
        Console.WriteLine($"Subtotal for {numberOfCoffees} coffees: ${coffeeSubtotal:F2}");

        // Pass the subtotal into the next method — chaining method calls.
        double totalWithTax = ApplyTax(coffeeSubtotal, 8.5);
        Console.WriteLine($"Total with 8.5% tax: ${totalWithTax:F2}");

        // Pass the result into FormatReceiptLine for a clean receipt string.
        string receiptLine = FormatReceiptLine("Flat White x4", totalWithTax);
        Console.WriteLine("--- Receipt ---");
        Console.WriteLine(receiptLine);
    }
}

using System;

class NotificationService
{
    // Optional parameter: 'isUrgent' defaults to false if not provided.
    // Required parameter 'recipientName' must always be supplied — it has no default.
    static void SendNotification(string recipientName, string message, bool isUrgent = false)
    {
        string prefix = isUrgent ? "[URGENT] " : ""; // ternary: if urgent add prefix
        Console.WriteLine($"To: {recipientName} | {prefix}{message}");
    }

    // OVERLOAD 1: Calculate area of a square — only needs one measurement.
    static double CalculateArea(double sideLength)
    {
        Console.WriteLine("Calculating square area...");
        return sideLength * sideLength;
    }

    // OVERLOAD 2: Calculate area of a rectangle — needs two measurements.
    // Same method name, different parameters — C# picks the right one automatically.
    static double CalculateArea(double width, double height)
    {
        Console.WriteLine("Calculating rectangle area...");
        return width * height;
    }

    static void Main(string[] args)
    {
        // --- Optional Parameters ---
        // Calling without the optional parameter — isUrgent defaults to false.
        SendNotification("Alice", "Your order has shipped.");

        // Calling with the optional parameter explicitly set to true.
        SendNotification("Bob", "Server is down!", true);

        // Named argument — we skip the positional rule and name the parameter.
        // This is especially helpful when a method has many parameters.
        SendNotification(recipientName: "Carol", message: "Meeting at 3pm", isUrgent: false);

        Console.WriteLine();

        // --- Method Overloading ---
        // C# sees one argument — calls the square overload.
        double squareArea = CalculateArea(5.0);
        Console.WriteLine($"Square area: {squareArea} sq units");

        Console.WriteLine();

        // C# sees two arguments — calls the rectangle overload.
        double rectangleArea = CalculateArea(4.0, 7.5);
        Console.WriteLine($"Rectangle area: {rectangleArea} sq units");
    }
}

using System;

class ParameterPassingDemo
{
    // VALUE type parameter — receives a COPY of the original.
    // Doubling the copy does NOT affect the original variable.
    static void TryToDoubleScore(int playerScore)
    {
        playerScore = playerScore * 2; // only the local copy changes
        Console.WriteLine($"  Inside method, playerScore = {playerScore}");
    }

    // REF parameter — receives a REFERENCE to the original.
    // Doubling here WILL affect the original variable.
    static void ActuallyDoubleScore(ref int playerScore)
    {
        playerScore = playerScore * 2; // the original changes!
        Console.WriteLine($"  Inside method (ref), playerScore = {playerScore}");
    }

    // OUT parameter — used to return multiple results from one method.
    // The caller doesn't need to initialise 'quotient' or 'remainder' beforehand.
    // But this method MUST assign them before it returns.
    static void DivideWithRemainder(int dividend, int divisor, out int quotient, out int remainder)
    {
        quotient = dividend / divisor;   // integer division
        remainder = dividend % divisor;  // modulo gives the leftover
    }

    static void Main(string[] args)
    {
        // --- Value Parameter Demo ---
        int currentScore = 100;
        Console.WriteLine("-- Value Parameter (copy) --");
        Console.WriteLine($"Before call: currentScore = {currentScore}");
        TryToDoubleScore(currentScore); // passes a copy
        Console.WriteLine($"After call:  currentScore = {currentScore}"); // unchanged!

        Console.WriteLine();

        // --- Ref Parameter Demo ---
        Console.WriteLine("-- Ref Parameter (original) --");
        Console.WriteLine($"Before call: currentScore = {currentScore}");
        ActuallyDoubleScore(ref currentScore); // 'ref' required at both definition AND call site
        Console.WriteLine($"After call:  currentScore = {currentScore}"); // changed!

        Console.WriteLine();

        // --- Out Parameter Demo ---
        Console.WriteLine("-- Out Parameter (multiple returns) --");
        int howManyTimes;
        int leftOver;
        // 'out' keyword required at the call site too — clear signal that values will be set.
        DivideWithRemainder(17, 5, out howManyTimes, out leftOver);
        Console.WriteLine($"17 divided by 5 = {howManyTimes} remainder {leftOver}");
    }
}

using System;

class UserService
{
    // Good: one job, clear name, few parameters.
    static string FormatUserName(string firstName, string lastName)
    {
        // Local variable — only exists inside this method.
        string formatted = $"{lastName}, {firstName}".Trim();
        return formatted;
    }

    // Bad: multiple responsibilities (formatting + saving logic not shown)
    // Bad: hidden side effect — imagine it also logs to a file implicitly.
    static void SaveUser(int userId, string name)
    {
        // ... save logic ...
        Console.WriteLine($"Saved user {name}");
    }

    static void Main(string[] args)
    {
        string fullName = FormatUserName("John", "Doe");
        Console.WriteLine(fullName); // Output: "Doe, John"

        // Local variable 'fullName' is used here, not accessible inside the method.
        SaveUser(101, fullName);
    }
}

using System;

public class Logger
{
    // This compiles fine but is a runtime minefield
    public static void Log(params object[] args)
    {
        foreach (var arg in args)
        {
            // Assume all args are strings — risky business
            Console.WriteLine(arg.ToString().ToUpper());
        }
    }
}

public class Program
{
    public static void Main()
    {
        Logger.Log("User", 42, null);  // No compile error
        // Output: USER, 42, then NullReferenceException
    }
}

using System;

public struct LargeStruct
{
    public int X, Y, Z;
    public LargeStruct(int x, int y, int z) { X = x; Y = y; Z = z; }
}

public class DataStore
{
    private LargeStruct[] _items = new LargeStruct[1000];

    public ref LargeStruct GetItem(int index)
    {
        // Returns a reference to the actual array element — no copy
        return ref _items[index];
    }
}

public class Program
{
    public static void Main()
    {
        var store = new DataStore();
        ref var item = ref store.GetItem(42);  // ref local required
        item.X = 100;  // Direct mutation of internal array
        Console.WriteLine(store.GetItem(42).X);  // Output: 100
    }
}