C #: Eine gute und effiziente Implementierung von IEnumerable .HasDuplicates

Question

Hat jemand eine gute und effiziente Erweiterung Verfahren zum Auffinden, wenn eine Folge von Elementen Duplikate hat?

Ich glaube, ich return subjects.Distinct().Count() == subjects.Count() in eine Erweiterung Methode setzen konnte, aber irgendwie fühlt sich der, dass es einen besseren Weg geben. Diese Methode würde Elemente zweimal zählen und alle distict Elemente auszusortieren. Eine bessere Umsetzung sollte return true auf dem ersten Duplikat es findet. Jedes gute Vorschläge?

Ich stelle mir die Umrisse so etwas wie dies sein könnten:

public static bool HasDuplicates<T>(this IEnumerable<T> subjects)
{
    return subjects.HasDuplicates(EqualityComparer<T>.Default);
}

public static bool HasDuplicates<T>(this IEnumerable<T> subjects, IEqualityComparer<T> comparer)
{
    ...
}

Aber nicht ganz sicher, wie eine intelligente Umsetzung wäre es ...

Answer 1

public static bool HasDuplicates<T>(this IEnumerable<T> subjects)
{
    return HasDuplicates(subjects, EqualityComparer<T>.Default);
}

public static bool HasDuplicates<T>(this IEnumerable<T> subjects, IEqualityComparer<T> comparer)
{
    HashSet<T> set = new HashSet<T>(comparer);
    foreach (T item in subjects)
    {
        if (!set.Add(item))
            return true;
    }

    return false;
}

Answer 2

Dies ist im Produktionscode. Funktioniert prima:

public static bool HasDuplicates<T>(this IEnumerable<T> sequence) {
    var set = new HashSet<T>();
    return !sequence.All(item => set.Add(item));
}

Answer 3

Ich denke, die einfachste Erweiterung Methode ist die folgende.

public static bool HasDuplicates<T>(this IEnumerable<T> enumerable) {
  var hs = new HashSet<T>();
  foreach ( var cur in enumerable ) {
    if ( !hs.Add(cur) ) {
      return false;
    }
  }
}