HashSet<T>.IsSupersetOf(IEnumerable<T>) HashSet<T>.IsSupersetOf(IEnumerable<T>) HashSet<T>.IsSupersetOf(IEnumerable<T>) HashSet<T>.IsSupersetOf(IEnumerable<T>) Method

Définition

Détermine si un objet HashSet<T> est un sur-ensemble de la collection spécifiée.Determines whether a HashSet<T> object is a superset of the specified collection.

public:
 bool IsSupersetOf(System::Collections::Generic::IEnumerable<T> ^ other);
public bool IsSupersetOf (System.Collections.Generic.IEnumerable<T> other);
member this.IsSupersetOf : seq<'T> -> bool
Public Function IsSupersetOf (other As IEnumerable(Of T)) As Boolean

Paramètres

other
IEnumerable<T> IEnumerable<T> IEnumerable<T> IEnumerable<T>

Collection à comparer à l'objet HashSet<T> actif.The collection to compare to the current HashSet<T> object.

Retours

true si l'objet HashSet<T> est un sur-ensemble de other ; sinon, false.true if the HashSet<T> object is a superset of other; otherwise, false.

Implémente

Exceptions

Exemples

L’exemple suivant crée deux HashSet<T> objets disparates et les compare entre eux.The following example creates two disparate HashSet<T> objects and compares them to each other. Dans cet exemple, allNumbers est à la fois un sur-ensemble et lowNumbers un sur-ensemble approprié de IntersectWith jusqu’à ce que allNumbers soit modifié, à l’aide de la méthode, pour contenir uniquement les valeurs qui sont présentes dans les deux ensembles.In this example, allNumbers is both a superset and a proper superset of lowNumbers until allNumbers is modified, using the IntersectWith method, to contain only values that are present in both sets. Une allNumbers fois lowNumbers et sont identiques allNumbers , est toujours un sur lowNumbers -ensemble de, mais n’est plus un sur-ensemble approprié.Once allNumbers and lowNumbers are identical, allNumbers is still a superset of lowNumbers but is no longer a proper superset.

static void Main()
{
    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));
}
/* 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

Remarques

Toutes les collections, y compris le jeu vide, sont des superensembles du jeu vide.All collections, including the empty set, are supersets of the empty set. Par conséquent, cette méthode true retourne si la collection représentée par other le paramètre est vide, même si l' HashSet<T> objet actuel est vide.Therefore, this method returns true if the collection represented by the other parameter is empty, even if the current HashSet<T> object is empty.

Cette méthode retourne false toujours si Count est inférieur au nombre d’éléments dans. otherThis method always returns false if Count is less than the number of elements in other.

Si la collection représentée par other est une HashSet<T> collection avec le même comparateur d’égalité que HashSet<T> l’objet actuel, cette méthode est unenopération O ().If the collection represented by other is a HashSet<T> collection with the same equality comparer as the current HashSet<T> object, this method is an O(n) operation. Sinon, cette méthode est une opération On( n m + ), où est le nombre d’éléments dans other et m est Count.Otherwise, this method is an O(n + m) operation, where n is the number of elements in other and m is Count.

S’applique à