HashSet<T>.IsProperSupersetOf(IEnumerable<T>) Metod

Definition

Namnområde:: System.Collections.Generic

Sammansättningar:: System.Collections.dll, System.Core.dll

Sammansättning:: System.Core.dll

Sammansättning:: System.Collections.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Avgör om ett HashSet<T> objekt är en riktig supermängd av den angivna samlingen.

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

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

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

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

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

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

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

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

Parametrar

other: IEnumerable<T>

Samlingen som ska jämföras med det aktuella HashSet<T> objektet.

Returer

Boolean

true om objektet HashSet<T> är en riktig superuppsättning av other, annars , false.

Implementeringar

IsProperSupersetOf(IEnumerable<T>)

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

other är null.

Exempel

I följande exempel skapas två olika HashSet<T> objekt och de jämförs med varandra. I det här exemplet allNumbers är både en superuppsättning och en riktig supermängd av tills har ändratsallNumbers, med hjälp av lowNumbersIntersectWith metoden, för att endast innehålla värden som finns i båda uppsättningarna. En gång allNumbers och lowNumbers är identiska, allNumbers är fortfarande en supermängd av lowNumbers men är inte längre en riktig superuppsättning.

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

Kommentarer

En tom uppsättning är en delmängd av en annan samling. Därför returnerar true den här metoden om samlingen som representeras av parametern other är tom om inte den aktuella HashSet<T> samlingen också är tom.

Den här metoden returnerar false alltid om Count är mindre än eller lika med antalet element i other.

Om samlingen som representeras av other är en HashSet<T> samling med samma likhetsjämförare som det aktuella HashSet<T> objektet är den här metoden en O()-nåtgärd. Annars är den här metoden en O(n + m)-åtgärd, där n är antalet element i other och m är .Count

Gäller för

Feedback

Var den här sidan till hjälp?