C# Dictionary that uses an Unordered Pair as its Key?

Question

I'm trying to create a Dictionary is C# that takes an Unordered Pair of Indices as its Key.

For example:

exampleDictionary[new UnorderedPair(x,y)] and exampleDictionary[new UnorderedPair(y,x)] should both return the same value.

Is there a way to create a custom unordered collection other than using a HashSet? Or some way to create an unordered Tuple?

This question is similar to what I'm trying to accomplish, except in C# rather than python.

Answer 1

If the type is not your own or you can't or don't want to modify refer to Theodor Zoulias's answer

Otherwise, assuming that UnorderedPair is your own class you can modify what you could do is e.g.

[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);
    }
}

and then e.g.

var testDict = new Dictionary<UnorderedPair<int>, string>();
testDict.Add(new UnorderedPair<int>(1,2), "Hello World!");
Console.WriteLine(testDict[new UnorderedPair<int>(2,1)]);

---

As per suggestion by Jodrell in the comments you could even make the types swappable - not sure this would be ever needed - but this way you could even have a pair of different types:

[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);
    }
}

and

var testDict = new Dictionary<UnorderedPair<int, double>, string>();
testDict.Add(new UnorderedPair<int, double>(1,2.5), "Hello World!");
Console.WriteLine(testDict[new UnorderedPair<double,int>(2.5,1)]);

---

(.NET Fiddle for both)