HashSet <T>から実際のアイテムを取得するにはどうすればよいですか?


85

なぜそれが不可能なのかについてこの質問を読みましたが、問題の解決策が見つかりませんでした。

.NETからアイテムを取得したいのHashSet<T>ですが。私はこの署名を持つメソッドを探しています:

/// <summary>
/// Determines if this set contains an item equal to <paramref name="item"/>, 
/// according to the comparison mechanism that was used when the set was created. 
/// The set is not changed. If the set does contain an item equal to 
/// <paramref name="item"/>, then the item from the set is returned.
/// </summary>
bool TryGetItem<T>(T item, out T foundItem);

このような方法でセットからアイテムを検索すると、O(1)になります。aからアイテムを取得する唯一の方法HashSet<T>は、O(n)であるすべてのアイテムを列挙することです。

自分で作成するHashSet<T>か、を使用する以外に、この問題の回避策は見つかりませんでしたDictionary<K, V>。他のアイデアはありますか?

注:
HashSet<T>アイテムが含まれているかどうかは確認したくありません。HashSet<T>(別のインスタンスに置き換えることなく)更新する必要があるため、に格納されているアイテムへの参照を取得したいと思います。私が渡す項目はTryGetItem(コンストラクターに渡した比較メカニズムによると)同じですが、同じ参照ではありません。


1
なぜContainsを使用して、入力として渡したアイテムを返しませんか?
マティアス


2
あなたは、キー値に基づいてオブジェクトをルックアップするために必要がある場合は、辞書<T>でそれを格納するためのより適切な集合であってもよい。
ThatBlairGuy

@ThatBlairGuy:その通りです。辞書を使用して独自のSetコレクションを実装し、アイテムを格納すると思います。キーはアイテムのHashCodeになります。HashSetとほぼ同じパフォーマンスが得られ、コレクションからアイテムを追加/削除/取得する必要があるたびにキーを提供する必要がなくなります。
フランソワC

2
@mathiasハッシュセットには入力と等しい項目が含まれている可能性がありますが、実際には同じではないためです。たとえば、参照型のハッシュセットが必要であるが、参照が等しいかどうかではなく、コンテンツを比較したい場合があります。
NounVerber

回答:


25

あなたが求めているものは、1年前.NET Coreに追加され、最近.NET4.7.2に追加されました

.NET Framework 4.7.2では、次のように新しい機能を有効にするいくつかのAPIを標準のコレクションタイプに追加しました。
-「TryGetValue」がSortedSetとHashSetに追加され、他のコレクションタイプで使用されるTryパターンと一致します。

署名は次のとおりです(.NET 4.7.2以降にあります)。

    //
    // Summary:
    //     Searches the set for a given value and returns the equal value it finds, if any.
    //
    // Parameters:
    //   equalValue:
    //     The value to search for.
    //
    //   actualValue:
    //     The value from the set that the search found, or the default value of T when
    //     the search yielded no match.
    //
    // Returns:
    //     A value indicating whether the search was successful.
    public bool TryGetValue(T equalValue, out T actualValue);

PS。:興味がある場合は、将来追加される関連関数HashSet.GetOrAdd(T)があります。


65

これは、実際には一連のコレクションの大きな省略です。キーのみのディクショナリ、またはオブジェクト参照の取得を可能にするHashSetのいずれかが必要になります。非常に多くの人々がそれを求めてきました、なぜそれが修正されないのかは私を超えています。

Dictionary<T, T>ディクショナリはエントリをハッシュテーブルとして格納するため、サードパーティのライブラリがない場合、最善の回避策は値と同じキーを使用することです。パフォーマンス面ではHashSetと同じですが、もちろんメモリを浪費します(エントリあたりのポインタのサイズ)。

Dictionary<T, T> myHashedCollection;
...
if(myHashedCollection.ContainsKey[item])
    item = myHashedCollection[item]; //replace duplicate
else
    myHashedCollection.Add(item, item); //add previously unknown item
...
//work with unique item

1
彼の辞書のキーは、ハッシュセット用にEqualityComparerに現在配置されているものでなければならないことをお勧めします。アイテムが等しいと実際に言っていないときにEqualityComparerを使用するのは汚いと思います(そうでなければ、比較のために作成したアイテムを使用することもできます)。キーを表すクラス/構造体を作成します。もちろん、これにはより多くのメモリが必要になります。
Ed T

1
キーはValue内に格納されるため、DictionaryではなくKeyedCollectionから継承されたコレクションを使用することをお勧めします。msdn.microsoft.com/en-us/library/ms132438(v=vs.110).aspx
アクセスが

11

このメソッドは、.NET Framework 4.7.2(およびその前の.NET Core 2.0)に追加されました。を参照してくださいHashSet<T>.TryGetValueソースの引用:

/// <summary>
/// Searches the set for a given value and returns the equal value it finds, if any.
/// </summary>
/// <param name="equalValue">The value to search for.
/// </param>
/// <param name="actualValue">
/// The value from the set that the search found, or the default value
/// of <typeparamref name="T"/> when the search yielded no match.</param>
/// <returns>A value indicating whether the search was successful.</returns>
/// <remarks>
/// This can be useful when you want to reuse a previously stored reference instead of 
/// a newly constructed one (so that more sharing of references can occur) or to look up
/// a value that has more complete data than the value you currently have, although their
/// comparer functions indicate they are equal.
/// </remarks>
public bool TryGetValue(T equalValue, out T actualValue)

1
また、SortedSetの場合も同様です。
nawfal 2018年

4

文字列等価比較器のオーバーロードについてはどうですか?

  class StringEqualityComparer : IEqualityComparer<String>
{
    public string val1;
    public bool Equals(String s1, String s2)
    {
        if (!s1.Equals(s2)) return false;
        val1 = s1;
        return true;
    }

    public int GetHashCode(String s)
    {
        return s.GetHashCode();
    }
}
public static class HashSetExtension
{
    public static bool TryGetValue(this HashSet<string> hs, string value, out string valout)
    {
        if (hs.Contains(value))
        {
            valout=(hs.Comparer as StringEqualityComparer).val1;
            return true;
        }
        else
        {
            valout = null;
            return false;
        }
    }
}

次に、HashSetを次のように宣言します。

HashSet<string> hs = new HashSet<string>(new StringEqualityComparer());

これはすべてメモリ管理に関するものです。同一のコピーではなく、ハッシュセットにある実際のアイテムを返します。したがって、上記のコードでは、同じ内容の文字列を見つけて、これへの参照を返します。文字列の場合、これはインターンが行うことと似ています。
mp666 2016

@zumalifeguard @ mp666これがそのまま動作することは保証されていません。HashSet特定の値コンバーターを提供するには、をインスタンス化する誰かが必要になります。最適な解決策はTryGetValue、specializedの新しいインスタンスを渡すことですStringEqualityComparer(そうしないas StringEqualityComparerと、nullが発生し、.val1プロパティアクセスがスローされる可能性があります)。そうすることで、StringEqualityComparerはHashSetExtension内のネストされたプライベートクラスになることができます。さらに、オーバーライドされた等式比較子の場合、StringEqualityComparerはデフォルトを呼び出す必要があります。
Graeme Wicksted 2016年

HashSetを次のように宣言する必要があります。HashSet<string> valueCash = new HashSet <string>(new StringEqualityComparer())
mp666 2016年

1
ダーティハック。私はそれがどのように機能するかを知っていますが、その怠惰はそれを一種の解決策にするだけです
M.kazem Akhgary 2017

2

さて、あなたはこのようにそれを行うことができます

YourObject x = yourHashSet.Where(w => w.Name.Contains("strin")).FirstOrDefault();

これは、選択したオブジェクトの新しいインスタンスを取得するためです。オブジェクトを更新するには、次を使用する必要があります。

yourHashSet.Where(w => w.Name.Contains("strin")).FirstOrDefault().MyProperty = "something";

これは興味深い方法です。2番目を試してラップする必要があります。リストにないものを検索すると、NullReferenceExpectionが取得されます。しかし、それは正しい方向への一歩ですか?
ピオトルクラ2016

11
LINQは、foreachループ、つまりO(n)ルックアップ時間でコレクションをトラバースします。これは問題の解決策ですが、そもそもHashSetを使用するという目的に反します。
Niklas Ekman


2

別のトリックはInternalIndexOf、HashSetの内部関数にアクセスすることにより、Reflectionを実行します。フィールド名はハードコーディングされているため、今後の.NETバージョンで変更された場合、これは機能しなくなります。

注: Monoを使用する場合は、フィールド名をからm_slotsに変更する必要があります_slots

internal static class HashSetExtensions<T>
{
    public delegate bool GetValue(HashSet<T> source, T equalValue, out T actualValue);

    public static GetValue TryGetValue { get; }

    static HashSetExtensions() {
        var targetExp = Expression.Parameter(typeof(HashSet<T>), "target");
        var itemExp   = Expression.Parameter(typeof(T), "item");
        var actualValueExp = Expression.Parameter(typeof(T).MakeByRefType(), "actualValueExp");

        var indexVar = Expression.Variable(typeof(int), "index");
        // ReSharper disable once AssignNullToNotNullAttribute
        var indexExp = Expression.Call(targetExp, typeof(HashSet<T>).GetMethod("InternalIndexOf", BindingFlags.NonPublic | BindingFlags.Instance), itemExp);

        var truePart = Expression.Block(
            Expression.Assign(
                actualValueExp, Expression.Field(
                    Expression.ArrayAccess(
                        // ReSharper disable once AssignNullToNotNullAttribute
                        Expression.Field(targetExp, typeof(HashSet<T>).GetField("m_slots", BindingFlags.NonPublic | BindingFlags.Instance)), indexVar),
                    "value")),
            Expression.Constant(true));

        var falsePart = Expression.Constant(false);

        var block = Expression.Block(
            new[] { indexVar },
            Expression.Assign(indexVar, indexExp),
            Expression.Condition(
                Expression.GreaterThanOrEqual(indexVar, Expression.Constant(0)),
                truePart,
                falsePart));

        TryGetValue = Expression.Lambda<GetValue>(block, targetExp, itemExp, actualValueExp).Compile();
    }
}

public static class Extensions
{
    public static bool TryGetValue2<T>(this HashSet<T> source, T equalValue,  out T actualValue) {
        if (source.Count > 0) {
            if (HashSetExtensions<T>.TryGetValue(source, equalValue, out actualValue)) {
                return true;
            }
        }
        actualValue = default;
        return false;
    }
}

テスト:

var x = new HashSet<int> { 1, 2, 3 };
if (x.TryGetValue2(1, out var value)) {
    Console.WriteLine(value);
}

1

それを使用することがオプションである場合、SortedSetはおそらくその状況でO(log n)ルックアップ時間を持っているでしょう。それでもO(1)ではありませんが、少なくとも優れています。


1

@ mp666回答の実装を変更して、あらゆるタイプのHashSetに使用できるようにし、デフォルトの等式比較子をオーバーライドできるようにしました。

public interface IRetainingComparer<T> : IEqualityComparer<T>
{
    T Key { get; }
    void ClearKeyCache();
}

/// <summary>
/// An <see cref="IEqualityComparer{T}"/> that retains the last key that successfully passed <see cref="IEqualityComparer{T}.Equals(T,T)"/>.
/// This class relies on the fact that <see cref="HashSet{T}"/> calls the <see cref="IEqualityComparer{T}.Equals(T,T)"/> with the first parameter
/// being an existing element and the second parameter being the one passed to the initiating call to <see cref="HashSet{T}"/> (eg. <see cref="HashSet{T}.Contains(T)"/>).
/// </summary>
/// <typeparam name="T">The type of object being compared.</typeparam>
/// <remarks>This class is thread-safe but may should not be used with any sort of parallel access (PLINQ).</remarks>
public class RetainingEqualityComparerObject<T> : IRetainingComparer<T> where T : class
{
    private readonly IEqualityComparer<T> _comparer;

    [ThreadStatic]
    private static WeakReference<T> _retained;

    public RetainingEqualityComparerObject(IEqualityComparer<T> comparer)
    {
        _comparer = comparer;
    }

    /// <summary>
    /// The retained instance on side 'a' of the <see cref="Equals"/> call which successfully met the equality requirement agains side 'b'.
    /// </summary>
    /// <remarks>Uses a <see cref="WeakReference{T}"/> so unintended memory leaks are not encountered.</remarks>
    public T Key
    {
        get
        {
            T retained;
            return _retained == null ? null : _retained.TryGetTarget(out retained) ? retained : null;
        }
    }


    /// <summary>
    /// Sets the retained <see cref="Key"/> to the default value.
    /// </summary>
    /// <remarks>This should be called prior to performing an operation that calls <see cref="Equals"/>.</remarks>
    public void ClearKeyCache()
    {
        _retained = _retained ?? new WeakReference<T>(null);
        _retained.SetTarget(null);
    }

    /// <summary>
    /// Test two objects of type <see cref="T"/> for equality retaining the object if successful.
    /// </summary>
    /// <param name="a">An instance of <see cref="T"/>.</param>
    /// <param name="b">A second instance of <see cref="T"/> to compare against <paramref name="a"/>.</param>
    /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are equal, false otherwise.</returns>
    public bool Equals(T a, T b)
    {
        if (!_comparer.Equals(a, b))
        {
            return false;
        }

        _retained = _retained ?? new WeakReference<T>(null);
        _retained.SetTarget(a);
        return true;
    }

    /// <summary>
    /// Gets the hash code value of an instance of <see cref="T"/>.
    /// </summary>
    /// <param name="o">The instance of <see cref="T"/> to obtain a hash code from.</param>
    /// <returns>The hash code value from <paramref name="o"/>.</returns>
    public int GetHashCode(T o)
    {
        return _comparer.GetHashCode(o);
    }
}

/// <summary>
/// An <see cref="IEqualityComparer{T}"/> that retains the last key that successfully passed <see cref="IEqualityComparer{T}.Equals(T,T)"/>.
/// This class relies on the fact that <see cref="HashSet{T}"/> calls the <see cref="IEqualityComparer{T}.Equals(T,T)"/> with the first parameter
/// being an existing element and the second parameter being the one passed to the initiating call to <see cref="HashSet{T}"/> (eg. <see cref="HashSet{T}.Contains(T)"/>).
/// </summary>
/// <typeparam name="T">The type of object being compared.</typeparam>
/// <remarks>This class is thread-safe but may should not be used with any sort of parallel access (PLINQ).</remarks>
public class RetainingEqualityComparerStruct<T> : IRetainingComparer<T> where T : struct 
{
    private readonly IEqualityComparer<T> _comparer;

    [ThreadStatic]
    private static T _retained;

    public RetainingEqualityComparerStruct(IEqualityComparer<T> comparer)
    {
        _comparer = comparer;
    }

    /// <summary>
    /// The retained instance on side 'a' of the <see cref="Equals"/> call which successfully met the equality requirement agains side 'b'.
    /// </summary>
    public T Key => _retained;


    /// <summary>
    /// Sets the retained <see cref="Key"/> to the default value.
    /// </summary>
    /// <remarks>This should be called prior to performing an operation that calls <see cref="Equals"/>.</remarks>
    public void ClearKeyCache()
    {
        _retained = default(T);
    }

    /// <summary>
    /// Test two objects of type <see cref="T"/> for equality retaining the object if successful.
    /// </summary>
    /// <param name="a">An instance of <see cref="T"/>.</param>
    /// <param name="b">A second instance of <see cref="T"/> to compare against <paramref name="a"/>.</param>
    /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are equal, false otherwise.</returns>
    public bool Equals(T a, T b)
    {
        if (!_comparer.Equals(a, b))
        {
            return false;
        }

        _retained = a;
        return true;
    }

    /// <summary>
    /// Gets the hash code value of an instance of <see cref="T"/>.
    /// </summary>
    /// <param name="o">The instance of <see cref="T"/> to obtain a hash code from.</param>
    /// <returns>The hash code value from <paramref name="o"/>.</returns>
    public int GetHashCode(T o)
    {
        return _comparer.GetHashCode(o);
    }
}

/// <summary>
/// Provides TryGetValue{T} functionality similar to that of <see cref="IDictionary{TKey,TValue}"/>'s implementation.
/// </summary>
public class ExtendedHashSet<T> : HashSet<T>
{
    /// <summary>
    /// This class is guaranteed to wrap the <see cref="IEqualityComparer{T}"/> with one of the <see cref="IRetainingComparer{T}"/>
    /// implementations so this property gives convenient access to the interfaced comparer.
    /// </summary>
    private IRetainingComparer<T> RetainingComparer => (IRetainingComparer<T>)Comparer;

    /// <summary>
    /// Creates either a <see cref="RetainingEqualityComparerStruct{T}"/> or <see cref="RetainingEqualityComparerObject{T}"/>
    /// depending on if <see cref="T"/> is a reference type or a value type.
    /// </summary>
    /// <param name="comparer">(optional) The <see cref="IEqualityComparer{T}"/> to wrap. This will be set to <see cref="EqualityComparer{T}.Default"/> if none provided.</param>
    /// <returns>An instance of <see cref="IRetainingComparer{T}"/>.</returns>
    private static IRetainingComparer<T> Create(IEqualityComparer<T> comparer = null)
    {
        return (IRetainingComparer<T>) (typeof(T).IsValueType ? 
            Activator.CreateInstance(typeof(RetainingEqualityComparerStruct<>)
                .MakeGenericType(typeof(T)), comparer ?? EqualityComparer<T>.Default)
            :
            Activator.CreateInstance(typeof(RetainingEqualityComparerObject<>)
                .MakeGenericType(typeof(T)), comparer ?? EqualityComparer<T>.Default));
    }

    public ExtendedHashSet() : base(Create())
    {
    }

    public ExtendedHashSet(IEqualityComparer<T> comparer) : base(Create(comparer))
    {
    }

    public ExtendedHashSet(IEnumerable<T> collection) : base(collection, Create())
    {
    }

    public ExtendedHashSet(IEnumerable<T> collection, IEqualityComparer<T> comparer) : base(collection, Create(comparer))
    {
    }

    /// <summary>
    /// Attempts to find a key in the <see cref="HashSet{T}"/> and, if found, places the instance in <paramref name="original"/>.
    /// </summary>
    /// <param name="value">The key used to search the <see cref="HashSet{T}"/>.</param>
    /// <param name="original">
    /// The matched instance from the <see cref="HashSet{T}"/> which is not neccessarily the same as <paramref name="value"/>.
    /// This will be set to null for reference types or default(T) for value types when no match found.
    /// </param>
    /// <returns>True if a key in the <see cref="HashSet{T}"/> matched <paramref name="value"/>, False if no match found.</returns>
    public bool TryGetValue(T value, out T original)
    {
        var comparer = RetainingComparer;
        comparer.ClearKeyCache();

        if (Contains(value))
        {
            original = comparer.Key;
            return true;
        }

        original = default(T);
        return false;
    }
}

public static class HashSetExtensions
{
    /// <summary>
    /// Attempts to find a key in the <see cref="HashSet{T}"/> and, if found, places the instance in <paramref name="original"/>.
    /// </summary>
    /// <param name="hashSet">The instance of <see cref="HashSet{T}"/> extended.</param>
    /// <param name="value">The key used to search the <see cref="HashSet{T}"/>.</param>
    /// <param name="original">
    /// The matched instance from the <see cref="HashSet{T}"/> which is not neccessarily the same as <paramref name="value"/>.
    /// This will be set to null for reference types or default(T) for value types when no match found.
    /// </param>
    /// <returns>True if a key in the <see cref="HashSet{T}"/> matched <paramref name="value"/>, False if no match found.</returns>
    /// <exception cref="ArgumentNullException">If <paramref name="hashSet"/> is null.</exception>
    /// <exception cref="ArgumentException">
    /// If <paramref name="hashSet"/> does not have a <see cref="HashSet{T}.Comparer"/> of type <see cref="IRetainingComparer{T}"/>.
    /// </exception>
    public static bool TryGetValue<T>(this HashSet<T> hashSet, T value, out T original)
    {
        if (hashSet == null)
        {
            throw new ArgumentNullException(nameof(hashSet));
        }

        if (hashSet.Comparer.GetType().IsInstanceOfType(typeof(IRetainingComparer<T>)))
        {
            throw new ArgumentException($"HashSet must have an equality comparer of type '{nameof(IRetainingComparer<T>)}' to use this functionality", nameof(hashSet));
        }

        var comparer = (IRetainingComparer<T>)hashSet.Comparer;
        comparer.ClearKeyCache();

        if (hashSet.Contains(value))
        {
            original = comparer.Key;
            return true;
        }

        original = default(T);
        return false;
    }
}

1
Linq拡張メソッドを使用しているためEnumerable.Contains、セットのすべての要素を列挙して比較し、セットのハッシュ実装が提供する利点を失います。次にset.SingleOrDefault(e => set.Comparer.Equals(e, obj))、ソリューションと同じ動作とパフォーマンス特性を持つを書くだけでもかまいません。
Daniel AA Pelsmaeker 2016年

@Virtlinkグッドキャッチ-あなたは絶対に正しいです。答えを修正します。
Graeme Wicksted 2016年

ただし、コンパレータを内部で使用するHashSetをラップする場合は、機能します。このように:Utillib / ExtHashSet
Daniel AA Pelsmaeker 2016年

@Virtlinkありがとうございます!最終的にHashSetを1つのオプションとしてラップしましたが、さらに汎用性を高めるために比較子と拡張メソッドを提供しました。これでスレッドセーフになり、メモリがリークすることはありません...しかし、私が思っていたよりもかなり多くのコードです!
Graeme Wicksted 2016年

@Francois上記のコードを書くことは、「最適な」時間/メモリソリューションを見つけるための演習でした。ただし、この方法を使用することはお勧めしません。カスタムIEqualityComparerでDictionary <T、T>を使用すると、はるかに簡単で将来性があります。
Graeme Wicksted 2016年

-2

HashSetにはContains(T)メソッドがあります

カスタム比較メソッドが必要な場合は、IEqualityComparerを指定できます(たとえば、人物オブジェクトを保存しますが、同等性の比較にはSSNを使用します)。


-11

ToList()メソッドを使用して、それにインデクサーを適用することもできます。

HashSet<string> mySet = new HashSet();
mySet.Add("mykey");
string key = mySet.toList()[0];

私がこのロジックを適用したときになぜあなたが反対票を獲得したのかわかりません。Dictionary <string、ISet <String >>で始まる構造から値を抽出する必要がありました。ISetにはx個の値が含まれていました。これらの値を取得する最も直接的な方法は、キーとISet値をプルする辞書をループすることでした。次に、ISetをループして、個々の値を表示しました。エレガントではありませんが、うまくいきました。
j.hull
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.