using System;

using System.Collections.Generic;

​

public class Program

{

    public static void Main()

    {

        var testDict = new Dictionary<UnorderedPair<int>, string>();

        testDict.Add(new UnorderedPair<int>(1, 2), "Hello World!");

        Console.WriteLine(testDict[new UnorderedPair<int>(2, 1)]);

        var testDict2 = new Dictionary<UnorderedPair<int, double>, string>();

        testDict2.Add(new UnorderedPair<int, double>(1,2.5), "Still Hello World!");

        Console.WriteLine(testDict2[new UnorderedPair<double,int>(2.5,1)]);

        var testDict3  = new Dictionary<UnorderedPair<float, float>, string>();

        testDict3.Add(new UnorderedPair<float,float>()

                      {

                          X=1.2f,

                          Y=2.5f

                      }, "Aaaand Still Hello World!");

        Console.WriteLine(testDict3[new UnorderedPair<float,float>()

                                    {

                                        X=2.5f,

                                        Y=1.2f

                                    }]);

    }

}

​

[Serializable]

public class UnorderedPair<T> : IEquatable<UnorderedPair<T>>

{

    public T X;

    public T Y;

​

    public UnorderedPair()

    {

    }

​

    public UnorderedPair(T x, T y)

    {

        X = x;

        Y = y;

    }

​

    public bool Equals(UnorderedPair<T> other)

    {

        if (ReferenceEquals(null, other))

        {

            return false;

        }

​

        if (ReferenceEquals(this, other))

        {

            return true;

        }

​

        // For equality simply include the swapped check

        return X.Equals(other.X) && Y.Equals(other.Y) || X.Equals(other.Y) && Y.Equals(other.X);

    }

​

    public override bool Equals(object obj)

    {

        if (ReferenceEquals(null, obj))

        {

            return false;

        }

​

        if (ReferenceEquals(this, obj))

        {

            return true;

        }

​

        if (obj.GetType() != GetType())

        {

            return false;

        }

​

        return Equals((UnorderedPair<T>)obj);

    }

​

    public override int GetHashCode()

    {

        // and for the HashCode (used as key in HashSet and Dictionary) simply order them by size an hash them again ^^

        var hashX = X == null ? 0 : X.GetHashCode();

        var hashY = Y == null ? 0 : Y.GetHashCode();

        return HashCode.Combine(Math.Min(hashX,hashY), Math.Max(hashX,hashY));

    }

​

    public static bool operator ==(UnorderedPair<T> left, UnorderedPair<T> right)

    {

        return Equals(left, right);

    }

​

    public static bool operator !=(UnorderedPair<T> left, UnorderedPair<T> right)

    {

        return !Equals(left, right);

    }

}

​

[Serializable]

public class UnorderedPair<TX, TY> : IEquatable<UnorderedPair<TX, TY>>

{

    public TX X;

    public TY Y;

​

    public UnorderedPair()

    {

    }

​

    public UnorderedPair(TX x, TY y)

    {

        X = x;

        Y = y;

    }

​

    public UnorderedPair(TY y, TX x)

    {

        X = x;

        Y = y;

    }

​

    public override int GetHashCode()

    {

        // and for the HashCode (used as key in HashSet and Dictionary) simply order them by size an hash them again ^^

        var hashX = X == null ? 0 : X.GetHashCode();

        var hashY = Y == null ? 0 : Y.GetHashCode();

        var combine = HashCode.Combine(Math.Min(hashX, hashY), Math.Max(hashX, hashY));

        return combine;

    }

​

    public bool Equals(UnorderedPair<TX, TY> other)

    {

        if (ReferenceEquals(null, other))

        {

            return false;

        }

​

        if (ReferenceEquals(this, other))

        {

            return true;

        }

​

        if (typeof(TX) != typeof(TY))

        {

            return EqualityComparer<TX>.Default.Equals(X, other.X) && EqualityComparer<TY>.Default.Equals(Y, other.Y);

        }

        return  EqualityComparer<TX>.Default.Equals(X, other.X) && EqualityComparer<TY>.Default.Equals(Y, other.Y)

            || X.Equals(other.Y) && Y.Equals(other.X);

    }

​

    public override bool Equals(object obj)

    {

        if (ReferenceEquals(null, obj))

        {

            return false;

        }

​

        if (ReferenceEquals(this, obj))

        {

            return true;

        }

​

        return obj switch

        {

            UnorderedPair<TX, TY> other => Equals(other),

            UnorderedPair<TY, TX> otherSwapped => Equals(otherSwapped),

            _ => false

        };

    }

​

    public static bool operator ==(UnorderedPair<TX, TY> left, UnorderedPair<TX, TY> right)

    {

        return Equals(left, right);

    }

​

    public static bool operator !=(UnorderedPair<TX, TY> left, UnorderedPair<TX, TY> right)

    {

        return !Equals(left, right);

    }

​

    public static implicit operator UnorderedPair<TX, TY>(UnorderedPair<TY, TX> pair)

    {

        return new UnorderedPair<TX, TY>(pair.Y, pair.X);

    }

}