Pourquoi ne puis-je récupérer un élément à partir d'un HashSet sans énumération?

Dans .Net, ce que vous êtes probablement à la recherche pour est KeyedCollection
http://msdn.microsoft.com/en-us/library/ms132438.aspx

Vous pouvez obtenir autour de la méchanceté de re-mise en œuvre de cette classe abstraite chaque fois avec un certain "générique" de l'intelligence. (Voir IKeyedObject`1.)

Remarque: Tout objet de transfert de données qui implémente IKeyedObject`1 doit avoir un substituée méthode GetHashCode simplement de retourner ce.Clé.GetHashCode(); et de même pour les est égal...

Ma Bibliothèque de classes de Base se termine généralement avec quelque chose comme ça:

public class KeyedCollection<TItem> : System.Collections.ObjectModel.KeyedCollection<TItem, TItem>
    where TItem : class
{
    public KeyedCollection() : base()
    {
    }

    public KeyedCollection(IEqualityComparer<TItem> comparer) : base(comparer)
    {
    }

    protected override TItem GetKeyForItem(TItem item)
    {
        return item;
    }
}

public class KeyedObjectCollection<TKey, TItem> : System.Collections.ObjectModel.KeyedCollection<TKey, TItem>
    where TItem : class, IKeyedObject<TKey>
    where TKey : struct
{
    public KeyedCollection() : base()
    {
    }

    protected override TItem GetKeyForItem(TItem item)
    {
        return item.Key;
    }
}

///<summary>
///I almost always implement this explicitly so the only
///classes that have access without some rigmarole
///are generic collections built to be aware that an object
///is keyed.
///</summary>
public interface IKeyedObject<TKey>
{
    TKey Key { get; }
}

J'imagine que les concepteurs de la Set interface et HashSet classe voulais m'assurer que le remove(Object) méthode définie sur la Collection l'interface a également été applicable à Set; cette méthode renvoie une valeur booléenne indiquant si l'objet a été supprimé avec succès. Si les concepteurs ont voulu fournir des fonctionnalités selon lequel remove(Object) a renvoyé l' "égalité" objet déjà dans le Set cela signifierait une autre signature de la méthode.

Aussi, étant donné que l'objet en cours de suppression est logiquement égale à l'objet passé en remove(Object) il est permis de penser au sujet de la valeur ajoutée dans le retour de l'objet contenu. Cependant, j'ai eu ce problème moi-même avant et ont utilisé une Carte de résoudre le problème.

Noter qu'en Java, une HashSet utilise un HashMap en interne et donc il n'y a pas de stockage supplémentaire de frais généraux à l'aide d'un HashMap à la place.

C'était un oubli de la bibliothèque de designers. Comme je l'ai mentionné dans une autre réponse, cette méthode a été ajoutée à .NET Framework 4.7.2 (et .NET Core 2.0 avant); voir HashSet<T>.TryGetValue. Citant la source:

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

RÉSOLU. Désireux de trouver un élément qui semble parfaitement valable pour moi, parce que le représentant de recherche peuvent différer de l'élément trouvé. Cela est particulièrement vrai si les éléments contiennent de la clé et de la valeur de l'information, et une coutume comparateur d'égalité compare la clé en partie seulement. Voir l'exemple de code. Le code contient un comparateur qui met en œuvre une recherche personnalisée et qui capture l'élément trouvé. Cela nécessite une instance de la comparer. Désactivez la référence à l'élément trouvé. Effectuer une recherche par le biais de l'affiche. Accéder à l'élément trouvé. Être conscient de multithread questions lors du partage de la comparer instance.

using System;
using System.Collections.Generic;
namespace ConsoleApplication1 {
class Box
{
public int Id;
public string Name;
public Box(int id, string name)
{
Id = id;
Name = name;
}
}
class BoxEq: IEqualityComparer<Box>
{
public Box Element;
public bool Equals(Box element, Box representative)
{
bool found = element.Id == representative.Id;
if (found)
{
Element = element;
}
return found;
}
public int GetHashCode(Box box)
{
return box.Id.GetHashCode();
}
}
class Program
{
static void Main()
{
var boxEq = new BoxEq();
var hashSet = new HashSet<Box>(boxEq);
hashSet.Add(new Box(3, "Element 3"));
var box5 = new Box(5, "Element 5");
hashSet.Add(box5);
var representative = new Box(5, "Representative 5");
boxEq.Element = null;
Console.WriteLine("Contains {0}: {1}", representative.Id, hashSet.Contains(representative));
Console.WriteLine("Found id: {0}, name: {1}", boxEq.Element.Id, boxEq.Element.Name);
Console.WriteLine("Press enter");
Console.ReadLine();
}
}
} //namespace

M'a donné une intéressante suggestion sur la manière d'utiliser une Carte, en ayant mes propres objets se définissent eux-mêmes comme KeyValuePairs. Alors qu'un bon concept, malheureusement KeyValuePair n'est pas une interface (pourquoi pas?) et c'est un struct, où l'on tire que du plan de l'air. En fin de compte je vais rouler mon propre Jeu, comme mes contraintes me permettre cette option.

Après demandais la même chose, et finement être capable de regarder le code source:

source: http://referencesource.microsoft.com/#System.Core/System/Collections/Generic/HashSet.cs

Un ensemble est une collection d'objets uniques (des objets ou des valeurs). Dans l' .net de la mise en œuvre d'un élément est le même que l'autre élément (et non unique) si la méthode Equals de la comparer retourne vrai pour les deux articles. Pas si les deux objets ont le même code de hachage. ainsi, une vérification de l'existence d'un élément est un processus en deux étapes. la première utilisation de l'hashset afin de minimiser le nombre d'éléments à compere, puis la compression elle-même.

Si vous souhaitez récupérer un élément, vous devez être en mesure de fournir la récupération de la fonction avec un identifiant unique. vous connaissez peut-être le code de hachage de l'élément que vous voulez. mais cela ne suffit pas. comme plus d'un élément peut avoir le même hash. vous aurez également besoin de fournir l'élément lui-même, de sorte que l'Égalité de méthode peut être appelée. et clairement si l'objet n'est pas une raison pour l'obtenir.

On pourrait créer une structure de données qui exige qu'aucun des deux objets uniques jamais revenir par le même code de hachage. et que vous pourriez obtenir un élément de celui-ci. il sera plus rapide de l'ajout d'*, et la récupération sera possible si vous connaissez le code de hachage. si deux éléments qui ne sont pas égales, mais de retour le même hachage sont mis dans le premier sera remplacé. pour autant que je sais que ce Type n'existe pas dans .net , et non ce n'est pas le même comme un dictionnaire.

*étant donné que la GetHash méthode est la même.