Tuple (C#)

Definition: tuples are data structures with multiple fields (light construct) for lightweight data transport mechanism.

Initialization:

// ("a", true, 4, "t");
// (string, bool, int, string) values=("a", true, 4, "t");

var values=("a", true, 4, "t");

// named fields
// (string FirstName, string MiddleName, string LastName) names=("Jack", "Von", "Chole");

var names=(FirstName: "Jack", MiddleName: "Von", LastName: "Chole");

// access tuple values
Console.WriteLine($"First Name: {names.FirstName}); // by field name
// Console.WriteLine($"Last Name: {names.Item3}); // through ItemX

Tuple equality(==) and inequality(!=)

var tuple1=(x: 10, y: 20);
(int? x, int? y) tuple2=(10, 20);
Console.WriteLine(tuple1==tuple2); // true

(long a, int b) first=(10, 20);
(int a, long b) second=(10, 20);
Console.WriteLine(first==second); // true

Tuple as Method return value

static (string firstName, string lastName, int age) GetPersonInfo()
{
    return( "Jack", "Chen", 25);
}

var p=GetPersonInfo();
Console.WriteLine($"{p.firstName} {p.lastName} is {p.age} years old.")

Tuple Pattern Matching (switch)

static string ColorMixer(string color1, string color2)
{
    //return (color1, color2) switch
    =>(color1, color2) switch
    {
        ("red", "green")=>"yellow",
        ("green", "blue")=>"cyan",
        ("red", "blue")=>"magenta",
        (_, _)=>"unknown",
    };
}

Deconstruct Tuples with Positional Pattern Matching (C# 8.0) 

namespace FunWithTuplePatternMatch
{
    public static class Common
    {
        public static string GetQuadrant(Point p)
        {
            var value = (p.Deconstruct());
            return value  switch
            {
                var (x, y) when x==0 && y==0 => "Origin",
                var (x, y) when x > 0 && y > 0 => "First",
                var (x, y) when x < 0 && y > 0 => "Second",
                var (_, _) => "unknown",
            };
        }

        public struct Point
        {
            // fields
            public double X;
            public double Y;

            // custom constructor
            public Point(double xValue, double yValue)
            {
                X = xValue;
                Y = yValue;
            }

            // deconstruct Tuple
            public (double xValue, double yValue) Deconstruct() => (X, Y);
        }
    }
}

using static FunWithTuplePatternMatch.Common;

Point p = new Point(10, 20);
var pV = p.Deconstruct();
Console.WriteLine($"X is {pV.xValue}");
Console.WriteLine($" Y is {pV.yValue}");
Console.WriteLine($"The quadrant is {GetQuadrant(p)}");