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

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

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

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

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

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

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

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

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

Parameter

Gibt zurück

true wenn das HashSet<T> Objekt eine Teilmenge von other; andernfalls false.

Implementiert

Attribute

SecurityCriticalAttribute

Ausnahmen

Beispiele

Im folgenden Beispiel werden zwei unterschiedliche HashSet<T> Objekte erstellt und miteinander verglichen. In diesem Beispiel lowNumbers handelt es sich sowohl um eine Teilmenge als auch um eine richtige Teilmenge, bis allNumbersallNumbers die Methode verwendet IntersectWith wird, um nur Werte zu enthalten, die in beiden Sätzen vorhanden sind. Einmal allNumbers und lowNumbers identisch, ist immer noch eine Teilmenge vonallNumbers, lowNumbers ist aber keine richtige Teilmenge mehr.

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

Ein leerer Satz ist eine Teilmenge einer anderen Sammlung, einschließlich eines leeren Satzes; Daher gibt diese Methode zurück true , wenn die durch das aktuelle HashSet<T> Objekt dargestellte Auflistung leer ist, auch wenn der other Parameter ein leerer Satz ist.

Diese Methode gibt immer zurückfalse, wenn Count die Anzahl der Elemente größer ist.other

Wenn es sich bei der auflistung um other 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 handelt es sich bei dieser Methode um einen O(n + m)-Vorgang, wobei n es Countm sich um die Anzahl der Elemente handelt.other