Lo opuesto a Intersecar ()

Intersect se puede usar para buscar coincidencias entre dos colecciones, como las siguientes:

// Assign two arrays. int[] array1 = { 1, 2, 3 }; int[] array2 = { 2, 3, 4 }; // Call Intersect extension method. var intersect = array1.Intersect(array2); // Write intersection to screen. foreach (int value in intersect) { Console.WriteLine(value); // Output: 2, 3 } 

Sin embargo, lo que me gustaría lograr es todo lo contrario, me gustaría enumerar los elementos que faltan al comparar dos colecciones:

 // Assign two arrays. int[] array1 = { 1, 2, 3 }; int[] array2 = { 2, 3, 4 }; // Call Intersect extension method. var intersect = array1.NonIntersect(array2); // I've made up the NonIntersect method // Write intersection to screen. foreach (int value in intersect) { Console.WriteLine(value); // Output: 4 } 

Como se dijo, si desea obtener 4 como resultado, puede hacer esto:

 var nonintersect = array2.Except(array1); 

Si quieres la no intersección real (también la 1 y la 4), entonces esto debería ser el truco:

 var nonintersect = array1.Except(array2).Union( array2.Except(array1)); 

Esta no será la solución más eficiente, pero para listas pequeñas debería funcionar bien.

Puedes usar

 a.Except(b).Union(b.Except(a)); 

O puedes usar

 var difference = new HashSet(a); difference.SymmetricExceptWith(b); 

Este código enumera cada secuencia solo una vez y usa Select(x => x) para ocultar el resultado y obtener un método de extensión de estilo Linq limpio. Como usa HashSet su tiempo de ejecución es O(n + m) si los hash están bien distribuidos. Los elementos duplicados en cualquiera de las listas se omiten.

 public static IEnumerable SymmetricExcept(this IEnumerable seq1, IEnumerable seq2) { HashSet hashSet = new HashSet(seq1); hashSet.SymmetricExceptWith(seq2); return hashSet.Select(x => x); } 

Creo que podrías estar buscando Except :

El operador Except produce la diferencia establecida entre dos secuencias. Solo devolverá elementos en la primera secuencia que no aparecen en el segundo. Opcionalmente puede proporcionar su propia función de comparación de igualdad.

Consulte este enlace , este enlace o Google para obtener más información.

No estoy 100% seguro de lo que se supone que debe hacer su método NonIntersect (con respecto a la teoría de conjuntos): ¿es
B \ A (todo de B que no ocurre en A)?
Si es así, entonces debería poder usar la operación Excepto (B.Excepto (A)).

 ///  /// Given two list, compare and extract differences /// http://stackoverflow.com/questions/5620266/the-opposite-of-intersect ///  public class CompareList { ///  /// Returns list of items that are in initial but not in final list. ///  ///  ///  ///  public static IEnumerable NonIntersect( List initial, List final) { //subtracts the content of initial from final //assumes that final.length < initial.length return initial.Except(final); } ///  /// Returns the symmetric difference between the two list. /// http://en.wikipedia.org/wiki/Symmetric_difference ///  ///  ///  ///  public static IEnumerable SymmetricDifference( List initial, List final) { IEnumerable setA = NonIntersect(final, initial); IEnumerable setB = NonIntersect(initial, final); // sum and return the two set. return setA.Concat(setB); } } 

array1.NonIntersect (array2);

No selecionar dicho operador no está presente en Linq, debe hacerlo

excepto -> unión -> excepto

 a.except(b).union(b.Except(a)); 
 string left = "411329_SOFT_MAC_GREEN"; string right= "SOFT_MAC_GREEN"; string[] l = left.Split('_'); string[] r = right.Split('_'); string[] distinctLeft = l.Distinct().ToArray(); string[] distinctRight = r.Distinct().ToArray(); var commonWord = l.Except(r, StringComparer.OrdinalIgnoreCase) string result = String.Join("_",commonWord); result = "411329"