C# 3.0：需要从 List<> 返回重复项

Question

我有一个列表<> C# 中的对象的数量，我需要一种方法来返回列表中被视为重复的那些对象。 我不需要不同的结果集，我需要一个将从我的存储库中删除的项目的列表。

就本示例而言，假设我有一个“汽车”类型列表，我需要知道其中哪些汽车与列表中的其他汽车颜色相同。 以下是列表中的汽车及其颜色属性：

Car1.Color = Red;

Car2.Color = Blue;

Car3.Color = Green;

Car4.Color = Red;

Car5.Color = Red;

对于此示例，我需要结果（IEnumerable<>、List<> 或其他）来包含 Car4 和 Car5，因为我想从我的存储库或数据库中删除它们，所以我的存储库中每种颜色只有一辆车。 任何帮助，将不胜感激。

Answer 1

我昨天无意中编写了这个代码，当时我试图写一个“通过投影来区分”。 我包括了一个！ 当我不应该这样做时，但这一次它是正确的：

public static IEnumerable<TSource> DuplicatesBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
    HashSet<TKey> seenKeys = new HashSet<TKey>();
    foreach (TSource element in source)
    {
        // Yield it if the key hasn't actually been added - i.e. it
        // was already in the set
        if (!seenKeys.Add(keySelector(element)))
        {
            yield return element;
        }
    }
}

然后你可以用以下方式调用它：

var duplicates = cars.DuplicatesBy(car => car.Color);

Answer 2

var duplicates = from car in cars
                 group car by car.Color into grouped
                 from car in grouped.Skip(1)
                 select car;

这将按颜色对汽车进行分组，然后跳过每组的第一个结果，返回每组中的剩余结果，并将其扁平化为单个序列。

如果您对要保留哪一辆有特殊要求，例如，如果汽车具有 Id 属性，并且您希望保留具有最低 Id 的汽车，那么您可以在那里添加一些排序，例如

var duplicates = from car in cars
                 group car by car.Color into grouped
                 from car in grouped.OrderBy(c => c.Id).Skip(1)
                 select car;

Answer 3

这是一个稍微不同的 Linq 解决方案，我认为它使您想要做的事情更加明显：

var s = from car in cars
    group car by car.Color into g
    where g.Count() == 1
    select g.First();

它只是按颜色对汽车进行分组，丢弃所有具有多个元素的组，然后将其余的放入返回的 IEnumerable 中。

Answer 4

IEnumerable<Car> GetDuplicateColors(List<Car> cars)
{
    return cars.Where(c => cars.Any(c2 => c2.Color == c.Color && cars.IndexOf(c2) < cars.IndexOf(c) ) );
}    

它基本上意味着“返回列表中具有相同颜色和较小索引的任何汽车的汽车”。

但不确定性能。 我怀疑使用 O(1) 查找重复项的方法（如字典/哈希集方法）对于大型集合可能会更快。

Answer 5

创建一个新的 Dictionary foundColors 和一个 List carsToDelete

然后，您可以像这样迭代原始汽车列表：

foreach(Car c in listOfCars)
{
    if (foundColors.containsKey(c.Color))
    {
        carsToDelete.Add(c);
    }
    else
    {
        foundColors.Add(c.Color, c);
    }
}

然后您可以删除foundColors 中的每辆汽车。

通过将“删除记录”逻辑放在 if 语句中而不是创建新列表，您可以获得较小的性能提升，但您提出问题的方式表明您需要将它们收集在列表中。

Answer 6

如果没有实际编码，那么像这样的算法怎么样：

• 迭代您的 List 创建一个 Dictionary
• 迭代您的 Dictionary< T, int> 删除 int 为 >1 的条目

Dictionary 中剩余的任何内容都有重复项。 当然，实际删除的第二部分是可选的。 您只需遍历 Dictionary 并查找 >1 即可采取操作。

编辑：好的，我提高了瑞安的，因为他实际上给了你代码。 ;)

Answer 7

我的回答的灵感来自于以下受访者（按此顺序）：Joe Coehoorn、Greg Beech 和 Jon Skeet。

我决定提供一个完整的示例，假设（为了实际效率）您有一个静态的汽车颜色列表。 我相信下面的代码以一种优雅但不一定超高效的方式说明了该问题的完整解决方案。

#region SearchForNonDistinctMembersInAGenericListSample
public static string[] carColors = new[]{"Red", "Blue", "Green"}; 
public static string[] carStyles = new[]{"Compact", "Sedan", "SUV", "Mini-Van", "Jeep"}; 
public class Car
{
    public Car(){}
    public string Color { get; set; }
    public string Style { get; set; }
}
public static List<Car> SearchForNonDistinctMembersInAList()
{
    // pass in cars normally, but declare here for brevity
    var cars = new List<Car>(5) { new Car(){Color=carColors[0], Style=carStyles[0]}, 
                                      new Car(){Color=carColors[1],Style=carStyles[1]},
                                      new Car(){Color=carColors[0],Style=carStyles[2]}, 
                                      new Car(){Color=carColors[2],Style=carStyles[3]}, 
                                      new Car(){Color=carColors[0],Style=carStyles[4]}};
    List<Car> carDupes = new List<Car>();

    for (int i = 0; i < carColors.Length; i++)
    {
        Func<Car,bool> dupeMatcher = c => c.Color == carColors[i];

        int count = cars.Count<Car>(dupeMatcher);

        if (count > 1) // we have duplicates
        {
            foreach (Car dupe in cars.Where<Car>(dupeMatcher).Skip<Car>(1))
            {
                carDupes.Add(dupe);
            }
        }
    }
    return carDupes;
}
#endregion

我稍后会回到这里，将这个解决方案与其所有三个灵感进行比较，只是为了对比风格。 还蛮有趣的。

Answer 8

公共静态 IQueryable 重复项（此 IEnumerable 源）其中 TSource ： IComparable
{

if (source == null)   
     throw new ArgumentNullException("source");   
 return source.Where(x => source.Count(y=>y.Equals(x)) > 1).AsQueryable<TSource>();   

}