正如kronoz在. net 3.5中所说，您可以使用Distinct()。

在。net 2中，你可以模仿它:

public IEnumerable<T> DedupCollection<T> (IEnumerable<T> input) 
{
    var passedValues = new HashSet<T>();

    // Relatively simple dupe check alg used as example
    foreach(T item in input)
        if(passedValues.Add(item)) // True if item is new
            yield return item;
}

这可用于删除任何集合，并将以原始顺序返回值。

通常，过滤一个集合(Distinct()和这个示例都是这样做的)比从其中删除项要快得多。

简单地用相同类型的List初始化HashSet:

var noDupes = new HashSet<T>(withDupes);

或者，如果你想返回一个List:

var noDupsList = new HashSet<T>(withDupes).ToList();

所有的答案要么复制列表，要么创建一个新列表，要么使用慢函数，要么就是慢得令人痛苦。

据我所知，这是我所知道的最快和最便宜的方法(同时，还得到了一个非常有经验的实时物理优化程序员的支持)。

// Duplicates will be noticed after a sort O(nLogn)
list.Sort();

// Store the current and last items. Current item declaration is not really needed, and probably optimized by the compiler, but in case it's not...
int lastItem = -1;
int currItem = -1;

int size = list.Count;

// Store the index pointing to the last item we want to keep in the list
int last = size - 1;

// Travel the items from last to first O(n)
for (int i = last; i >= 0; --i)
{
    currItem = list[i];

    // If this item was the same as the previous one, we don't want it
    if (currItem == lastItem)
    {
        // Overwrite last in current place. It is a swap but we don't need the last
       list[i] = list[last];

        // Reduce the last index, we don't want that one anymore
        last--;
    }

    // A new item, we store it and continue
    else
        lastItem = currItem;
}

// We now have an unsorted list with the duplicates at the end.

// Remove the last items just once
list.RemoveRange(last + 1, size - last - 1);

// Sort again O(n logn)
list.Sort();

最终成本为:

nlogn + n + nlogn = n + 2nlogn = O(nlogn)非常漂亮。

关于RemoveRange注意事项: 由于我们不能设置列表的计数并避免使用Remove函数，我不知道这个操作的确切速度，但我猜这是最快的方法。

把它排序，然后检查两个和两个相邻的，因为重复的会聚集在一起。

就像这样:

list.Sort();
Int32 index = list.Count - 1;
while (index > 0)
{
    if (list[index] == list[index - 1])
    {
        if (index < list.Count - 1)
            (list[index], list[list.Count - 1]) = (list[list.Count - 1], list[index]);
        list.RemoveAt(list.Count - 1);
        index--;
    }
    else
        index--;
}

注:

从后到前进行比较，避免每次移除后都要列出度假胜地列表 这个例子现在使用c#值元组来进行交换，如果你不能使用它，可以用适当的代码来代替 最终结果不再排序

一个简单直观的实现:

public static List<PointF> RemoveDuplicates(List<PointF> listPoints)
{
    List<PointF> result = new List<PointF>();

    for (int i = 0; i < listPoints.Count; i++)
    {
        if (!result.Contains(listPoints[i]))
            result.Add(listPoints[i]);
        }

        return result;
    }

使用Linq的Union方法。

注意:这个解决方案不需要了解Linq，只需要知道它存在。

Code

首先将以下内容添加到类文件的顶部:

using System.Linq;

现在，你可以使用下面的方法从一个名为obj1的对象中删除重复项:

obj1 = obj1.Union(obj1).ToList();

注意:将obj1重命名为对象的名称。

它是如何工作的

Union命令列出两个源对象的每个条目中的一个。由于obj1都是源对象，这将把obj1减少为每个条目中的一个。 ToList()返回一个新的List。这是必要的，因为像Union这样的Linq命令将结果返回为IEnumerable结果，而不是修改原来的List或返回一个新的List。