C# Strings — Turkish 'i' Bug Breaks Logins

using System;

class StringBasics
{
    static void Main()
    {
        // Declaring a string with a literal value
        string greeting = "Hello, World!";

        // string (lowercase) is just an alias for System.String
        // Both of these lines are identical in behaviour
        string firstName = "Alice";
        System.String lastName = "Johnson"; // same type, different spelling

        // Strings can contain letters, numbers, symbols, even spaces
        string emailAddress = "alice.johnson@example.com";
        string productCode = "ITEM-2024-XL";

        // An empty string — valid and very common
        string emptyText = "";

        // string.Empty is the recommended way to represent an empty string
        // It's more expressive and avoids any confusion with null
        string alsoEmpty = string.Empty;

        // Proving immutability — 'greeting' is not modified.
        // ToUpper() creates and returns a BRAND NEW string.
        // The original 'greeting' still holds "Hello, World!"
        string shoutedGreeting = greeting.ToUpper();

        Console.WriteLine(greeting);        // original — unchanged
        Console.WriteLine(shoutedGreeting); // new string
        Console.WriteLine(firstName + " " + lastName);
        Console.WriteLine(emailAddress);
        Console.WriteLine("Is emptyText empty? " + string.IsNullOrEmpty(emptyText));
    }
}

using System;

class StringCombining
{
    static void Main()
    {
        string userName = "Alice";
        int notificationCount = 3;
        double accountBalance = 1025.50;

        // --- METHOD 1: Concatenation with + ---
        // Works fine for simple cases, gets messy with many variables
        string welcomeMessage = "Good morning, " + userName + "! You have "
                                + notificationCount + " new notifications.";
        Console.WriteLine(welcomeMessage);

        // --- METHOD 2: String Interpolation (RECOMMENDED for modern C#) ---
        // The $ prefix enables interpolation. Expressions go inside { }
        // You can put ANY valid C# expression inside the braces
        string interpolatedMessage = $"Good morning, {userName}! You have {notificationCount} new notifications.";
        Console.WriteLine(interpolatedMessage);

        // Interpolation also supports formatting specifiers after a colon
        // :C formats as currency, :F2 forces 2 decimal places
        string balanceMessage = $"Your balance is {accountBalance:C} as of today.";
        Console.WriteLine(balanceMessage);

        // You can even call methods inside the braces
        string upperCaseName = $"Username in capitals: {userName.ToUpper()}";
        Console.WriteLine(upperCaseName);

        // --- METHOD 3: string.Format() — older style, still common in legacy code ---
        // {0}, {1} etc. are placeholders replaced by the arguments that follow
        string formattedMessage = string.Format("Hello, {0}. Your balance is {1:C}.", userName, accountBalance);
        Console.WriteLine(formattedMessage);

        // --- METHOD 4: Verbatim strings with @ ---
        // Without @, backslashes need escaping: "C:\\Users\\Alice\\Documents"
        // With @, you write it exactly as it looks — no escaping needed
        string filePath = @"C:\Users\Alice\Documents\report.pdf";
        Console.WriteLine(filePath);

        // Verbatim strings also support multiple lines — the line breaks are included
        string multiLineAddress = @"123 Maple Street
Springfield
IL 62701";
        Console.WriteLine(multiLineAddress);
    }
}

using System;

class StringMethods
{
    static void Main()
    {
        string userInput = "   alice.johnson@example.com   ";
        string productDescription = "The Red Bicycle is fast, reliable, and red.";
        string fullName = "Alice Johnson";
        string csvLine = "London,Paris,Tokyo,Sydney";

        // --- Length ---
        // Returns the number of characters (spaces count!)
        Console.WriteLine($"Raw input length: {userInput.Length}"); // includes the spaces

        // --- Trim ---
        // Removes leading and trailing whitespace — essential for cleaning user input
        string cleanEmail = userInput.Trim();
        Console.WriteLine($"Cleaned email: '{cleanEmail}'");
        Console.WriteLine($"Clean length: {cleanEmail.Length}");

        // --- ToLower / ToUpper ---
        // Useful for case-insensitive comparisons or display formatting
        string normalizedEmail = cleanEmail.ToLower();
        Console.WriteLine($"Normalised: {normalizedEmail}");

        // --- Contains ---
        // Returns true or false — checks if a substring exists anywhere inside
        bool hasAtSymbol = cleanEmail.Contains("@");
        Console.WriteLine($"Is it an email? {hasAtSymbol}");

        // --- StartsWith / EndsWith ---
        bool isHttps = "https://thecodeforge.io".StartsWith("https");
        bool isPdf = "report.pdf".EndsWith(".pdf");
        Console.WriteLine($"Secure URL: {isHttps}, Is PDF: {isPdf}");

        // --- IndexOf ---
        // Returns the ZERO-BASED position of the first match, or -1 if not found
        int atPosition = cleanEmail.IndexOf("@");
        Console.WriteLine($"'@' is at index: {atPosition}");

        // --- Substring ---
        // Substring(startIndex) extracts from startIndex to the end
        // Substring(startIndex, length) extracts exactly 'length' characters
        string domainPart = cleanEmail.Substring(atPosition + 1); // everything after @
        Console.WriteLine($"Domain: {domainPart}");

        string extractedFirstName = fullName.Substring(0, 5); // first 5 chars
        Console.WriteLine($"First name extracted: {extractedFirstName}");

        // --- Replace ---
        // Replaces ALL occurrences, not just the first one
        string correctedDescription = productDescription.Replace("red", "blue");
        Console.WriteLine(correctedDescription);

        // --- Split ---
        // Breaks a string into an array at every occurrence of the separator
        string[] cities = csvLine.Split(',');
        Console.WriteLine($"Number of cities: {cities.Length}");
        foreach (string city in cities)
        {
            Console.WriteLine($"  City: {city}");
        }
    }
}

using System;
using System.Text; // Required for StringBuilder

class StringComparisonAndBuilder
{
    static void Main()
    {
        // =====================================================
        // PART 1: String Comparison Done Right
        // =====================================================

        string storedUsername = "Alice";
        string inputFromUser = "alice"; // user typed lowercase

        // Naive comparison — WRONG for usernames (case-sensitive)
        bool naiveMatch = (storedUsername == inputFromUser);
        Console.WriteLine($"Naive == comparison: {naiveMatch}"); // False — incorrect!

        // Correct comparison — OrdinalIgnoreCase ignores casing
        // Use this for usernames, file names, command inputs
        bool correctMatch = string.Equals(storedUsername, inputFromUser,
                                          StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"OrdinalIgnoreCase comparison: {correctMatch}"); // True — correct!

        // For text displayed to users (like sorting a list of names)
        // use CurrentCultureIgnoreCase — it respects locale rules
        bool cultureMatch = string.Equals(storedUsername, inputFromUser,
                                          StringComparison.CurrentCultureIgnoreCase);
        Console.WriteLine($"CurrentCultureIgnoreCase comparison: {cultureMatch}");

        // Null-safe check: always handle null before comparing
        string possiblyNullInput = null;
        bool isSafe = string.Equals(storedUsername, possiblyNullInput,
                                    StringComparison.OrdinalIgnoreCase);
        Console.WriteLine($"Null-safe comparison result: {isSafe}"); // False, no crash

        Console.WriteLine();

        // =====================================================
        // PART 2: Building Strings Efficiently with StringBuilder
        // =====================================================

        int reportRowCount = 5; // imagine this is 10,000 in production

        // BAD approach — creates a new string on every + in the loop
        // Do NOT do this in loops with many iterations
        string badReport = "Sales Report\n";
        for (int rowNumber = 1; rowNumber <= reportRowCount; rowNumber++)
        {
            badReport += $"Row {rowNumber}: ${ rowNumber * 100}.00\n"; // new string each time!
        }
        Console.WriteLine("--- Bad Report (illustrative only) ---");
        Console.Write(badReport);

        Console.WriteLine();

        // GOOD approach — StringBuilder mutates ONE internal buffer
        // Only call .ToString() once at the very end
        StringBuilder reportBuilder = new StringBuilder();
        reportBuilder.AppendLine("Sales Report"); // AppendLine adds text + newline

        for (int rowNumber = 1; rowNumber <= reportRowCount; rowNumber++)
        {
            // Append builds up the content without creating intermediate strings
            reportBuilder.AppendLine($"Row {rowNumber}: ${rowNumber * 100}.00");
        }

        // Convert to a real string exactly once
        string efficientReport = reportBuilder.ToString();
        Console.WriteLine("--- Efficient Report ---");
        Console.Write(efficientReport);

        // StringBuilder also supports Insert, Remove and Replace
        reportBuilder.Insert(0, "=== CONFIDENTIAL ===\n");
        Console.WriteLine("First 30 chars after Insert: "
                          + reportBuilder.ToString().Substring(0, 20) + "...");
    }
}

using System;
using System.Collections.Generic;

class StringPoolAndPerformance
{
    static void Main()
    {
        // === String interning demo ===
        string literal1 = "thecodeforge";
        string literal2 = "thecodeforge";
        Console.WriteLine(Object.ReferenceEquals(literal1, literal2)); // True — same interned object

        // Runtime strings are NOT interned automatically
        string runtime1 = new string(new char[] { 't', 'h', 'e', 'c', 'o', 'd', 'e', 'f', 'o', 'r', 'g', 'e' });
        string runtime2 = new string(new char[] { 't', 'h', 'e', 'c', 'o', 'd', 'e', 'f', 'o', 'r', 'g', 'e' });
        Console.WriteLine(Object.ReferenceEquals(runtime1, runtime2)); // False — different objects
        Console.WriteLine(runtime1 == runtime2); // True — content equality

        // Explicit interning
        string interned = string.Intern(runtime1);
        Console.WriteLine(Object.ReferenceEquals(interned, literal1)); // True — now in pool

        // === Case-insensitive dictionary with StringComparer ===
        var dict = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
        dict.Add("USA", 1);
        Console.WriteLine(dict.ContainsKey("usa")); // True without conversion
    }
}

// io.thecodeforge — csharp tutorial

using System;

class StringDemo
{
    static void Main()
    {
        // Both compile to identical IL
        string orderId = "ORD-2024-01";
        System.String customerName = "Acme Corp";

        // Nullable reference type (requires #nullable enable)
        string? discountCode = null;

        Console.WriteLine($"Order: {orderId}, Customer: {customerName}");
        Console.WriteLine($"Discount: {discountCode ?? "none"}");
    }
}

// io.thecodeforge — csharp tutorial

using System;

class LiteralDemo
{
    static void Main()
    {
        // Quoted: backslash escapes required
        string quotedPath = "c:\\Users\\Admin\\Documents\\report.pdf";

        // Verbatim: no backslash escaping, just double quotes for quotes
        string verbatimPath = @"c:

Users\Admin\Documents\report.pdf";

        // Raw (C# 11+): handles JSON, SQL, multi-line
        string rawJson = """
        {
            "userId": 1001,
            "role": "admin"
        }
        """;

        Console.WriteLine(quotedPath);
        Console.WriteLine(verbatimPath);
        Console.WriteLine(rawJson);
    }
}

// io.thecodeforge — csharp tutorial

using System;
using System.Globalization;

class FormatDemo
{
    static void Main()
    {
        double revenue = 1234567.89;
        string region = "DE";

        // Interpolation: clean, but cultures depend on current thread
        string userFriendly = $"Revenue for {region}: {revenue:C}";

        // Composite formatting with invariant culture
        string machineReadable = string.Format(
            CultureInfo.InvariantCulture,
            "Revenue for {0}: {1:F2}",
            region,
            revenue);

        Console.WriteLine(userFriendly);       // Depends on thread culture
        Console.WriteLine(machineReadable);    // Always invariant
    }
}

// io.thecodeforge — csharp tutorial

string data = "2025-04-10;ERROR;DB timeout";

// Allocating — creates new string
string date = data.Substring(0, 10);

// Allocation-free — zero heap pressure
ReadOnlySpan<char> span = data.AsSpan();
ReadOnlySpan<char> dateSpan = span.Slice(0, 10);

// For iteration or comparison, use span directly
if (dateSpan.SequenceEqual("2025-04-10"))
    Console.WriteLine("Date match, zero allocation");

// io.thecodeforge — csharp tutorial

string s = "hello";

// Fast — no allocation
char ch = s[1];

// Hidden allocation — ToString() creates a new string
string trap = s[1].ToString();

// Zero-allocation: use span
ReadOnlySpan<char> span = s.AsSpan();
char ch2 = span[1];

// Transform without allocation
Span<char> buffer = stackalloc char[s.Length];
s.AsSpan().CopyTo(buffer);
for (int i = 0; i < buffer.Length; i++)
    if (buffer[i] == 'l') buffer[i] = 'L';