Struct type comparison

Question

Imagine I have an IEnumerable<T> where T is a struct type. For each element of the collection I want to check whether there is another element with the same value.

Firstly, I thought about something like this:

IEnumerable<T> collection = someInput;

foreach(var element in collection)
{
  try
  {
    collection.First(x => x == element &&
                          x.GetHashCode() =! element.GetHashCode());

    DoA(element);
  }
  catch
  {
    DoB(element);
  }
}

But then I found out that hashes are actually equal for structures having same values. Apparently, Object.ReferenceEquals(x, element) is not a way as well.

So, there are 2 questions:

1. Is there an option to distinguish two different struct variables with the same values?
2. Is there any other other ways to solve my problem?

Thanks

Answer 1

Is there an option to distinguish two different struct variables with the same values?

No, structs are so called value types. They are only defined by their values and have no reference. If you want to distinguish two instances which have equal values you have to use a class instead of a struct. Classes are reference types and therefore are distinguishable even if they have equal values because they have different references.

In this case however you also have their position in the collection which could be used to distinguish them (it's bascially also some kind of reference).

Is there any other other ways to solve my problem?

As noted above you may use the position. Here's a simple basic implementation without LINQ. You can certainly make a shorter one with LINQ.

    for (var i = 0; i < collection.Count; i++)
    {
        var foundEqual = false;
        for (var j = 0; j < collection.Count; j++)
        {
            if (j != i && collection[i] == collection[j])
            {
                foundEqual = true;
                break;
            }
        }
        
        if (foundEqual)
        {
            DoA(collection[i]);
        }
        else
        {
            DoB(collection[i]);
        }   
    }

If your struct doesn't implement IEquatable yet you have to implement it to make the equality comparison work. Look here for an explanation and an example: https://learn.microsoft.com/en-us/do.net/csharp/programming-guide/statements-expressions-operators/how-to-define-value-equality-for-a-type

You should never rely on GetHashCode() for equality comparison as an equal hash code does not guarantee that the compared objects are actually equal.

Answer 2

Structs will autmatically be compared to each other by a hashcode generated from their fields, so you should be able to use the Equals method to determine if there are any duplicates in your collection. One simple way to do this is to group your collection by the struct itself, and then compare the counts of the grouped items and the original collection. If there were any identical items, they would be grouped together, and the grouped item count would be less than the original collection count:

bool hasDuplicates = collection.GroupBy(i => i).Count() < collection.Count();

In general, you can compare items using the Equals method:

public bool HasDuplicateElement<T>(IEnumerable<T> items) where T : struct
{
    if (items == null || items.Count() < 2) return false;

    for(int i = 0; i < items.Count() - 1; i++)
    {
        for (int j = i + 1; j < items.Count(); j++)
        {
            if (items.ElementAt(i).Equals(items.ElementAt(j))) return true;
        }
    }

    return false;
}

Note that if the struct has reference-type fields, and they don't have a meaningful equality implementation (ie they use the default reference equality), then you'll have to write your own IEqualityComparer<T> and pass that to the GroupBy method.