HashSet<T> Costruttori

Definizione

Spazio dei nomi:

System.Collections.Generic

Assembly:

netstandard.dll, System.Collections.dll

Inizializza una nuova istanza della classe HashSet<T>.

Overload

Nome	Descrizione
HashSet<T>()	Inizializza una nuova istanza della HashSet<T> classe vuota e usa l'operatore di confronto di uguaglianza predefinito per il tipo di set.
HashSet<T>(IEnumerable<T>)	Inizializza una nuova istanza della HashSet<T> classe che utilizza l'operatore di confronto di uguaglianza predefinito per il tipo di set, contiene elementi copiati dalla raccolta specificata e ha capacità sufficiente per contenere il numero di elementi copiati.
HashSet<T>(IEqualityComparer<T>)	Inizializza una nuova istanza della HashSet<T> classe vuota e usa l'operatore di confronto di uguaglianza specificato per il tipo di set.
HashSet<T>(Int32)	Inizializza una nuova istanza della HashSet<T> classe vuota, ma ha spazio riservato per capacity gli elementi e usa l'operatore di confronto di uguaglianza predefinito per il tipo di set.
HashSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Inizializza una nuova istanza della HashSet<T> classe che utilizza l'operatore di confronto di uguaglianza specificato per il tipo di set, contiene elementi copiati dalla raccolta specificata e ha capacità sufficiente per contenere il numero di elementi copiati.
HashSet<T>(Int32, IEqualityComparer<T>)	Inizializza una nuova istanza della HashSet<T> classe che usa l'operatore di confronto di uguaglianza specificato per il tipo di set e ha una capacità sufficiente per contenere capacity gli elementi.
HashSet<T>(SerializationInfo, StreamingContext)	Obsoleti. Inizializza una nuova istanza della classe HashSet<T> con dati serializzati.

HashSet<T>()

Origine:

HashSet.cs

Inizializza una nuova istanza della HashSet<T> classe vuota e usa l'operatore di confronto di uguaglianza predefinito per il tipo di set.

public:
 HashSet();

public HashSet();

Public Sub New ()

Esempio

Nell'esempio seguente viene illustrato come creare e popolare due HashSet<T> oggetti. Questo esempio fa parte di un esempio più ampio fornito per il UnionWith metodo .

HashSet<int> evenNumbers = new HashSet<int>();
HashSet<int> oddNumbers = new HashSet<int>();

for (int i = 0; i < 5; i++)
{
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2);

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add((i * 2) + 1);
}

let evenNumbers = HashSet<int>()
let oddNumbers = HashSet<int>()

for i = 0 to 4 do
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2) |> ignore

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add(i * 2 + 1) |> ignore

Dim evenNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()
Dim oddNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()

For i As Integer = 0 To 4

    ' Populate evenNumbers with only even numbers.
    evenNumbers.Add(i * 2)

    ' Populate oddNumbers with only odd numbers.
    oddNumbers.Add((i * 2) + 1)
Next i

Commenti

La capacità di un HashSet<T> oggetto è il numero di elementi che l'oggetto può contenere. La capacità di un HashSet<T> oggetto aumenta automaticamente man mano che gli elementi vengono aggiunti all'oggetto.

Questo costruttore è un'operazione O(1).

HashSet<T>(IEnumerable<T>)

Origine:

HashSet.cs

Inizializza una nuova istanza della HashSet<T> classe che utilizza l'operatore di confronto di uguaglianza predefinito per il tipo di set, contiene elementi copiati dalla raccolta specificata e ha capacità sufficiente per contenere il numero di elementi copiati.

public:
 HashSet(System::Collections::Generic::IEnumerable<T> ^ collection);

public HashSet(System.Collections.Generic.IEnumerable<T> collection);

new System.Collections.Generic.HashSet<'T> : seq<'T> -> System.Collections.Generic.HashSet<'T>

Public Sub New (collection As IEnumerable(Of T))

Parametri

collection

IEnumerable<T>

Raccolta i cui elementi vengono copiati nel nuovo set.

Eccezioni

ArgumentNullException

collection è null.

Esempio

Nell'esempio seguente viene illustrato come creare una HashSet<T> raccolta da un set esistente. In questo esempio vengono creati due set rispettivamente con numeri interi pari e dispari. Viene quindi creato un terzo HashSet<T> oggetto dal set intero pari.

HashSet<int> evenNumbers = new HashSet<int>();
HashSet<int> oddNumbers = new HashSet<int>();

for (int i = 0; i < 5; i++)
{
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2);

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add((i * 2) + 1);
}

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

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

// Create a new HashSet populated with even numbers.
HashSet<int> numbers = new HashSet<int>(evenNumbers);
Console.WriteLine("numbers UnionWith oddNumbers...");
numbers.UnionWith(oddNumbers);

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

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

/* This example produces output similar to the following:
* evenNumbers contains 5 elements: { 0 2 4 6 8 }
* oddNumbers contains 5 elements: { 1 3 5 7 9 }
* numbers UnionWith oddNumbers...
* numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }
*/

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

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

    printfn " }"

let evenNumbers = HashSet<int>()
let oddNumbers = HashSet<int>()

for i = 0 to 4 do
    // Populate numbers with just even numbers.
    evenNumbers.Add(i * 2) |> ignore

    // Populate oddNumbers with just odd numbers.
    oddNumbers.Add(i * 2 + 1) |> ignore

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

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

// Create a new HashSet populated with even numbers.
let numbers = HashSet<int> evenNumbers
printfn "numbers UnionWith oddNumbers..."
numbers.UnionWith oddNumbers

printf $"numbers contains {numbers.Count} elements: "
displaySet numbers
// This example produces output similar to the following:
//    evenNumbers contains 5 elements: { 0 2 4 6 8 }
//    oddNumbers contains 5 elements: { 1 3 5 7 9 }
//    numbers UnionWith oddNumbers...
//    numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }

Shared Sub Main()

    Dim evenNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()
    Dim oddNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()

    For i As Integer = 0 To 4

        ' Populate evenNumbers with only even numbers.
        evenNumbers.Add(i * 2)

        ' Populate oddNumbers with only odd numbers.
        oddNumbers.Add((i * 2) + 1)
    Next i

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

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

    ' Create a new HashSet populated with even numbers.
    Dim numbers As HashSet(Of Integer) = New HashSet(Of Integer)(evenNumbers)
    Console.WriteLine("numbers UnionWith oddNumbers...")
    numbers.UnionWith(oddNumbers)

    Console.Write("numbers contains {0} elements: ", numbers.Count)
    DisplaySet(numbers)
End Sub

Commenti

La capacità di un HashSet<T> oggetto è il numero di elementi che l'oggetto può contenere. La capacità di un HashSet<T> oggetto aumenta automaticamente man mano che gli elementi vengono aggiunti all'oggetto.

Se collection contiene duplicati, il set conterrà uno di ogni elemento univoco. Non verrà generata alcuna eccezione. Pertanto, le dimensioni del set risultante non sono identiche alle dimensioni di collection.

Questo costruttore è un'operazione O(n), dove n è il numero di elementi nel collection parametro .

HashSet<T>(IEqualityComparer<T>)

Origine:

HashSet.cs

Inizializza una nuova istanza della HashSet<T> classe vuota e usa l'operatore di confronto di uguaglianza specificato per il tipo di set.

public:
 HashSet(System::Collections::Generic::IEqualityComparer<T> ^ comparer);

public HashSet(System.Collections.Generic.IEqualityComparer<T>? comparer);

new System.Collections.Generic.HashSet<'T> : System.Collections.Generic.IEqualityComparer<'T> -> System.Collections.Generic.HashSet<'T>

Public Sub New (comparer As IEqualityComparer(Of T))

Parametri

comparer

IEqualityComparer<T>

Implementazione IEqualityComparer<T> da usare per confrontare i valori nel set o null per usare l'implementazione predefinita EqualityComparer<T> per il tipo di set.

Commenti

La capacità di un HashSet<T> oggetto è il numero di elementi che l'oggetto può contenere. La capacità di un HashSet<T> oggetto aumenta automaticamente man mano che gli elementi vengono aggiunti all'oggetto.

Questo costruttore è un'operazione O(1).

HashSet<T>(Int32)

Origine:

HashSet.cs

Inizializza una nuova istanza della HashSet<T> classe vuota, ma ha spazio riservato per capacity gli elementi e usa l'operatore di confronto di uguaglianza predefinito per il tipo di set.

public:
 HashSet(int capacity);

public HashSet(int capacity);

new System.Collections.Generic.HashSet<'T> : int -> System.Collections.Generic.HashSet<'T>

Public Sub New (capacity As Integer)

Parametri

capacity

Int32

Dimensione iniziale dell'oggetto HashSet<T>.

Commenti

Poiché le dimensioni sono relativamente costose (richiedono il ripristino), questo tentativo di ridurre al minimo la necessità di ridimensionare impostando la capacità iniziale in base al valore di capacity.

Attenzione

Se capacity proviene dall'input dell'utente, preferire l'uso di un overload del costruttore senza un capacity parametro e lasciare che la raccolta venga ridimensionata man mano che vengono aggiunti elementi. Se è necessario usare un valore specificato dall'utente, bloccarlo a un limite ragionevole ,ad esempio Math.Clamp(untrustedValue, 0, 20), oppure verificare che il numero di elementi corrisponda al valore specificato.

HashSet<T>(IEnumerable<T>, IEqualityComparer<T>)

Origine:

HashSet.cs

Inizializza una nuova istanza della HashSet<T> classe che utilizza l'operatore di confronto di uguaglianza specificato per il tipo di set, contiene elementi copiati dalla raccolta specificata e ha capacità sufficiente per contenere il numero di elementi copiati.

public:
 HashSet(System::Collections::Generic::IEnumerable<T> ^ collection, System::Collections::Generic::IEqualityComparer<T> ^ comparer);

public HashSet(System.Collections.Generic.IEnumerable<T> collection, System.Collections.Generic.IEqualityComparer<T>? comparer);

new System.Collections.Generic.HashSet<'T> : seq<'T> * System.Collections.Generic.IEqualityComparer<'T> -> System.Collections.Generic.HashSet<'T>

Public Sub New (collection As IEnumerable(Of T), comparer As IEqualityComparer(Of T))

Parametri

collection

IEnumerable<T>

Raccolta i cui elementi vengono copiati nel nuovo set.

comparer

IEqualityComparer<T>

Implementazione IEqualityComparer<T> da usare per confrontare i valori nel set o null per usare l'implementazione predefinita EqualityComparer<T> per il tipo di set.

Eccezioni

ArgumentNullException

collection è null.

Esempio

Nell'esempio seguente viene utilizzato un oggetto fornito IEqualityComparer<T> per consentire confronti senza distinzione tra maiuscole e minuscole sugli elementi di una HashSet<T> raccolta di tipi di veicoli.

HashSet<string> allVehicles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
List<string> someVehicles = new List<string>();

someVehicles.Add("Planes");
someVehicles.Add("Trains");
someVehicles.Add("Automobiles");

// Add in the vehicles contained in the someVehicles list.
allVehicles.UnionWith(someVehicles);

Console.WriteLine("The current HashSet contains:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

allVehicles.Add("Ships");
allVehicles.Add("Motorcycles");
allVehicles.Add("Rockets");
allVehicles.Add("Helicopters");
allVehicles.Add("Submarines");

Console.WriteLine("\nThe updated HashSet contains:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

// Verify that the 'All Vehicles' set contains at least the vehicles in
// the 'Some Vehicles' list.
if (allVehicles.IsSupersetOf(someVehicles))
{
    Console.Write("\nThe 'All' vehicles set contains everything in ");
    Console.WriteLine("'Some' vechicles list.");
}

// Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
// true for the mixed-case vehicle type.
if (allVehicles.Contains("roCKeTs"))
{
    Console.WriteLine("\nThe 'All' vehicles set contains 'roCKeTs'");
}

allVehicles.ExceptWith(someVehicles);
Console.WriteLine("\nThe excepted HashSet contains:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

// Remove all the vehicles that are not 'super cool'.
allVehicles.RemoveWhere(isNotSuperCool);

Console.WriteLine("\nThe super cool vehicles are:\n");
foreach (string vehicle in allVehicles)
{
    Console.WriteLine(vehicle);
}

// Predicate to determine vehicle 'coolness'.
bool isNotSuperCool(string vehicle)
{
    bool superCool = (vehicle == "Helicopters") || (vehicle == "Motorcycles");

    return !superCool;
}

// The program writes the following output to the console.
//
// The current HashSet contains:
//
// Planes
// Trains
// Automobiles
//
// The updated HashSet contains:
//
// Planes
// Trains
// Automobiles
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The 'All' vehicles set contains everything in 'Some' vechicles list.
//
// The 'All' vehicles set contains 'roCKeTs'
//
// The excepted HashSet contains:
//
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The super cool vehicles are:
//
// Motorcycles
// Helicopters

let allVehicles = HashSet<string> StringComparer.OrdinalIgnoreCase
let someVehicles = ResizeArray()

someVehicles.Add "Planes"
someVehicles.Add "Trains"
someVehicles.Add "Automobiles"

// Add in the vehicles contained in the someVehicles list.
allVehicles.UnionWith someVehicles

printfn "The current HashSet contains:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

allVehicles.Add "Ships" |> ignore
allVehicles.Add "Motorcycles" |> ignore
allVehicles.Add "Rockets" |> ignore
allVehicles.Add "Helicopters" |> ignore
allVehicles.Add "Submarines" |> ignore

printfn "\nThe updated HashSet contains:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

// Verify that the 'All Vehicles' set contains at least the vehicles in
// the 'Some Vehicles' list.
if allVehicles.IsSupersetOf someVehicles then
    printfn "\nThe 'All' vehicles set contains everything in 'Some' vehicles list."

// Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
// true for the mixed-case vehicle type.
if allVehicles.Contains "roCKeTs" then
    printfn "\nThe 'All' vehicles set contains 'roCKeTs'"

allVehicles.ExceptWith someVehicles
printfn "\nThe excepted HashSet contains:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

// Predicate to determine vehicle 'coolness'.
let isNotSuperCool vehicle =
    let superCool = vehicle = "Helicopters" || vehicle = "Motorcycles"
    not superCool

// Remove all the vehicles that are not 'super cool'.
allVehicles.RemoveWhere isNotSuperCool |> ignore

printfn "\nThe super cool vehicles are:\n"

for vehicle in allVehicles do
    printfn $"{vehicle}"

// The program writes the following output to the console.
//
// The current HashSet contains:
//
// Planes
// Trains
// Automobiles
//
// The updated HashSet contains:
//
// Planes
// Trains
// Automobiles
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The 'All' vehicles set contains everything in 'Some' vehicles list.
//
// The 'All' vehicles set contains 'roCKeTs'
//
// The excepted HashSet contains:
//
// Ships
// Motorcycles
// Rockets
// Helicopters
// Submarines
//
// The super cool vehicles are:
//
// Motorcycles
// Helicopters

Imports System.Collections.Generic

Class Program
    Public Shared Sub Main()
        Dim allVehicles As New HashSet(Of String)(StringComparer.OrdinalIgnoreCase)
        Dim someVehicles As New List(Of String)()

        someVehicles.Add("Planes")
        someVehicles.Add("Trains")
        someVehicles.Add("Automobiles")

        ' Add in the vehicles contained in the someVehicles list.
        allVehicles.UnionWith(someVehicles)

        Console.WriteLine("The current HashSet contains:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle

        allVehicles.Add("Ships")
        allVehicles.Add("Motorcycles")
        allVehicles.Add("Rockets")
        allVehicles.Add("Helicopters")
        allVehicles.Add("Submarines")

        Console.WriteLine(Environment.NewLine + "The updated HashSet contains:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle

        ' Verify that the 'All Vehicles' set contains at least the vehicles in
        ' the 'Some Vehicles' list.
        If allVehicles.IsSupersetOf(someVehicles) Then
            Console.Write(Environment.NewLine + "The 'All' vehicles set contains everything in ")
            Console.WriteLine("'Some' vechicles list.")
        End If

        ' Check for Rockets. Here the OrdinalIgnoreCase comparer will compare
        ' True for the mixed-case vehicle type.
        If allVehicles.Contains("roCKeTs") Then
            Console.WriteLine(Environment.NewLine + "The 'All' vehicles set contains 'roCKeTs'")
        End If

        allVehicles.ExceptWith(someVehicles)
        Console.WriteLine(Environment.NewLine + "The excepted HashSet contains:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle

        ' Remove all the vehicles that are not 'super cool'.
        allVehicles.RemoveWhere(AddressOf isNotSuperCool)

        Console.WriteLine(Environment.NewLine + "The super cool vehicles are:" + Environment.NewLine)
        For Each vehicle As String In allVehicles
            Console.WriteLine(vehicle)
        Next vehicle
    End Sub

    ' Predicate to determine vehicle 'coolness'.
    Private Shared Function isNotSuperCool(vehicle As String) As Boolean
        Dim notSuperCool As Boolean = _
            (vehicle <> "Helicopters") And (vehicle <> "Motorcycles")

        Return notSuperCool
    End Function
End Class

'
' The program writes the following output to the console.
'
' The current HashSet contains:
'
' Planes
' Trains
' Automobiles
'
' The updated HashSet contains:
'
' Planes
' Trains
' Automobiles
' Ships
' Motorcycles
' Rockets
' Helicopters
' Submarines
'
' The 'All' vehicles set contains everything in 'Some' vechicles list.
'
' The 'All' vehicles set contains 'roCKeTs'
'
' The excepted HashSet contains:
'
' Ships
' Motorcycles
' Rockets
' Helicopters
' Submarines
'
' The super cool vehicles are:
'
' Motorcycles
' Helicopters

Commenti

La capacità di un HashSet<T> oggetto è il numero di elementi che l'oggetto può contenere. La capacità di un HashSet<T> oggetto aumenta automaticamente man mano che gli elementi vengono aggiunti all'oggetto.

Se collection contiene duplicati, il set conterrà uno di ogni elemento univoco. Non verrà generata alcuna eccezione. Pertanto, le dimensioni del set risultante non sono identiche alle dimensioni di collection.

Questo costruttore è un'operazione O(n), dove n è il numero di elementi nel collection parametro .

HashSet<T>(Int32, IEqualityComparer<T>)

Origine:

HashSet.cs

Inizializza una nuova istanza della HashSet<T> classe che usa l'operatore di confronto di uguaglianza specificato per il tipo di set e ha una capacità sufficiente per contenere capacity gli elementi.

public:
 HashSet(int capacity, System::Collections::Generic::IEqualityComparer<T> ^ comparer);

public HashSet(int capacity, System.Collections.Generic.IEqualityComparer<T>? comparer);

new System.Collections.Generic.HashSet<'T> : int * System.Collections.Generic.IEqualityComparer<'T> -> System.Collections.Generic.HashSet<'T>

Public Sub New (capacity As Integer, comparer As IEqualityComparer(Of T))

Parametri

capacity

Int32

Dimensione iniziale dell'oggetto HashSet<T>.

comparer

IEqualityComparer<T>

Implementazione IEqualityComparer<T> da utilizzare per confrontare i valori nel set o Null (Nothing in Visual Basic) per utilizzare l'implementazione predefinita IEqualityComparer<T> per il tipo di set.

Commenti

Poiché le dimensioni sono relativamente costose (richiedono il ripristino), questo tentativo di ridurre al minimo la necessità di ridimensionare impostando la capacità iniziale in base al valore di capacity.

Attenzione

Se capacity proviene dall'input dell'utente, preferire l'uso di un overload del costruttore senza un capacity parametro e lasciare che la raccolta venga ridimensionata man mano che vengono aggiunti elementi. Se è necessario usare un valore specificato dall'utente, bloccarlo a un limite ragionevole ,ad esempio Math.Clamp(untrustedValue, 0, 20), oppure verificare che il numero di elementi corrisponda al valore specificato.

HashSet<T>(SerializationInfo, StreamingContext)

Origine:

HashSet.cs

Attenzione

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Inizializza una nuova istanza della classe HashSet<T> con dati serializzati.

protected:
 HashSet(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected HashSet(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Collections.Generic.HashSet<'T> : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Generic.HashSet<'T>

Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parametri

info

SerializationInfo

Oggetto SerializationInfo contenente le informazioni necessarie per serializzare l'oggetto HashSet<T> .

context

StreamingContext

Struttura StreamingContext che contiene l'origine e la destinazione del flusso serializzato associato all'oggetto HashSet<T> .

Attributi

ObsoleteAttribute

Commenti

Questo costruttore viene chiamato durante la deserializzazione per ricostituire un oggetto trasmesso su un flusso. Per altre informazioni, vedere Serializzazione XML e SOAP.