Eliminar duplicados de una lista en C#

Si está usando.Net 3+, puede usar Linq.

List<T> withDupes = LoadSomeData();
List<T> noDupes = withDupes.Distinct().ToList();

Qué tal: -

var noDupes = list.Distinct().ToList();

En .net 3.5?

Simplemente inicialice un HashSet con una Lista del mismo tipo:

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

O, si desea que se devuelva una Lista:

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

Ordénelo, luego marque dos y dos uno al lado del otro, ya que los duplicados se agruparán.

Algo como esto:

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

Funcionó para mí. simplemente use

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

Reemplace "Type" con el tipo deseado, por ejemplo, int.

Me gusta usar este comando:

List<Store> myStoreList = Service.GetStoreListbyProvince(provinceId)
                                                 .GroupBy(s => s.City)
                                                 .Select(grp => grp.FirstOrDefault())
                                                 .OrderBy(s => s.City)
                                                 .ToList();

Tengo estos campos en mi lista: Id, StoreName, City, PostalCode Quería mostrar la lista de ciudades en un menú desplegable que tiene valores duplicados. solución: Agrupe por ciudad y luego elija la primera para la lista.

Espero que ayude :)

Como kronoz dijo en.Net 3.5 puede usar Distinct().

En. Net 2 puedes imitarlo:

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;
}

Esto se puede usar para desduplicar cualquier colección y devolverá los valores en el orden original.

Normalmente es mucho más rápido filtrar una colección (como lo hacen Distinct() y esta muestra) que eliminar elementos de ella.

Un método de extensión podría ser una forma decente de hacerlo... algo como esto:

public static List<T> Deduplicate<T>(this List<T> listToDeduplicate)
{
    return listToDeduplicate.Distinct().ToList();
}

Y luego llamar así, por ejemplo:

List<int> myFilteredList = unfilteredList.Deduplicate();

En Java (asumo que C# es más o menos idéntico):

list = new ArrayList<T>(new HashSet<T>(list))

Si realmente querías mutar la lista original:

List<T> noDupes = new ArrayList<T>(new HashSet<T>(list));
list.clear();
list.addAll(noDupes);

Para preservar el orden, simplemente reemplace el HashSet con LinkedHashSet.

Si no te importa el orden, puedes meter los elementos en un HashSet, si quieres mantener el orden, puedes hacer algo como esto:

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

O el camino Linq:

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

Editar: El método HashSet es O(N) el tiempo y O(N) el espacio mientras se ordena y luego se hace único (como lo sugieren @lassevk y otros) es O(N*lgN) el tiempo y O(1) el espacio, por lo que no está tan claro para mí (como lo estaba a primera vista) que disculpas por el voto negativo temporal...)

Como método auxiliar (sin Linq):

public static List<T> Distinct<T>(this List<T> list)
{
    return (new HashSet<T>(list)).ToList();
}

Utilice el método de Linq Union.

Nota: Esta solución no requiere conocimiento de Linq, aparte de que existe.

Código

Comience agregando lo siguiente a la parte superior de su archivo de clase:

using System.Linq;

Ahora, puede usar lo siguiente para eliminar duplicados de un objeto llamado, obj1:

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

Nota: Cambie el nombre de obj1 al nombre de su objeto.

Cómo obras

1. El comando Union enumera una de cada entrada de dos objetos fuente. Puesto que obj1 es ambos objetos fuente, esto reduce obj1 a una de cada entrada.

2. El ToList()) devuelve una nueva Lista. Esto es necesario, porque comandos Linq como Union devuelve el resultado como un resultadoumumerable en lugar de modificar la Lista original o devolver una nueva Lista.

Aquí hay un método de extensión para eliminar duplicados adyacentes in-situ. Llama primero a Sort () y pasa el mismo IComparer. Esto debería ser más eficiente que la versión de Lasse V. Karlsen que llama a RemoveAt repetidamente (lo que resulta en múltiples movimientos de memoria de bloque).

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);
}

Podría ser más fácil simplemente asegurarse de que los duplicados no se agreguen a la lista.

if(items.IndexOf(new_item) < 0) 
    items.add(new_item)

Puede usar Union

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

Otra forma en. Net 2.0

    static void Main(string[] args)
    {
        List<string> alpha = new List<string>();

        for(char a = 'a'; a <= 'd'; a++)
        {
            alpha.Add(a.ToString());
            alpha.Add(a.ToString());
        }

        Console.WriteLine("Data :");
        alpha.ForEach(delegate(string t) { Console.WriteLine(t); });

        alpha.ForEach(delegate (string v)
                          {
                              if (alpha.FindAll(delegate(string t) { return t == v; }).Count > 1)
                                  alpha.Remove(v);
                          });

        Console.WriteLine("Unique Result :");
        alpha.ForEach(delegate(string t) { Console.WriteLine(t);});
        Console.ReadKey();
    }

Hay muchas maneras de resolver-el problema de duplicados en la Lista, a continuación es una de ellas:

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);
       }
  }

Saludos Ravi Ganesan

Aquí hay una solución simple que no requiere ningún LINQ difícil de leer ni ninguna ordenación previa de la lista.

   private static void CheckForDuplicateItems(List<string> items)
    {
        if (items == null ||
            items.Count == 0)
            return;

        for (int outerIndex = 0; outerIndex < items.Count; outerIndex++)
        {
            for (int innerIndex = 0; innerIndex < items.Count; innerIndex++)
            {
                if (innerIndex == outerIndex) continue;
                if (items[outerIndex].Equals(items[innerIndex]))
                {
                    // Duplicate Found
                }
            }
        }
    }

La respuesta de David J. es un buen método, sin necesidad de objetos adicionales, clasificación, etc. Sin embargo, se puede mejorar:

for (int innerIndex = items.Count - 1; innerIndex > outerIndex ; innerIndex--)

Así que el bucle exterior va arriba abajo para toda la lista, pero el bucle interior va abajo "hasta que se alcanza la posición del bucle exterior".

El bucle externo se asegura de que se procese toda la lista, el bucle interno encuentra los duplicados reales, esos solo pueden ocurrir en la parte que el bucle externo no ha procesado todavía.

O si no quieres hacer de abajo hacia arriba para el bucle interno, puede hacer que el bucle interno comience en outerIndex + 1.

  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++;
        }
     }  
  }

Al instalar el paquete MoreLINQ a través de Nuget, puede distinguir fácilmente la lista de objetos por una propiedad

IEnumerable<Catalogue> distinctCatalogues = catalogues.DistinctBy(c => c.CatalogueCode); 

Una implementación sencilla e intuitiva:

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;
    }