When to Use Tuple vs ValueTuple in C#

using System;
using System.Collections.Generic;

        // Old-style Tuple (reference type)
        Console.WriteLine("=== Old Tuple (System.Tuple) ===");
        Tuple<string, int> oldTuple = Tuple.Create("Alice", 30);
        Console.WriteLine($"Name: {oldTuple.Item1}, Age: {oldTuple.Item2}");

        // Modern ValueTuple (value type)
        Console.WriteLine("\n=== ValueTuple (Modern C# 7+) ===");
        (string name, int age) person = ("Bob", 25);
        Console.WriteLine($"Name: {person.name}, Age: {person.age}");

        // ValueTuple without names (still better than Tuple)
        var unnamed = (42, "Hello");
        Console.WriteLine($"Item1: {unnamed.Item1}, Item2: {unnamed.Item2}");

        // Returning multiple values
        Console.WriteLine("\n=== Returning multiple values ===");
        
        // Old way with Tuple
        Tuple<int, int, int> oldStats = GetStatsOld(new[] { 1, 2, 3, 4, 5 });
        Console.WriteLine($"Old - Min: {oldStats.Item1}, Max: {oldStats.Item2}, Sum: {oldStats.Item3}");

        // New way with ValueTuple
        var (min, max, sum) = GetStats(new[] { 1, 2, 3, 4, 5 });
        Console.WriteLine($"New - Min: {min}, Max: {max}, Sum: {sum}");

        // Deconstruction
        Console.WriteLine("\n=== Deconstruction ===");
        var coordinates = GetCoordinates();
        var (x, y, z) = coordinates;
        Console.WriteLine($"X: {x}, Y: {y}, Z: {z}");

        // Partial deconstruction with discards
        var (userName, _, userAge) = GetUserInfo();
        Console.WriteLine($"Name: {userName}, Age: {userAge}");

        // Multiple return values from methods
        Console.WriteLine("\n=== Multiple return patterns ===");
        
        if (TryParseDate("2024-12-31", out DateTime date))
        {
            Console.WriteLine($"Parsed date: {date:yyyy-MM-dd}");
        }

        // ValueTuple alternative
        var parseResult = ParseDate("2024-12-31");
        if (parseResult.success)
        {
            Console.WriteLine($"Parsed via tuple: {parseResult.date:yyyy-MM-dd}");
        }

        // Tuples in collections
        Console.WriteLine("\n=== Tuples in collections ===");
        List<(string name, int score)> scores = new List<(string, int)>
        {
            ("Alice", 95),
            ("Bob", 87),
            ("Charlie", 92)
        };

        foreach (var entry in scores)
        {
            Console.WriteLine($"{entry.name}: {entry.score}");
        }

        // Tuples in Dictionary
        Dictionary<int, (string firstName, string lastName)> users = new Dictionary<int, (string, string)>
        {
            { 1, ("John", "Doe") },
            { 2, ("Jane", "Smith") }
        };

        Console.WriteLine($"\nUser 1: {users[1].firstName} {users[1].lastName}");

        // Tuple equality (ValueTuple supports ==)
        Console.WriteLine("\n=== Tuple equality ===");
        var tuple1 = (1, "test");
        var tuple2 = (1, "test");
        var tuple3 = (2, "test");

        Console.WriteLine($"tuple1 == tuple2: {tuple1 == tuple2}");  // True
        Console.WriteLine($"tuple1 == tuple3: {tuple1 == tuple3}");  // False

        // Performance comparison
        Console.WriteLine("\n=== Performance characteristics ===");
        Console.WriteLine("Tuple: Reference type (heap allocation)");
        Console.WriteLine("ValueTuple: Value type (stack allocation, more efficient)");

        // Nested tuples
        Console.WriteLine("\n=== Nested tuples ===");
        var nested = (1, (2, (3, 4)));
        Console.WriteLine($"Nested: {nested.Item1}, {nested.Item2.Item1}, {nested.Item2.Item2.Item1}");

        // Named nested tuples
        var namedNested = (id: 1, address: (street: "Main St", zip: "12345"));
        Console.WriteLine($"ID: {namedNested.id}, Street: {namedNested.address.street}");

        // Switch expressions with tuples
        Console.WriteLine("\n=== Switch with tuples ===");
        var point = (x: 0, y: 0);
        string location = point switch
        {
            (0, 0) => "Origin",
            (0, _) => "X-axis",
            (_, 0) => "Y-axis",
            _ => "Somewhere else"
        };
        Console.WriteLine($"Point (0,0) is at: {location}");

        // Practical example: parsing CSV
        Console.WriteLine("\n=== Practical example: CSV parsing ===");
        var csv = "John,Doe,30,Engineer";
        var parsedRecord = ParseCsvRecord(csv);
        Console.WriteLine($"Parsed: {parsedRecord.firstName} {parsedRecord.lastName}, " +
                         $"{parsedRecord.age}, {parsedRecord.occupation}");

// Old-style Tuple return
static Tuple<int, int, int> GetStatsOld(int[] numbers)
    {
        int min = numbers[0];
        int max = numbers[0];
        int sum = 0;

        foreach (int n in numbers)
        {
            if (n < min) min = n;
            if (n > max) max = n;
            sum += n;
        }

        return Tuple.Create(min, max, sum);
    }

    // Modern ValueTuple return
    static (int min, int max, int sum) GetStats(int[] numbers)
    {
        int min = numbers[0];
        int max = numbers[0];
        int sum = 0;

        foreach (int n in numbers)
        {
            if (n < min) min = n;
            if (n > max) max = n;
            sum += n;
        }

        return (min, max, sum);
    }

    static (double x, double y, double z) GetCoordinates()
    {
        return (10.5, 20.3, 30.7);
    }

    static (string name, string email, int age) GetUserInfo()
    {
        return ("Alice", "alice@example.com", 28);
    }

    static bool TryParseDate(string input, out DateTime result)
    {
        return DateTime.TryParse(input, out result);
    }

    static (bool success, DateTime date) ParseDate(string input)
    {
        bool success = DateTime.TryParse(input, out DateTime date);
        return (success, date);
    }

    static (string firstName, string lastName, int age, string occupation) ParseCsvRecord(string csv)
    {
        string[] parts = csv.Split(',');
        return (parts[0], parts[1], int.Parse(parts[2]), parts[3]);
}