Das Gegenteil von Intersect ()

Intersect kann verwendet werden, um Übereinstimmungen zwischen zwei Sammlungen zu finden, z. B.:

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

Was ich jedoch erreichen möchte, ist das Gegenteil. Ich möchte Elemente aus einer Sammlung auflisten, die in der anderen fehlen :

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

Wie bereits erwähnt, können Sie Folgendes tun, wenn Sie als Ergebnis 4 erhalten möchten:

var nonintersect = array2.Except(array1);

Wenn Sie die reale Nicht-Schnittmenge (auch 1 und 4) möchten, sollte dies den Trick tun:

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

Dies ist nicht die leistungsstärkste Lösung, aber für kleine Listen sollte sie einwandfrei funktionieren.

Sie können verwenden

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

Oder Sie können verwenden

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

Dieser Code listet jede Sequenz nur einmal auf und Select(x => x)versteckt das Ergebnis, um eine saubere Erweiterungsmethode im Linq-Stil zu erhalten. Da es HashSet<T>seine Laufzeit verwendet, ist, O(n + m)wenn die Hashes gut verteilt sind. Doppelte Elemente in beiden Listen werden weggelassen.

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

Ich denke, Sie suchen vielleicht Except:

Der Operator Except erzeugt die eingestellte Differenz zwischen zwei Sequenzen. Es werden nur Elemente in der ersten Sequenz zurückgegeben, die in der zweiten nicht erscheinen. Optional können Sie Ihre eigene Gleichstellungsvergleichsfunktion bereitstellen.

Weitere Informationen finden Sie unter diesem Link , diesem Link oder Google.

Ich bin nicht 100% sicher, was Ihre NonIntersect-Methode tun soll (in Bezug auf die Mengenlehre) - ist es
B \ A (alles von B, was in A nicht vorkommt)?
Wenn ja, sollten Sie in der Lage sein, die Operation Except (B.Except (A)) zu verwenden.

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

Ein solcher Operator, der keinen Schnittpunkt aufweist, ist in Linq nicht vorhanden

außer -> Vereinigung -> außer

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"