LINQ: obtention de clés pour une liste donnée de valeurs du dictionnaire et vice versa

Je avoir la structure suivante dans mon code Dictionary<TKeys, TValues> data;.
Je exécutez des requêtes LINQ sur les deux types de données et ont souvent besoin de basculer entre les Keys et Values.
Quelle est la meilleure façon d'obtenir la liste des Clés pour les Valeurs et vice-versa?
S'il vous plaît, remarquez, que j'ai l'habitude de 'IEnumerable" et "IEnumerable' la suite de mon précédent requêtes LINQ et je voudrais avoir quelque chose comme IEnumerable<TKeys> Dictionary.GetAllKeys(IEnumerable<IValues> vals) et IEnumerable<TValues> Dictionary.GetAllValues(IEnumerable<IKeys> keys).

Peut-être que j'ai besoin d'autres données de conteneur pour cette tâche?

Ce qui concerne,
Alexander.

source d'informationauteur Alexander Galkin

  1. 29
     var values = dictionary.Where(x => someKeys.Contains(x.Key)).Select(x => x.Value);
 var keys = dictionary.Where(x => someValues.Contains(x.Value)).Select(x => x.Key);
  2. 10

    Un Dictionary<,> n'est vraiment pas idéal pour trouver les clés de la valeur. Vous pourriez écrire un dictionnaire bidirectionnel, comme Je l'ai fait dans cette réponsemais il ne serait pas nécessairement être la meilleure approche.

    Bien sûr, vous peut utiliser un dictionnaire comme une séquence de paires clé/valeur, de sorte que vous pourriez avoir:

    var keysForValues = dictionary.Where(pair => values.Contains(pair.Value))
                              .Select(pair => pair.Key);

    Juste être conscient ce sera un O(n), même si vos "valeurs" est un HashSet ou quelque chose de similaire (avec une efficacité de confinement à vérifier).

    EDIT: Si vous n'avez pas vraiment besoin d'une clé/valeur, relation s'il est plus comme ils sont juste des paires - puis à l'aide de List<Tuple<Foo, Bar>> ferait une certaine quantité de sens. La requête finit par être le même, en gros:

    public IEnumerable<T1> GetAllFirst<T1, T2>(IEnumerable<Tuple<T1, T2>> source,
                                           IEnumerable<T2> seconds)
{
    HashSet<T2> secondsSet = new HashSet<T2>(seconds);
    return source.Where(pair => secondsSet.Contains(pair.Item2));
}

public IEnumerable<T2> GetAllSecond<T1, T2>(IEnumerable<Tuple<T1, T2>> source,
                                            IEnumerable<T1> firsts)
{
    HashSet<T1> firstsSet = new HashSet<T1>(firsts);
    return source.Where(pair => firstsSet.Contains(pair.Item1));
}
  3. 1

    La meilleure approche est d'effectuer votre requête linq sur la collection de paires clé-valeur, puis utiliser une sélection de projection pour sélectionner les Touches ou les Valeurs à la fin de votre requête. De cette façon, il n'est pas nécessaire d'effectuer une recherche à la fin de votre requête.

    Par exemple:

      Dictionary<string, string> data = new Dictionary<string, string>();
  //select all values for keys that contain the letter 'A'
  var values = data.Where(pair => pair.Key.Contains("A"))
                   .Select(pair => pair.Value);