Le contraire d'Intersect ()

Intersect peut être utilisé pour trouver des correspondances entre deux collections, comme ceci:

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

Cependant, ce que je voudrais réaliser est le contraire, je voudrais énumérer éléments d'une collection qui manquent dans l'autre :

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

Comme indiqué, si vous souhaitez obtenir 4 comme résultat, vous pouvez faire comme ceci:

var nonintersect = array2.Except(array1);

Si vous voulez la véritable non-intersection (également à la fois 1 et 4), cela devrait faire l'affaire:

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

Ce ne sera pas la solution la plus performante, mais pour les petites listes, cela devrait très bien fonctionner.

Vous pouvez utiliser

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

Ou vous pouvez utiliser

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

Ce code énumère chaque séquence une seule fois et permet Select(x => x)de masquer le résultat pour obtenir une méthode d'extension de style Linq propre. Puisqu'il utilise HashSet<T>son runtime, c'est O(n + m)si les hachages sont bien distribués. Les éléments en double dans l'une ou l'autre liste sont omis.

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);
}

Je pense que vous cherchez peut-être Except:

L'opérateur Except produit la différence définie entre deux séquences. Il ne renverra que les éléments de la première séquence qui n'apparaissent pas dans la seconde. Vous pouvez éventuellement fournir votre propre fonction de comparaison d'égalité.

Consultez ce lien , ce lien ou Google pour plus d'informations.

Je ne suis pas sûr à 100% de ce que votre méthode NonIntersect est censée faire (en ce qui concerne la théorie des ensembles) - est-ce
B \ A (tout ce qui provient de B ne se produit pas dans A)?
Si oui, vous devriez pouvoir utiliser l'opération 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);

Un tel opérateur sans intersection n'est pas présent dans Linq, vous devriez le faire

sauf -> union -> sauf

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"