HashSet <T>から実際のアイテムを取得する方法は？
この質問 なぜそれが不可能なのかを読んだことがありますが、問題の解決策が見つかりませんでした。
.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）になります。 HashSet<T>からアイテムを取得する唯一の方法は、O（n）であるすべてのアイテムを列挙することです。
この問題の回避策は、自分でHashSet<T>を作成するか、Dictionary<K, V>を使用する以外には見つかりません。他のアイデアは？
注：HashSet<T>にアイテムが含まれているかどうかを確認したくありません。 HashSet<T>に格納されているアイテムへの参照を取得したいのは、それを更新する必要があるためです（別のインスタンスに置き換えることなく）。 TryGetItemに渡す項目は（コンストラクタに渡した比較メカニズムによると）等しくなりますが、同じ参照にはなりません。
求めているのは 1年前の.NET Core に追加され、 最近.NET 4.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）。
これは実際には、一連のコレクションの大きな省略です。キーのみのディクショナリまたはオブジェクト参照の取得を可能にする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
このメソッドは 。NET Framework 4.7.2 （およびその前の 。NET Core 2. ）に追加されました。見る - 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)
文字列等値比較子のオーバーロードはどうですか：
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());
別のトリックは、HashSetの内部関数InternalIndexOfにアクセスすることにより、リフレクションを行います。フィールド名はハードコードされているため、今後の.NETバージョンでこれらの変更が行われた場合、これは機能しなくなります。次のソリューションは、1つの特定のタイプ（たとえば、文字列）のみをサポートしますが、ジェネリックにすることもできます。
public static class Extensions
{
private static Func<HashSet<string>, string, string> getHashSetInternalValue;
static Extensions()
{
ParameterExpression targetExp = Expression.Parameter(typeof(HashSet<string>), "target");
ParameterExpression itemExp = Expression.Parameter(typeof(string), "item");
var slotsExp = Expression.Field(targetExp, typeof(HashSet<string>).GetField("m_slots", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance));
var indexExp = Expression.Call(targetExp, typeof(HashSet<string>).GetMethod("InternalIndexOf", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance), itemExp);
var slotExp = Expression.ArrayAccess(slotsExp, indexExp);
var valueExp = Expression.Field(slotExp, "value");
var testExp = Expression.GreaterThanOrEqual(indexExp, Expression.Constant(0));
var conditionExp = Expression.Condition(testExp, valueExp, Expression.Constant(null, typeof(string)));
getHashSetInternalValue = Expression.Lambda<Func<HashSet<string>, string, string>>(conditionExp, new[] { targetExp, itemExp }).Compile();
}
/// <summary>
/// Gets the internal item value equal to <paramref name="item"/> or null if <paramref name="item"/> is not contained
/// </summary>
public static string GetInternalValue(this HashSet<string> hashet, string item)
{
return getHashSetInternalValue(hashet, item);
}
}
テスト：
var set = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "TABLE" };
var intern = set.GetInternalValue("table");
Console.WriteLine(intern); // prints "TABLE"
現在、.NET Core 2.0にはこの正確なメソッドがあります。
わかりましたので、このようにすることができます
YourObject x = yourHashSet.Where(w => w.Name.Contains("strin")).FirstOrDefault();
これは、選択したオブジェクトの新しいインスタンスを取得するためです。オブジェクトを更新するには、次を使用する必要があります。
yourHashSet.Where(w => w.Name.Contains("strin")).FirstOrDefault().MyProperty = "something";
SortedSetを使用することがオプションである場合、SortedSetはおそらくその状況でO（log n）ルックアップ時間を持ちます。まだO（1）ではありませんが、少なくとも優れています。
@ mp666 answerの実装を変更して、任意のタイプの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;
}
}