HashSet<T>.SetEquals(IEnumerable<T>) Methode

Referenz

Definition

Namespace:: System.Collections.Generic

Assembly:: System.Collections.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Quelle:: HashSet.cs

Quelle:: HashSet.cs

Quelle:: HashSet.cs

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Bestimmt, ob ein HashSet<T> -Objekt und die angegebene Auflistung dieselben Elemente enthalten.

public:
 virtual bool SetEquals(System::Collections::Generic::IEnumerable<T> ^ other);

public:
 bool SetEquals(System::Collections::Generic::IEnumerable<T> ^ other);

public bool SetEquals (System.Collections.Generic.IEnumerable<T> other);

[System.Security.SecurityCritical]
public bool SetEquals (System.Collections.Generic.IEnumerable<T> other);

abstract member SetEquals : seq<'T> -> bool
override this.SetEquals : seq<'T> -> bool

[<System.Security.SecurityCritical>]
member this.SetEquals : seq<'T> -> bool

[<System.Security.SecurityCritical>]
abstract member SetEquals : seq<'T> -> bool
override this.SetEquals : seq<'T> -> bool

Public Function SetEquals (other As IEnumerable(Of T)) As Boolean

Parameter

other: IEnumerable<T>

Die Auflistung, die mit dem aktuellen HashSet<T>-Objekt verglichen werden soll.

Gibt zurück

Boolean

true, wenn das HashSet<T>-Objekt gleich otherist; andernfalls false.

Implementiert

SetEquals(IEnumerable<T>) SetEquals(IEnumerable<T>)

Attribute: SecurityCriticalAttribute

Ausnahmen

ArgumentNullException

other ist null.

Beispiele

Im folgenden Beispiel werden zwei unterschiedliche HashSet<T> Objekte erstellt und miteinander verglichen. Zunächst sind die beiden Sätze nicht gleich, was mithilfe der SetEquals-Methode veranschaulicht wird. Das allNumbersHashSet<T>-Objekt wird dann geändert, nach dem die Sätze gleich sind.

HashSet<int> lowNumbers = new HashSet<int>();
HashSet<int> allNumbers = new HashSet<int>();

for (int i = 1; i < 5; i++)
{
    lowNumbers.Add(i);
}

for (int i = 0; i < 10; i++)
{
    allNumbers.Add(i);
}

Console.Write("lowNumbers contains {0} elements: ", lowNumbers.Count);
DisplaySet(lowNumbers);

Console.Write("allNumbers contains {0} elements: ", allNumbers.Count);
DisplaySet(allNumbers);

Console.WriteLine("lowNumbers overlaps allNumbers: {0}",
    lowNumbers.Overlaps(allNumbers));

Console.WriteLine("allNumbers and lowNumbers are equal sets: {0}",
    allNumbers.SetEquals(lowNumbers));

// Show the results of sub/superset testing
Console.WriteLine("lowNumbers is a subset of allNumbers: {0}",
    lowNumbers.IsSubsetOf(allNumbers));
Console.WriteLine("allNumbers is a superset of lowNumbers: {0}",
    allNumbers.IsSupersetOf(lowNumbers));
Console.WriteLine("lowNumbers is a proper subset of allNumbers: {0}",
    lowNumbers.IsProperSubsetOf(allNumbers));
Console.WriteLine("allNumbers is a proper superset of lowNumbers: {0}",
    allNumbers.IsProperSupersetOf(lowNumbers));

// Modify allNumbers to remove numbers that are not in lowNumbers.
allNumbers.IntersectWith(lowNumbers);
Console.Write("allNumbers contains {0} elements: ", allNumbers.Count);
DisplaySet(allNumbers);

Console.WriteLine("allNumbers and lowNumbers are equal sets: {0}",
    allNumbers.SetEquals(lowNumbers));

// Show the results of sub/superset testing with the modified set.
Console.WriteLine("lowNumbers is a subset of allNumbers: {0}",
    lowNumbers.IsSubsetOf(allNumbers));
Console.WriteLine("allNumbers is a superset of lowNumbers: {0}",
    allNumbers.IsSupersetOf(lowNumbers));
Console.WriteLine("lowNumbers is a proper subset of allNumbers: {0}",
    lowNumbers.IsProperSubsetOf(allNumbers));
Console.WriteLine("allNumbers is a proper superset of lowNumbers: {0}",
    allNumbers.IsProperSupersetOf(lowNumbers));

void DisplaySet(HashSet<int> set)
{
    Console.Write("{");
    foreach (int i in set)
    {
        Console.Write(" {0}", i);
    }
    Console.WriteLine(" }");
}

/* This code example produces output similar to the following:
* lowNumbers contains 4 elements: { 1 2 3 4 }
* allNumbers contains 10 elements: { 0 1 2 3 4 5 6 7 8 9 }
* lowNumbers overlaps allNumbers: True
* allNumbers and lowNumbers are equal sets: False
* lowNumbers is a subset of allNumbers: True
* allNumbers is a superset of lowNumbers: True
* lowNumbers is a proper subset of allNumbers: True
* allNumbers is a proper superset of lowNumbers: True
* allNumbers contains 4 elements: { 1 2 3 4 }
* allNumbers and lowNumbers are equal sets: True
* lowNumbers is a subset of allNumbers: True
* allNumbers is a superset of lowNumbers: True
* lowNumbers is a proper subset of allNumbers: False
* allNumbers is a proper superset of lowNumbers: False
*/

let displaySet (set: HashSet<int>) =
    printf "{"

    for i in set do
        printf $" {i}"

    printfn " }"

let lowNumbers = HashSet<int>()
let allNumbers = HashSet<int>()

for i = 1 to 4 do
    lowNumbers.Add i |> ignore


for i = 0 to 9 do
    allNumbers.Add i |> ignore

printf $"lowNumbers contains {lowNumbers.Count} elements: "
displaySet lowNumbers

printf $"allNumbers contains {allNumbers.Count} elements: "
displaySet allNumbers

printfn $"lowNumbers overlaps allNumbers: {lowNumbers.Overlaps allNumbers}"

printfn $"allNumbers and lowNumbers are equal sets: {allNumbers.SetEquals lowNumbers}"

// Show the results of sub/superset testing
printfn $"lowNumbers is a subset of allNumbers: {lowNumbers.IsSubsetOf allNumbers}"
printfn $"allNumbers is a superset of lowNumbers: {allNumbers.IsSupersetOf lowNumbers}"
printfn $"lowNumbers is a proper subset of allNumbers: {lowNumbers.IsProperSubsetOf allNumbers}"
printfn $"allNumbers is a proper superset of lowNumbers: {allNumbers.IsProperSupersetOf lowNumbers}"

// Modify allNumbers to remove numbers that are not in lowNumbers.
allNumbers.IntersectWith lowNumbers
printf $"allNumbers contains {allNumbers.Count} elements: "
displaySet allNumbers

printfn $"allNumbers and lowNumbers are equal sets: {allNumbers.SetEquals lowNumbers}"

// Show the results of sub/superset testing with the modified set.
printfn $"lowNumbers is a subset of allNumbers: {lowNumbers.IsSubsetOf allNumbers}"
printfn $"allNumbers is a superset of lowNumbers: {allNumbers.IsSupersetOf lowNumbers}"
printfn $"lowNumbers is a proper subset of allNumbers: {lowNumbers.IsProperSubsetOf allNumbers}"
printfn $"allNumbers is a proper superset of lowNumbers: {allNumbers.IsProperSupersetOf lowNumbers}"
// This code example produces output similar to the following:
//     lowNumbers contains 4 elements: { 1 2 3 4 }
//     allNumbers contains 10 elements: { 0 1 2 3 4 5 6 7 8 9 }
//     lowNumbers overlaps allNumbers: True
//     allNumbers and lowNumbers are equal sets: False
//     lowNumbers is a subset of allNumbers: True
//     allNumbers is a superset of lowNumbers: True
//     lowNumbers is a proper subset of allNumbers: True
//     allNumbers is a proper superset of lowNumbers: True
//     allNumbers contains 4 elements: { 1 2 3 4 }
//     allNumbers and lowNumbers are equal sets: True
//     lowNumbers is a subset of allNumbers: True
//     allNumbers is a superset of lowNumbers: True
//     lowNumbers is a proper subset of allNumbers: False
//     allNumbers is a proper superset of lowNumbers: False

Shared Sub Main()

    Dim lowNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()
    Dim allNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()

    For i As Integer = 1 To 4
        lowNumbers.Add(i)
    Next i

    For i As Integer = 0 To 9
        allNumbers.Add(i)
    Next i


    Console.Write("lowNumbers contains {0} elements: ", lowNumbers.Count)
    DisplaySet(lowNumbers)

    Console.Write("allNumbers contains {0} elements: ", allNumbers.Count)
    DisplaySet(allNumbers)

    Console.WriteLine("lowNumbers overlaps allNumbers: {0}", _
        lowNumbers.Overlaps(allNumbers))

    Console.WriteLine("allNumbers and lowNumbers are equal sets: {0}", _
        allNumbers.SetEquals(lowNumbers))

    ' Show the results of sub/superset testing
    Console.WriteLine("lowNumbers is a subset of allNumbers: {0}", _
        lowNumbers.IsSubsetOf(allNumbers))
    Console.WriteLine("allNumbers is a superset of lowNumbers: {0}", _
        allNumbers.IsSupersetOf(lowNumbers))
    Console.WriteLine("lowNumbers is a proper subset of allNumbers: {0}", _
        lowNumbers.IsProperSubsetOf(allNumbers))
    Console.WriteLine("allNumbers is a proper superset of lowNumbers: {0}", _
        allNumbers.IsProperSupersetOf(lowNumbers))

    ' Modify allNumbers to remove numbers that are not in lowNumbers.
    allNumbers.IntersectWith(lowNumbers)
    Console.Write("allNumbers contains {0} elements: ", allNumbers.Count)
    DisplaySet(allNumbers)

    Console.WriteLine("allNumbers and lowNumbers are equal sets: {0}", _
        allNumbers.SetEquals(lowNumbers))

    ' Show the results of sub/superset testing with the modified set.
    Console.WriteLine("lowNumbers is a subset of allNumbers: {0}", _
        lowNumbers.IsSubsetOf(allNumbers))
    Console.WriteLine("allNumbers is a superset of lowNumbers: {0}", _
        allNumbers.IsSupersetOf(lowNumbers))
    Console.WriteLine("lowNumbers is a proper subset of allNumbers: {0}", _
        lowNumbers.IsProperSubsetOf(allNumbers))
    Console.WriteLine("allNumbers is a proper superset of lowNumbers: {0}", _
        allNumbers.IsProperSupersetOf(lowNumbers))
End Sub
' This code example produces output similar to the following:
' lowNumbers contains 4 elements: { 1 2 3 4 }
' allNumbers contains 10 elements: { 0 1 2 3 4 5 6 7 8 9 }
' lowNumbers overlaps allNumbers: True
' allNumbers and lowNumbers are equal sets: False
' lowNumbers is a subset of allNumbers: True
' allNumbers is a superset of lowNumbers: True
' lowNumbers is a proper subset of allNumbers: True
' allNumbers is a proper superset of lowNumbers: True
' allNumbers contains 4 elements: { 1 2 3 4 }
' allNumbers and lowNumbers are equal sets: True
' lowNumbers is a subset of allNumbers: True
' allNumbers is a superset of lowNumbers: True
' lowNumbers is a proper subset of allNumbers: False
' allNumbers is a proper superset of lowNumbers: False

Hinweise

Die SetEquals-Methode ignoriert doppelte Einträge und die Reihenfolge der Elemente im other-Parameter.

Wenn es sich bei der durch other dargestellten Auflistung um eine HashSet<T> Auflistung mit dem gleichen Gleichheitsvergleich wie das aktuelle HashSet<T>-Objekt handelt, handelt es sich bei dieser Methode um einen O(n)-Vorgang. Andernfalls ist diese Methode ein O(n + m) Vorgang, wobei n die Anzahl der Elemente in other und mCountist.

Gilt für:

Freigeben über