这里有一个扩展的方法来删除相邻的副本原位。首先调用Sort()并传入相同的ic比较器。这应该比Lasse V. Karlsen的版本更有效，后者重复调用RemoveAt(导致多次块内存移动)。

public static void RemoveAdjacentDuplicates<T>(this List<T> List, IComparer<T> Comparer)
{
    int NumUnique = 0;
    for (int i = 0; i < List.Count; i++)
        if ((i == 0) || (Comparer.Compare(List[NumUnique - 1], List[i]) != 0))
            List[NumUnique++] = List[i];
    List.RemoveRange(NumUnique, List.Count - NumUnique);
}

如果你不关心顺序，你可以把这些项推到HashSet中，如果你想保持顺序，你可以这样做:

var unique = new List<T>();
var hs = new HashSet<T>();
foreach (T t in list)
    if (hs.Add(t))
        unique.Add(t);

或者用Linq的方式:

var hs = new HashSet<T>();
list.All( x =>  hs.Add(x) );

编辑:HashSet方法是O(N)时间和O(N)空间，而排序，然后使唯一(由@lassevk和其他人建议)是O(N*lgN)时间和O(1)空间，所以我不太清楚(因为它是第一眼)，排序方式是较差的

有很多方法可以解决列表中的重复问题，下面是其中之一:

List<Container> containerList = LoadContainer();//Assume it has duplicates
List<Container> filteredList = new  List<Container>();
foreach (var container in containerList)
{ 
  Container duplicateContainer = containerList.Find(delegate(Container checkContainer)
  { return (checkContainer.UniqueId == container.UniqueId); });
   //Assume 'UniqueId' is the property of the Container class on which u r making a search

    if(!containerList.Contains(duplicateContainer) //Add object when not found in the new class object
      {
        filteredList.Add(container);
       }
  }

干杯 拉维Ganesan

  public static void RemoveDuplicates<T>(IList<T> list )
  {
     if (list == null)
     {
        return;
     }
     int i = 1;
     while(i<list.Count)
     {
        int j = 0;
        bool remove = false;
        while (j < i && !remove)
        {
           if (list[i].Equals(list[j]))
           {
              remove = true;
           }
           j++;
        }
        if (remove)
        {
           list.RemoveAt(i);
        }
        else
        {
           i++;
        }
     }  
  }

这对我很管用。简单地使用

List<Type> liIDs = liIDs.Distinct().ToList<Type>();

将“类型”替换为所需的类型，例如int。

David J。的答案是一个很好的方法，不需要额外的对象，排序等。但是，它可以在以下方面进行改进:

for （int innerIndex = items.计数 - 1;内索引 > 外索引 ;内部索引--）

因此，对于整个列表，外部循环会从上到下，但内部循环会从下到“直到到达外部循环的位置”。

外部循环确保整个列表被处理，内部循环找到实际的重复项，这些只会发生在外部循环还没有处理的部分。

或者如果你不想对内循环做自底向上你可以让内循环从outerIndex + 1开始。