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

Question

Hat jemand eine gute und effiziente Erweiterungsmethode zum Finden, ob eine Sequenz von Elementen irgendwelche Duplikate hat?

Ich denke, ich könnte return subjects.Distinct().Count() == subjects.Count() in eine Erweiterungsmethode setzen, aber irgendwie fühlt, dass es einen besseren Weg geben sollte. Diese Methode müsste Elemente zweimal zählen und alle district Elemente aussortieren. Eine bessere Implementierung sollte True für das erste gefundene Duplikat zurückgeben. Irgendwelche guten Vorschläge?

stelle ich mir die Umrisse so etwas wie dies sein könnte:

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

Ich denke, die einfachste Erweiterung Methode ist 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; 
    } 
    } 
} 

Answer 3

Dies ist im Produktionscode. Works great:

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