O oposto de Intersect ()

O Intersect pode ser usado para encontrar correspondências entre duas collections, assim:

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

No entanto, o que eu gostaria de alcançar é o oposto, gostaria de listar os itens que estão faltando ao comparar duas collections:

 // 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 dito, se você quiser obter 4 como resultado, você pode fazer assim:

 var nonintersect = array2.Except(array1); 

Se você quer a verdadeira não-interseção (também ambas 1 e 4), então isto deve fazer o truque:

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

Esta não será a solução com maior desempenho, mas para pequenas listas deve funcionar muito bem.

Você pode usar

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

Ou você pode usar

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

Esse código enumera cada seqüência apenas uma vez e usa Select(x => x) para ocultar o resultado para obter um método de extensão limpo no estilo Linq. Como ele usa o HashSet seu tempo de execução é O(n + m) se os hashes estiverem bem distribuídos. Elementos duplicados em qualquer uma das listas são omitidos.

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

Eu acho que você pode estar procurando por Except :

O operador Excepto produz a diferença definida entre duas seqüências. Ele só retornará elementos na primeira seqüência que não aparecem no segundo. Você pode, opcionalmente, fornecer sua própria function de comparação de igualdade.

Confira este link , este link ou o Google para mais informações.

Eu não tenho 100% de certeza do que seu método NonIntersect deve fazer (em relação à teoria dos conjuntos) – é
B \ A (tudo de B que não ocorre em A)?
Se sim, então você deve ser capaz de usar a operação Exceto (B.Except (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);

Nonintersect tal operador não está presente em Linq você deve fazer

exceto -> união -> exceto

 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"