Comment obtenir le dictionnaire TValue à partir de TKey en C#?

Question

J'ai déclaré le dictionnaire obj.

Dictionary<string, string> aDict = new Dictionary<string, string>(); 
     aDict .Add("IP", "Host"); 

Comme je me suis rappelé,

L'expression de aDict[IP] peut renvoyer la valeur (Host).

Maintenant, si je vais dans la direction opposée.

Comment obtenir la clé de la valeur? aDict[Host]?

Est-ce que le dictionnaire est une rue à sens unique en C# fonctionnant uniquement de la clé à la valeur? Merci.

Answer 1

Les dictionnaires ne fonctionnent pas comme ceux-ci et ne le sont pas non plus. Comment voulez-vous résoudre ce qui suit:

key = "1", value = "x", 
key = "2", value = "x" 

Vous pouvez le faire:

var keys = dict.Where(kvp => kvp.Value == someValue).Select(kvp => kvp.Key); 
foreach(var key in keys) { 
    Console.WriteLine(key); 
} 

Mais si vous avez vraiment besoin d'aller et venir entre les touches et les valeurs que vous devriez envisager d'encapsuler le problème en deux carte de route Voici une application très simple de ce que vous pouvez adapter à vos besoins:

class TwoWayDictionary<TLeft, TRight> { 
    IDictionary<TLeft, TRight> leftToRight = new Dictionary<TLeft, TRight>(); 
    IDictionary<TRight, TLeft> rightToLeft = new Dictionary<TRight, TLeft>(); 

    public void Add(TLeft left, TRight right) { 
     if (leftToRight.ContainsKey(left)) { 
      throw new InvalidOperationException("key left is duplicate"); 
     } 
     if (rightToLeft.ContainsKey(right)) { 
      throw new InvalidOperationException("key right is duplicate"); 
     } 
     leftToRight.Add(left, right); 
     rightToLeft.Add(right, left); 
    } 

    public bool TryGetRightByLeft(TLeft left, out TRight right) { 
     return leftToRight.TryGetValue(left, out right); 
    } 

    public bool TryGetLeftByRight(out TLeft left, TRight right) { 
     return rightToLeft.TryGetValue(right, out left); 
    } 
} 

Notez que cela suppose qu'aucune clé est jamais reproduit.

Maintenant vous pouvez dire:

TwoWayDictionary<string, string> dict = new TwoWayDictionary<string, string>(); 
dict.Add("127.0.0.1", "localhost"); 

string host; 
dict.TryGetRightByLeft("127.0.0.1", out host); 
// host is "localhost" 

string ip; 
dict.TryGetLeftByRight("localhost", out ip); 
// ip is "127.0.0.1" 

Answer 2

Le dictionnaire est une recherche unidirectionnelle. Vous pouvez toujours faire une boucle sur toutes les entrées du dictionnaire en recherchant la valeur "Host" si vous en avez besoin. Si vous prévoyez le faire beaucoup, vous pouvez simplement utiliser deux dictionnaires pour les synchroniser.

Answer 3

C'est une rue à sens unique. Les valeurs ne sont pas censés être unique, de sorte que vous ne pouvez pas regarder une clé de valeur, sauf en dénombrant le dictionnaire tout:

foreach(string s in Dict.Keys) 
{ 
    if(Dict[s] == TheValue) 
     ;//we found it! 
} 

Answer 4

Oui, le dictionnaire est fondamentalement une rue à sens unique. Par exemple, il serait possible pour de nombreuses clés d'avoir la valeur "Host", donc il n'y a pas de recherche inversée simple.

Cependant, vous pouvez parcourir le dictionnaire de noter que les clés carte à la valeur désirée:

foreach (var entry in dict) 
{ 
    if (entry.Value == desiredValue) 
    found.Add(entry.Key); 
} 

Il est évident que ce n'est pas efficace pour les grands dictionnaires bien.