HashSet<T>.IsProperSubsetOf(IEnumerable<T>) Méthode

Référence

Définition

Espace de noms:: System.Collections.Generic

Assembly:: System.Collections.dll

Assembly:: System.Core.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Détermine si un objet HashSet<T> appartient à la collection spécifiée.

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

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

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

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

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

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

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

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

Paramètres

other: IEnumerable<T>

Collection à comparer à l'objet HashSet<T> actif.

Retours

Boolean

true si l'objet HashSet<T> appartient à l'élément other ; sinon, false.

Implémente

IsProperSubsetOf(IEnumerable<T>) IsProperSubsetOf(IEnumerable<T>)

Attributs: SecurityCriticalAttribute

Exceptions

ArgumentNullException

other a la valeur null.

Exemples

L’exemple suivant crée deux objets disparates HashSet<T> et les compare les uns aux autres. Dans cet exemple, lowNumbers il s’agit à la fois d’un sous-ensemble et d’un sous-ensemble approprié jusqu’à allNumbers ce qu’il soit modifié, à l’aide de allNumbers la IntersectWith méthode, pour contenir uniquement des valeurs présentes dans les deux ensembles. Une fois allNumbers et lowNumbers sont identiques, lowNumbers est toujours un sous-ensemble de allNumbers mais n’est plus un sous-ensemble approprié.

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

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

Un jeu vide est un sous-ensemble approprié d’une autre collection. Par conséquent, cette méthode retourne true si la collection représentée par l’objet actuel HashSet<T> est vide, sauf si le other paramètre est également un jeu vide.

Cette méthode retourne false toujours si Count elle est supérieure ou égale au nombre d’éléments dans other.

Si la collection représentée par other est une HashSet<T> collection avec le même comparateur d’égalité que l’objet actuel HashSet<T> , cette méthode est une opération O(n). Sinon, cette méthode est une opération O(n + m), où n se trouve Count le m nombre d’éléments dans other.

S’applique à