几天前，我在stackoverflow回答了一个有关HashSet<T>的有趣问题。有一个可能的解决方案是克隆hashset，而在我的回答中，我建议这样做：
HashSet<int> original = ...
HashSet<int> clone = new HashSet<int>(original);
HashSet<T> 的构造函数需要从原始哈希集中单独添加每个项，并检查它是否已经存在。显然这是浪费时间的：因为源集合是一个ISet<T>，它保证不包含重复项。应该有一种方法利用这个知识...HashSet<T> 应该实现 ICloneable, 但不幸的是, 它并不是这种情况. 作者也使用 Reflector 检查了，如果源集合是哈希集，则 HashSet<T> 构造函数是否执行了特定操作，但没有。可能可以通过反射私有字段来完成，但那将是一个丑陋的hack...如果您真的想要克隆 HashSet<T> 最有效的方法，请按照以下步骤进行（但可能会牺牲可维护性）
HashSet<T> 中的确切字段。您可能需要针对每个字段递归执行此操作。Reflection.Emit或使用表达式树生成一个方法，该方法执行所有字段的必要复制。可能需要调用其他生成的方法来复制每个字段的值。我们使用运行时代码生成，因为这是唯一直接访问私有字段的方式。FormatterServices.GetUninitializedObject(...) 实例化空对象。使用第2步生成的方法将原始对象复制到新的空对象中。AddWithPresent添加。我不明白为什么还没有人处理这个问题。 - Chibueze OpataFormatterServices.GetUnintializedObject(...)来做除了序列化之外的事情...这是一个鲜为人知的方法的史诗级用法！ - mhand编辑：经过仔细检查，这似乎不是一个好主意。在原始哈希集中有少于60个元素时，下面的方法似乎比创建新哈希集更慢。
免责声明：这似乎有效，但使用风险自负。如果您将序列化克隆的哈希集，您可能需要复制SerializationInfo m_siInfo。
我也遇到了这个问题，并尝试解决它。以下是一个扩展方法，它使用FieldInfo.GetValue和SetValue来复制所需的字段。它比使用HashSet(IEnumerable)更快，速度取决于原始哈希集中的元素数量。对于1,000个元素，差异约为7倍。对于100,000个元素，差异约为3倍。
还有其他可能更快的方法，但现在这个方法已经消除了我的瓶颈。我尝试使用表达式树和发射，但遇到了障碍，如果我让它们工作，我会更新此帖子。
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.Serialization;
public static class HashSetExtensions
{
public static HashSet<T> Clone<T>(this HashSet<T> original)
{
var clone = (HashSet<T>)FormatterServices.GetUninitializedObject(typeof(HashSet<T>));
Copy(Fields<T>.comparer, original, clone);
if (original.Count == 0)
{
Fields<T>.freeList.SetValue(clone, -1);
}
else
{
Fields<T>.count.SetValue(clone, original.Count);
Clone(Fields<T>.buckets, original, clone);
Clone(Fields<T>.slots, original, clone);
Copy(Fields<T>.freeList, original, clone);
Copy(Fields<T>.lastIndex, original, clone);
Copy(Fields<T>.version, original, clone);
}
return clone;
}
static void Copy<T>(FieldInfo field, HashSet<T> source, HashSet<T> target)
{
field.SetValue(target, field.GetValue(source));
}
static void Clone<T>(FieldInfo field, HashSet<T> source, HashSet<T> target)
{
field.SetValue(target, ((Array)field.GetValue(source)).Clone());
}
static class Fields<T>
{
public static readonly FieldInfo freeList = GetFieldInfo("m_freeList");
public static readonly FieldInfo buckets = GetFieldInfo("m_buckets");
public static readonly FieldInfo slots = GetFieldInfo("m_slots");
public static readonly FieldInfo count = GetFieldInfo("m_count");
public static readonly FieldInfo lastIndex = GetFieldInfo("m_lastIndex");
public static readonly FieldInfo version = GetFieldInfo("m_version");
public static readonly FieldInfo comparer = GetFieldInfo("m_comparer");
static FieldInfo GetFieldInfo(string name)
{
return typeof(HashSet<T>).GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
}
}
}
易于实现但并不适用于许多集合的简单模式：
Class cloneableDictionary(Of T, U)
Inherits Dictionary(Of T, U)
Function clone() As Dictionary(Of T, U)
Return CType(Me.MemberwiseClone, cloneableDict(Of T, U))
End Function
End Class
不幸的是，我不知道微软是否采取了任何措施来防止在不应该调用MemberwiseClone的地方（例如声明名称为MemberwiseClone的方法之外的其他内容，比如类）中调用它，因此我不知道这种方法是否可行。
我认为标准集合不支持公共克隆方法而只支持受保护的方法是有充分理由的：如果克隆一个从集合派生的类可能会严重破坏它，如果基类的克隆方法是公共的，就无法防止将派生类的对象提供给期望克隆它的代码。
话虽如此，如果.NET包括cloneableDictionary和其他这样的类作为标准类型（尽管显然不是像上面那样实现），那就太好了。
O(n)克隆是理论上可以得到的最好的克隆两个不共享相同底层数据结构的集合的方法。
检查一个元素是否在HashSet中应该是一个常数时间（即O(1)）操作。
因此，您可以创建一个包装器，只需包装现有的HashSet并保留任何新添加的内容，但这似乎相当反常。
当您说“高效”时，您的意思是“比现有的O(n)方法更高效”-我认为您实际上无法在没有对“克隆”的含义进行严格语义游戏的情况下获得比O(n)更高效的方法。
List<T>.Add和HashSet<T>.Add一样具有O(1)的复杂度，但它更快，因为它不需要检查项目是否已经存在。所以，当我说“高效”的时候，我的意思是更快，而不是更简单。 - Thomas Levesque只是个随意的想法，可能有点儿傻。
由于它们没有实现 ICloneable 接口，而且构造函数没有使用源类型相同的知识，所以我认为我们只有一种选择。就是实现优化版本，并将其作为扩展方法添加到该类型中。
类似于：
namespace ExtensionMethods
{
public static class MyExtensions
{
public static HashSet<int> Clone(this HashSet<int> original)
{
HashSet<int> clone = new HashSet<int>();
//your optimized code here
return clone;
}
}
}
那么，你在问题中的代码将会是这样的：
HashSet<int> original = ...
HashSet<int> clone = HashSet<int>.Clone(original);