O oposto de Intersect ()

O Intersect pode ser usado para encontrar correspondências entre duas coleções, 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 conseguir é o contrário, gostaria de listar itens de uma coleção que estão faltando na outra :

// Assign two arrays.
int[] array1 = { 1, 2, 3 };
int[] array2 = { 2, 3, 4 };
// Call "NonIntersect" 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 afirmado, se você deseja obter 4 como resultado, pode fazer o seguinte:

var nonintersect = array2.Except(array1);

Se você deseja a não interseção real (também 1 e 4), faça o seguinte:

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

Essa não será a solução com melhor desempenho, mas para listas pequenas ela 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 sequê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 HashSet<T>seu tempo de execução, éO(n + m) se os hashes estão bem distribuídos. Elementos duplicados em qualquer lista são omitidos.

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

Eu acho que você pode estar procurando Except:

O operador Except produz a diferença definida entre duas sequências. Ele retornará apenas elementos na primeira sequência que não aparecem na segunda. Opcionalmente, você pode fornecer sua própria função de comparação de igualdade.

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

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, você poderá usar a operação Except (B.Except (A)).

/// <summary>
/// Given two list, compare and extract differences
/// http://stackoverflow.com/questions/5620266/the-opposite-of-intersect
/// </summary>
public class CompareList
{
    /// <summary>
    /// Returns list of items that are in initial but not in final list.
    /// </summary>
    /// <param name="listA"></param>
    /// <param name="listB"></param>
    /// <returns></returns>
    public static IEnumerable<string> NonIntersect(
        List<string> initial, List<string> final)
    {
        //subtracts the content of initial from final
        //assumes that final.length < initial.length
        return initial.Except(final);
    }

    /// <summary>
    /// Returns the symmetric difference between the two list.
    /// http://en.wikipedia.org/wiki/Symmetric_difference
    /// </summary>
    /// <param name="initial"></param>
    /// <param name="final"></param>
    /// <returns></returns>
    public static IEnumerable<string> SymmetricDifference(
        List<string> initial, List<string> final)
    {
        IEnumerable<string> setA = NonIntersect(final, initial);
        IEnumerable<string> setB = NonIntersect(initial, final);
        // sum and return the two set.
        return setA.Concat(setB);
    }
}

array1.NonIntersect (array2);

Se um operador não digitalizado não estiver presente no Linq, você deve

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"