C# Tuples Explained — Syntax, Named Elements and Real-World Uses

using System;

class TupleBasics
{
    static void Main()
    {
        // ── OLD WAY: System.Tuple (reference type, avoid in new code) ──
        // Elements can only be accessed as Item1, Item2 — not descriptive at all.
        Tuple<string, int> oldStyleUser = Tuple.Create("Alice", 30);
        Console.WriteLine($"Old style — Name: {oldStyleUser.Item1}, Age: {oldStyleUser.Item2}");

        // ── MODERN WAY: ValueTuple with named elements (C# 7.0+) ──
        // The parentheses syntax is built into the language — no class needed.
        // Each element gets a real name that makes the code self-documenting.
        (string Name, int Age) modernUser = ("Alice", 30);
        Console.WriteLine($"Modern style — Name: {modernUser.Name}, Age: {modernUser.Age}");

        // You can also access modern tuple elements by position (Item1, Item2)
        // but using the named properties is always clearer.
        Console.WriteLine($"By position — Name: {modernUser.Item1}, Age: {modernUser.Item2}");

        // ValueTuples are VALUE types — assigning copies the data, not a reference.
        // Changing the copy does NOT affect the original.
        var copiedUser = modernUser;
        copiedUser.Name = "Bob";  // ValueTuple fields are mutable — a key difference from Tuple
        Console.WriteLine($"Original is still: {modernUser.Name}"); // Still Alice
        Console.WriteLine($"Copy is now: {copiedUser.Name}");       // Bob
    }
}

using System;

class TupleReturnValues
{
    // Return type is a named ValueTuple — two pieces of information in one return.
    // The caller gets IsValid AND ErrorMessage without any out parameters.
    static (bool IsValid, string ErrorMessage) ValidatePassword(string password)
    {
        if (string.IsNullOrWhiteSpace(password))
            return (false, "Password cannot be empty.");  // Tuple literal — values match by position

        if (password.Length < 8)
            return (false, $"Password must be at least 8 characters (got {password.Length}).");

        if (!password.Contains('!') && !password.Contains('@') && !password.Contains('#'))
            return (false, "Password must contain at least one special character: !, @, or #.");

        // All checks passed — return success with no error message
        return (true, string.Empty);
    }

    // Return a tuple summarising a price calculation — avoids a throw-away DTO class.
    static (decimal SubTotal, decimal Tax, decimal GrandTotal) CalculateOrderTotal(
        decimal pricePerItem, int quantity, decimal taxRate)
    {
        decimal subTotal   = pricePerItem * quantity;   // Base cost before tax
        decimal tax        = subTotal * taxRate;         // Tax amount
        decimal grandTotal = subTotal + tax;             // Final amount customer pays

        return (subTotal, tax, grandTotal);  // Names are inferred from the variable names
    }

    static void Main()
    {
        // ── Password validation ──
        string[] testPasswords = { "", "abc123", "securepwd", "Secure@99" };

        foreach (string pwd in testPasswords)
        {
            // Call the method and capture the returned tuple into a named variable.
            var result = ValidatePassword(pwd);

            if (result.IsValid)
                Console.WriteLine($"  '{pwd}' → VALID");
            else
                Console.WriteLine($"  '{pwd}' → INVALID: {result.ErrorMessage}");
        }

        Console.WriteLine();

        // ── Order total calculation ──
        var order = CalculateOrderTotal(pricePerItem: 24.99m, quantity: 3, taxRate: 0.08m);

        Console.WriteLine($"Sub-total:   ${order.SubTotal:F2}");
        Console.WriteLine($"Tax (8%):    ${order.Tax:F2}");
        Console.WriteLine($"Grand total: ${order.GrandTotal:F2}");
    }
}

using System;
using System.Collections.Generic;

class TupleDeconstruction
{
    static (string City, string Country, int Population) GetCityInfo(string cityName)
    {
        // In a real app this would hit a database — here we use a lookup dictionary.
        var cities = new Dictionary<string, (string Country, int Population)>
        {
            ["Tokyo"]    = ("Japan",   13960000),
            ["London"]   = ("UK",       8982000),
            ["Sydney"]   = ("Australia", 5312000),
            ["New York"] = ("USA",      8336817),
        };

        if (cities.TryGetValue(cityName, out var info))
            return (cityName, info.Country, info.Population);

        return (cityName, "Unknown", 0);  // Graceful fallback
    }

    static void Main()
    {
        // ── Basic deconstruction: all three elements unpacked at once ──
        // 'var' on the left infers all three types automatically.
        var (city, country, population) = GetCityInfo("Tokyo");
        Console.WriteLine($"{city} is in {country} with a population of {population:N0}.");

        // ── Explicit type deconstruction ──
        (string name, string nation, int size) = GetCityInfo("London");
        Console.WriteLine($"{name} is in {nation} with a population of {size:N0}.");

        // ── Using discard _ to ignore elements you don't need ──
        // We want the country and population but don't need the city name repeated.
        var (_, londonCountry, londonPop) = GetCityInfo("London");
        Console.WriteLine($"Country: {londonCountry}, Pop: {londonPop:N0}");

        Console.WriteLine();

        // ── Deconstructing in a foreach loop ──
        // Each element in the list is a tuple — we unpack it right in the loop header.
        var productSales = new List<(string ProductName, int UnitsSold, decimal Revenue)>
        {
            ("Wireless Headphones", 142, 14199.58m),
            ("USB-C Hub",           389,  9724.61m),
            ("Mechanical Keyboard",  97,  9206.03m),
        };

        Console.WriteLine($"  {"Product",-25} {"Units",6}  {"Revenue",12}");
        Console.WriteLine(new string('-', 48));

        foreach (var (productName, unitsSold, revenue) in productSales)
        {
            // Each loop iteration deconstructs the current tuple into three clean variables.
            Console.WriteLine($"  {productName,-25} {unitsSold,6}  {revenue,12:C}");
        }
    }
}

using System;

// ── Option 1: A dedicated class ──
// Best when the data has behaviour, needs documentation, or travels widely.
public class WeatherReport
{
    public string City        { get; init; }
    public double TemperatureC { get; init; }
    public string Condition   { get; init; }

    public WeatherReport(string city, double temperatureC, string condition)
    {
        City           = city;
        TemperatureC   = temperatureC;
        Condition      = condition;
    }

    // Classes can have behaviour — tuples cannot.
    public string ToFahrenheitSummary() =>
        $"{City}: {TemperatureC * 9 / 5 + 32:F1}°F — {Condition}";
}

// ── Option 2: A record (C# 9+) ──
// Great for immutable data containers with named properties and less boilerplate.
public record StockPrice(string Ticker, decimal Price, decimal ChangePercent);

class TupleVsClass
{
    // Returns a tuple — the data only needs to live inside this method's caller.
    // Creating a class just for this would be overkill.
    static (int WordCount, int CharCount, int SentenceCount) AnalyseText(string text)
    {
        int words     = text.Split(' ', StringSplitOptions.RemoveEmptyEntries).Length;
        int chars     = text.Replace(" ", "").Length;  // Characters excluding spaces
        int sentences = text.Split(new[] { '.', '!', '?' },
                            StringSplitOptions.RemoveEmptyEntries).Length;
        return (words, chars, sentences);
    }

    static void Main()
    {
        // ── Tuple: quick, local, no ceremony ──
        string sampleText = "Hello world. How are you? I am fine!";
        var (wordCount, charCount, sentenceCount) = AnalyseText(sampleText);
        Console.WriteLine($"Words: {wordCount}, Chars: {charCount}, Sentences: {sentenceCount}");

        // ── Class: carries behaviour, meaningful type name ──
        var report = new WeatherReport("Melbourne", 22.5, "Partly Cloudy");
        Console.WriteLine(report.ToFahrenheitSummary()); // Behaviour lives on the object

        // ── Record: immutable, concise, value-equality built in ──
        var appleStock = new StockPrice("AAPL", 189.30m, +1.42m);
        var sameStock  = new StockPrice("AAPL", 189.30m, +1.42m);

        // Records compare by VALUE — two records with same data are equal.
        // Classes would compare by REFERENCE (not equal unless same object instance).
        Console.WriteLine($"Same stock data? {appleStock == sameStock}"); // True
        Console.WriteLine($"{appleStock.Ticker}: ${appleStock.Price} ({appleStock.ChangePercent:+0.##;-0.##}%)");
    }
}