Diferencia entre dos listas

Tengo dos listas genéricas llenas de CustomsObjects.

Necesito recuperar la diferencia entre esas dos listas (elementos que están en la primera sin los elementos de la segunda) en una tercera.

Estaba pensando que usarlo .Except()era una buena idea, pero no veo cómo usar esto ... ¡Ayuda!

Usar Exceptes exactamente la forma correcta de hacerlo. Si su tipo anula Equalsy GetHashCode, o solo está interesado en la igualdad de tipos de referencia (es decir, dos referencias solo son "iguales" si se refieren al mismo objeto exacto), puede usar:

var list3 = list1.Except(list2).ToList();

Si necesita expresar una idea personalizada de igualdad, por ejemplo, mediante ID, deberá implementar IEqualityComparer<T>. Por ejemplo:

public class IdComparer : IEqualityComparer<CustomObject>
{
    public int GetHashCode(CustomObject co)
    {
        if (co == null)
        {
            return 0;
        }
        return co.Id.GetHashCode();
    }

    public bool Equals(CustomObject x1, CustomObject x2)
    {
        if (object.ReferenceEquals(x1, x2))
        {
            return true;
        }
        if (object.ReferenceEquals(x1, null) ||
            object.ReferenceEquals(x2, null))
        {
            return false;
        }
        return x1.Id == x2.Id;
    }
}

Entonces usa:

var list3 = list1.Except(list2, new IdComparer()).ToList();

Tenga en cuenta que esto eliminará cualquier elemento duplicado. Si necesita conservar los duplicados, probablemente sería más fácil crear un conjunto list2y usar algo como:

var list3 = list1.Where(x => !set2.Contains(x)).ToList();

Podrías hacer algo como esto:

var result = customlist.Where(p => !otherlist.Any(l => p.someproperty == l.someproperty));

Creo que es importante enfatizar: el uso del método Except le devolverá los artículos que están en el primero sin los artículos del segundo solamente. No devuelve aquellos elementos en segundo que no aparecen en primero.

var list1 = new List<int> { 1, 2, 3, 4, 5};
var list2 = new List<int> { 3, 4, 5, 6, 7 };

var list3 = list1.Except(list2).ToList(); //list3 contains only 1, 2

Pero si desea obtener una diferencia real entre dos listas:

Elementos que están en el primero sin los elementos del segundo y elementos que están en el segundo sin los elementos del primero.

Necesita usar Excepto dos veces:

var list1 = new List<int> { 1, 2, 3, 4, 5};
var list2 = new List<int> { 3, 4, 5, 6, 7 };

var list3 = list1.Except(list2); //list3 contains only 1, 2
var list4 = list2.Except(list1); //list4 contains only 6, 7
var resultList = list3.Concat(list4).ToList(); //resultList contains 1, 2, 6, 7

O puede utilizar SymmetricExceptWith método de HashSet. Pero cambia el conjunto en el que llamó:

var list1 = new List<int> { 1, 2, 3, 4, 5};
var list2 = new List<int> { 3, 4, 5, 6, 7 };

var list1Set = list1.ToHashSet(); //.net framework 4.7.2 and .net core 2.0 and above otherwise new HashSet(list1)
list1Set.SymmetricExceptWith(list2);
var resultList = list1Set.ToList(); //resultList contains 1, 2, 6, 7

var third = first.Except(second);

(también puede llamar ToList()después Except(), si no le gusta hacer referencia a colecciones perezosas).

El Except()método compara los valores utilizando el comparador predeterminado, si los valores comparados son de tipos de datos base, tal como int, string, decimaletc.

De lo contrario, la comparación se realizará por dirección de objeto, que probablemente no sea lo que desea ... En ese caso, haga que sus objetos personalizados se implementen IComparable(o implemente un personalizado IEqualityComparery páselo al Except()método).

var list3 = list1.Where(x => !list2.Any(z => z.Id == x.Id)).ToList();

Nota: list3contendrá los elementos u objetos que no están en ambas listas. Nota: ToList()no estoList()

Dado que el método de extensión Except opera en dos IEumerables, me parece que será una operación O (n ^ 2). Si el rendimiento es un problema (si dice que sus listas son grandes), le sugiero que cree un HashSet de list1 y use el método ExceptWith de HashSet.

aquí está mi solución:

    List<String> list1 = new List<String>();

    List<String> list2 = new List<String>();

    List<String> exceptValue = new List<String>();

foreach(String L1 in List1) 
{
    if(!List2.Contains(L1)
    {
         exceptValue.Add(L1);
    }
}
foreach(String L2 in List2) 
{
    if(!List1.Contains(L2)
    {
         exceptValue.Add(L2);
    }
}

un poco tarde, pero aquí hay una solución que funciona para mí

 var myBaseProperty = (typeof(BaseClass)).GetProperties();//get base code properties
                    var allProperty = entity.GetProperties()[0].DeclaringType.GetProperties();//get derived class property plus base code as it is derived from it
                    var declaredClassProperties = allProperty.Where(x => !myBaseProperty.Any(l => l.Name == x.Name)).ToList();//get the difference

En el código de mención anterior, obtengo la diferencia de propiedades entre mi clase base y la lista de clases derivadas

var resultList = checklist.Where(p => myList.All(l => p.value != l.value)).ToList();

List<ObjectC> _list_DF_BW_ANB = new List<ObjectC>();    
List<ObjectA> _listA = new List<ObjectA>();
List<ObjectB> _listB = new List<ObjectB>();

foreach (var itemB in _listB )
{     
    var flat = 0;
    foreach(var itemA in _listA )
    {
        if(itemA.ProductId==itemB.ProductId)
        {
            flat = 1;
            break;
        }
    }
    if (flat == 0)
    {
        _list_DF_BW_ANB.Add(itemB);
    }
}

Si ambas listas implementan la interfaz IEnumerable, puede lograr esto usando LINQ.

list3 = list1.where(i => !list2.contains(i));

        List<int> list1 = new List<int>();
        List<int> list2 = new List<int>();
        List<int> listDifference = new List<int>();

        foreach (var item1 in list1)
        {
            foreach (var item2 in list2)
            {
                if (item1 != item2)
                    listDifference.Add(item1);
            }
        }