HashSet<T> 생성자

정의

HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class.

오버로드

HashSet<T>()

비어 있으며 집합 형식에 대한 기본 같음 비교자를 사용하는 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that is empty and uses the default equality comparer for the set type.

HashSet<T>(IEnumerable<T>)

집합 형식에 대한 기본 같음 비교자를 사용하고 지정된 컬렉션에서 복사한 요소가 들어 있으며 복사된 요소 수를 수용하기에 용량이 충분한 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that uses the default equality comparer for the set type, contains elements copied from the specified collection, and has sufficient capacity to accommodate the number of elements copied.

HashSet<T>(IEqualityComparer<T>)

비어 있으며 집합 형식에 대한 지정된 같음 비교자를 사용하는 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that is empty and uses the specified equality comparer for the set type.

HashSet<T>(Int32)

비어 있지만 HashSet<T> 항목에 대한 공간이 예약되어 있고 집합 형식에 대한 기본 같음 비교자를 사용하는 capacity 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that is empty, but has reserved space for capacity items and uses the default equality comparer for the set type.

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

집합 형식에 대한 지정된 같음 비교자를 사용하고 지정된 컬렉션에서 복사한 요소가 들어 있으며 복사된 요소 수를 수용하기에 용량이 충분한 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that uses the specified equality comparer for the set type, contains elements copied from the specified collection, and has sufficient capacity to accommodate the number of elements copied.

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

집합 형식에 대해 지정된 같음 비교자를 사용하고 HashSet<T> 요소를 수용할 수 있을 만큼 용량이 충분한 capacity 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that uses the specified equality comparer for the set type, and has sufficient capacity to accommodate capacity elements.

HashSet<T>(SerializationInfo, StreamingContext)

직렬화된 데이터로 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class with serialized data.

HashSet<T>()

비어 있으며 집합 형식에 대한 기본 같음 비교자를 사용하는 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that is empty and uses the default equality comparer for the set type.

public:
 HashSet();
public HashSet ();
Public Sub New ()

예제

다음 예제에서는 두 개의 HashSet<T> 개체를 만들고 채우는 방법을 보여 줍니다.The following example demonstrates how to create and populate two HashSet<T> objects. 이 예제는 UnionWith 메서드에 제공 된 더 큰 예제의 일부입니다.This example is part of a larger example provided for the UnionWith method.

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);
}
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

설명

HashSet<T> 개체의 용량은 개체가 보유할 수 있는 요소의 수입니다.The capacity of a HashSet<T> object is the number of elements that the object can hold. 개체에 요소를 추가 하면 HashSet<T> 개체의 용량이 자동으로 늘어납니다.A HashSet<T> object's capacity automatically increases as elements are added to the object.

이 생성자는 o (1) 작업입니다.This constructor is an O(1) operation.

HashSet<T>(IEnumerable<T>)

집합 형식에 대한 기본 같음 비교자를 사용하고 지정된 컬렉션에서 복사한 요소가 들어 있으며 복사된 요소 수를 수용하기에 용량이 충분한 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that uses the default equality comparer for the set type, contains elements copied from the specified collection, and has sufficient capacity to accommodate the number of elements copied.

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))

매개 변수

collection
IEnumerable<T>

해당 요소가 새 집합에 복사되는 컬렉션입니다.The collection whose elements are copied to the new set.

예외

collectionnull인 경우collection is null.

예제

다음 예에서는 기존 집합에서 HashSet<T> 컬렉션을 만드는 방법을 보여 줍니다.The following example shows how to create a HashSet<T> collection from an existing set. 이 예제에서는 두 만들어집니다 홀수 및 짝수 정수를 사용 하 여 각각.In this example, two sets are created with even and odd integers, respectively. 그런 다음 짝수 정수 집합에서 세 번째 HashSet<T> 개체가 만들어집니다.A third HashSet<T> object is then created from the even integer set.

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> set)
{
    Console.Write("{");
    foreach (int i in set)
    {
        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 }
*/
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

설명

HashSet<T> 개체의 용량은 개체가 보유할 수 있는 요소의 수입니다.The capacity of a HashSet<T> object is the number of elements that the object can hold. 개체에 요소를 추가 하면 HashSet<T> 개체의 용량이 자동으로 늘어납니다.A HashSet<T> object's capacity automatically increases as elements are added to the object.

collection에 중복이 포함 되어 있으면 집합에는 각각의 고유 요소 중 하나가 포함 됩니다.If collection contains duplicates, the set will contain one of each unique element. 예외가 throw 됩니다.No exception will be thrown. 따라서 결과 집합의 크기는 collection의 크기와 동일 하지 않습니다.Therefore, the size of the resulting set is not identical to the size of collection.

이 생성자는 O (n) 작업으로, ncollection 매개 변수에 있는 요소의 수입니다.This constructor is an O(n) operation, where n is the number of elements in the collection parameter.

HashSet<T>(IEqualityComparer<T>)

비어 있으며 집합 형식에 대한 지정된 같음 비교자를 사용하는 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that is empty and uses the specified equality comparer for the set type.

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))

매개 변수

comparer
IEqualityComparer<T>

집합의 값을 비교하려면 IEqualityComparer<T> 구현을 사용하고, 집합 형식에 대한 기본 null 구현을 사용하려면 EqualityComparer<T>을(를) 지정합니다.The IEqualityComparer<T> implementation to use when comparing values in the set, or null to use the default EqualityComparer<T> implementation for the set type.

설명

HashSet<T> 개체의 용량은 개체가 보유할 수 있는 요소의 수입니다.The capacity of a HashSet<T> object is the number of elements that the object can hold. 개체에 요소를 추가 하면 HashSet<T> 개체의 용량이 자동으로 늘어납니다.A HashSet<T> object's capacity automatically increases as elements are added to the object.

이 생성자는 o (1) 작업입니다.This constructor is an O(1) operation.

HashSet<T>(Int32)

비어 있지만 HashSet<T> 항목에 대한 공간이 예약되어 있고 집합 형식에 대한 기본 같음 비교자를 사용하는 capacity 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that is empty, but has reserved space for capacity items and uses the default equality comparer for the set type.

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)

매개 변수

capacity
Int32

HashSet<T>의 초기 크기입니다.The initial size of the HashSet<T>

설명

크기 조정에는 상대적으로 비용이 많이 들기 때문에 (rehashing 필요),이는 capacity값에 따라 초기 용량을 설정 하 여 크기를 조정 해야 하는 필요성을 최소화 하려고 시도 합니다.Since resizes are relatively expensive (require rehashing), this attempts to minimize the need to resize by setting the initial capacity based on the value of the capacity.

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

집합 형식에 대한 지정된 같음 비교자를 사용하고 지정된 컬렉션에서 복사한 요소가 들어 있으며 복사된 요소 수를 수용하기에 용량이 충분한 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that uses the specified equality comparer for the set type, contains elements copied from the specified collection, and has sufficient capacity to accommodate the number of elements copied.

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))

매개 변수

collection
IEnumerable<T>

해당 요소가 새 집합에 복사되는 컬렉션입니다.The collection whose elements are copied to the new set.

comparer
IEqualityComparer<T>

집합의 값을 비교하려면 IEqualityComparer<T> 구현을 사용하고, 집합 형식에 대한 기본 null 구현을 사용하려면 EqualityComparer<T>을(를) 지정합니다.The IEqualityComparer<T> implementation to use when comparing values in the set, or null to use the default EqualityComparer<T> implementation for the set type.

예외

collectionnull인 경우collection is null.

예제

다음 예제에서는 제공 된 IEqualityComparer<T>를 사용 하 여 차량 유형 HashSet<T> 컬렉션의 요소에 대 한 대/소문자를 구분 하지 않는 비교를 허용 합니다.The following example uses a supplied IEqualityComparer<T> to allow case-insensitive comparisons on the elements of a HashSet<T> collection of vehicle types.

#using <System.Core.dll>

using namespace System;
using namespace System::Collections::Generic;

ref class Program
{
public:
    static void Main()
    {
        HashSet<String^> ^allVehicles = gcnew HashSet<String^>(StringComparer::OrdinalIgnoreCase);
        List<String^>^ someVehicles = gcnew 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");
        for each (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");
        for each (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");
        for each (String^ vehicle in allVehicles)
        {
            Console::WriteLine(vehicle);
        }

        // Remove all the vehicles that are not 'super cool'.
        allVehicles->RemoveWhere(gcnew Predicate<String^>(&isNotSuperCool));

        Console::WriteLine("\nThe super cool vehicles are:\n");
        for each (String^ vehicle in allVehicles)
        {
            Console::WriteLine(vehicle);
        }
    }

private:
    // Predicate to determine vehicle 'coolness'.
    static bool isNotSuperCool(String^ vehicle)
    {
        bool superCool = (vehicle == "Helicopters") || (vehicle == "Motorcycles");

        return !superCool;
    }
};

int main()
{
    Program::Main();
}

// 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
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
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:" + vbNewLine)
        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(vbNewLine + "The updated HashSet contains:" + vbNewLine)
        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(vbNewLine + "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(vbNewLine + "The 'All' vehicles set contains 'roCKeTs'")
        End If

        allVehicles.ExceptWith(someVehicles)
        Console.WriteLine(vbNewLine + "The excepted HashSet contains:" + vbNewLine)
        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(vbNewLine + "The super cool vehicles are:" + vbNewLine)
        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

설명

HashSet<T> 개체의 용량은 개체가 보유할 수 있는 요소의 수입니다.The capacity of a HashSet<T> object is the number of elements that the object can hold. 개체에 요소를 추가 하면 HashSet<T> 개체의 용량이 자동으로 늘어납니다.A HashSet<T> object's capacity automatically increases as elements are added to the object.

collection에 중복이 포함 되어 있으면 집합에는 각각의 고유 요소 중 하나가 포함 됩니다.If collection contains duplicates, the set will contain one of each unique element. 예외가 throw 됩니다.No exception will be thrown. 따라서 결과 집합의 크기는 collection의 크기와 동일 하지 않습니다.Therefore, the size of the resulting set is not identical to the size of collection.

이 생성자는 O (n) 작업으로, ncollection 매개 변수에 있는 요소의 수입니다.This constructor is an O(n) operation, where n is the number of elements in the collection parameter.

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

집합 형식에 대해 지정된 같음 비교자를 사용하고 HashSet<T> 요소를 수용할 수 있을 만큼 용량이 충분한 capacity 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class that uses the specified equality comparer for the set type, and has sufficient capacity to accommodate capacity elements.

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))

매개 변수

capacity
Int32

HashSet<T>의 초기 크기입니다.The initial size of the HashSet<T>

comparer
IEqualityComparer<T>

집합의 값을 비교하려면 IEqualityComparer<T> 구현을 사용하고, 집합 형식에 대한 기본 IEqualityComparer<T> 구현을 사용하려면 null(Visual Basic의 경우 Nothing)을 지정합니다.The IEqualityComparer<T> implementation to use when comparing values in the set, or null (Nothing in Visual Basic) to use the default IEqualityComparer<T> implementation for the set type.

설명

크기 조정에는 상대적으로 비용이 많이 들기 때문에 (rehashing 필요),이는 capacity값에 따라 초기 용량을 설정 하 여 크기를 조정 해야 하는 필요성을 최소화 하려고 시도 합니다.Since resizes are relatively expensive (require rehashing), this attempts to minimize the need to resize by setting the initial capacity based on the value of the capacity.

HashSet<T>(SerializationInfo, StreamingContext)

직렬화된 데이터로 HashSet<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the HashSet<T> class with serialized data.

protected:
 HashSet(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected HashSet (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
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)

매개 변수

info
SerializationInfo

SerializationInfo 개체를 serialize하는 데 필요한 정보가 포함된 HashSet<T> 개체입니다.A SerializationInfo object that contains the information required to serialize the HashSet<T> object.

context
StreamingContext

StreamingContext 개체에 연결되어 있는 serialize된 스트림의 소스와 대상이 포함된 HashSet<T> 구조체입니다.A StreamingContext structure that contains the source and destination of the serialized stream associated with the HashSet<T> object.

설명

이 생성자는 스트림을 통해 전송 되는 개체를 다시 구성 하기 위해 역직렬화 하는 동안 호출 됩니다.This constructor is called during deserialization to reconstitute an object that is transmitted over a stream. 자세한 내용은 XML 및 SOAP Serialization합니다.For more information, see XML and SOAP Serialization.

적용 대상