Excepto que tiene un efecto similar a Distinct?

Question

Acabo de descubrir que Except() eliminará todos los elementos en la segunda lista de la primera, pero también tiene el efecto de que hace que todos los elementos en el resultado devuelto sean distintos.

manera simple alrededor que estoy usando es Where(v => !secondList.Contains(v))

Puede alguien me explique por qué este es el comportamiento, y me apuntan a la documentación que explica esto si es posible?

Answer 1

La documentación de los estados de función Except:

la diferencia de conjuntos de dos secuencias utilizando el comparador de igualdad predeterminado para comparar los valores.

La diferencia establecida de dos conjuntos se define como los miembros del primer conjunto que no aparecen en el segundo conjunto.

La palabra importante aquí es conjunto, que es defined como:

... una estructura de datos abstracta que puede almacenar ciertos valores, sin ningún orden en particular, y no hay valores repetidos ..

Dado que Except se documenta como una operación basada en conjuntos, también tiene el efecto de hacer que los valores resultantes sean distintos.

Answer 2

Usted escribió:

manera simple en torno estoy usando es Where(v => !secondList.Contains(v))

Al hacer esto, todavía hay Distict hecho con secondList.

Por ejemplo:

var firstStrings = new [] { "1", null, null, null, "3", "3" }; 
var secondStrings = new [] { "1", "1", "1", null, null, "4" }; 
var resultStrings = firstStrings.Where(v => !secondStrings.Contains(v)); // 3, 3 

creé un método de extensión no tener distinta en absoluto. Examle de uso:

var result2Strings = firstStrings.ExceptAll(secondStrings).ToList(); // null, 3, 3 

Esto es lo que hace:

Ésta es la fuente:

public static IEnumerable<TSource> ExceptAll<TSource>(
    this IEnumerable<TSource> first, 
    IEnumerable<TSource> second) 
{ 
    // Do not call reuse the overload method because that is a slower imlementation 
    if (first == null) { throw new ArgumentNullException("first"); } 
    if (second == null) { throw new ArgumentNullException("second"); } 

    var secondList = second.ToList(); 
    return first.Where(s => !secondList.Remove(s)); 
} 

public static IEnumerable<TSource> ExceptAll<TSource>(
    this IEnumerable<TSource> first, 
    IEnumerable<TSource> second, 
    IEqualityComparer<TSource> comparer) 
{ 
    if (first == null) { throw new ArgumentNullException("first"); } 
    if (second == null) { throw new ArgumentNullException("second"); } 
    var comparerUsed = comparer ?? EqualityComparer<TSource>.Default; 

    var secondList = second.ToList(); 
    foreach (var item in first) 
    { 
     if (secondList.Contains(item, comparerUsed)) 
     { 
      secondList.Remove(item); 
     } 
     else 
     { 
      yield return item; 
     } 
    } 
} 

Editar: Una Implementación más rápida, basado en la observación de DigEmAll

public static IEnumerable<TSource> ExceptAll<TSource>(
     this IEnumerable<TSource> first, 
     IEnumerable<TSource> second) 
{ 
    return ExceptAll(first, second, null); 
} 

public static IEnumerable<TSource> ExceptAll<TSource>(
    this IEnumerable<TSource> first, 
    IEnumerable<TSource> second, 
    IEqualityComparer<TSource> comparer) 
{ 
    if (first == null) { throw new ArgumentNullException("first"); } 
    if (second == null) { throw new ArgumentNullException("second"); } 


    var secondCounts = new Dictionary<TSource, int>(comparer ?? EqualityComparer<TSource>.Default); 
    int count; 
    int nullCount = 0; 

    // Count the values from second 
    foreach (var item in second) 
    { 
     if (item == null) 
     { 
      nullCount++; 
     } 
     else 
     { 
      if (secondCounts.TryGetValue(item, out count)) 
      { 
       secondCounts[item] = count + 1; 
      } 
      else 
      { 
       secondCounts.Add(item, 1); 
      } 
     } 
    } 

    // Yield the values from first 
    foreach (var item in first) 
    { 
     if (item == null) 
     { 
      nullCount--; 
      if (nullCount < 0) 
      { 
       yield return item; 
      } 
     } 
     else 
     { 
      if (secondCounts.TryGetValue(item, out count)) 
      { 
       if (count == 0) 
       { 
        secondCounts.Remove(item); 
        yield return item; 
       } 
       else 
       { 
        secondCounts[item] = count - 1; 
       } 
      } 
      else 
      { 
       yield return item; 
      } 
     } 
    } 
} 

More info en mi blog (también variante para Intersecar y Unión)