Effiziente Weise zu Klonen, eine HashSet<T>?

EDIT: Nach genauerer Betrachtung bedeutet dies nicht, scheint eine gute Idee zu sein, mit weniger als 60 Elementen in der ursprünglichen hashset die Methode unten zu sein scheint langsamer dann nur die Schaffung eines neuen hashset.

HAFTUNGSAUSSCHLUSS: dies scheint zu funktionieren, aber verwenden Sie auf Ihr eigenes Risiko, wenn Sie sich zu serialisieren, die das geklonte hashsets werden Sie wahrscheinlich wollen, zu kopieren SerializationInfo m_siInfo.

Ich auch gegenüber diesem problem und nahm einen Stich an, unten finden Sie eine extension-Methode, die verwendet FieldInfo.GetValue-und SetValue-kopieren Sie die erforderlichen Felder aus. Es ist schneller, als HashSet(IEnumerable), wie viel hängt von der Menge der Elemente in der ursprünglichen hashset. Für 1000 Elementen ist der Unterschied etwa einen Faktor 7. Mit 100.000 Elementen deren etwa um den Faktor 3.

Gibt es andere Möglichkeiten, die vielleicht sogar schneller, aber das hat losgeworden der Engpass bei mir für jetzt. Ich habe versucht, mit expressiontrees und ausgeben, sondern traf eine Straßensperre, wenn ich diese zu arbeiten Ill update this post.

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

Einfach Muster, das sollte nicht Arbeit für viele Sammlungen:

Klasse cloneableDictionary(T, U) 
Erbt Dictionary(Of T, U) 
Function clone() As Dictionary(Of T, U) 
Return CType(Me.MemberwiseClone, cloneableDict(T, U)) 
End Function 
End Class 

Leider weiß ich nicht, dass Microsoft alles Tat, um zu verhindern, ruft MemberwiseClone in Orten, wo es sollte nicht aufgerufen werden (z.B. Erklärung etwas anderes als eine Methode, die-wie vielleicht ein Klasse-mit dem Namen MemberwiseClone) also ich weiß nicht, wie man sagen kann, ob ein solcher Ansatz ist wahrscheinlich zu arbeiten.

Ich denke, es ist fair Grund für eine standard-Sammlung nicht zu unterstützen, eine öffentliche Klonen Methode, aber nur ein geschützt eine: es ist möglich, dass eine Klasse, die stammt aus einer Sammlung, bricht stark, wenn geklont wird, und wenn die Basis-Klasse' cloning-Methode ist öffentlich, es gibt keinen Weg, um zu verhindern, dass ein Objekt einer abgeleiteten Klasse an code, der erwartet, dass zu Klonen.

Dass gesagt wurde, es wäre schön gewesen, wenn .net enthalten cloneableDictionary und andere Klassen wie standard-Typen (aber offensichtlich nicht realisiert im wesentlichen wie oben).

Nur ein zufälliger Gedanke. Es könnte albern sein.

Da Sie nicht ICloneable implementieren, und der Konstruktor nicht die Erkenntnis, dass die Quelle ist der gleiche Typ, ich denke, wir sind Links mit einer option. Die Umsetzung der optimierten version, und das hinzufügen von es als eine Erweiterungsmethode für den Typ.

Etwas wie:

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

Dann der code aus der Frage würde so Aussehen:

HashSet<int> original = ...
HashSet<int> clone = HashSet<int>.Clone(original);