cómo utilizar el diccionario bidireccional en C#

Question

public static Dictionary<int, string> dic = new Dictionary<int, string>() { 
      {1,"anystring1"}, 
      {2,"anystring2"}}; 

necesito para utilizar este

string str= dic[1]; // it is possible 

int a=dic["anystring1"]; // My dream is it 

Answer 1

Eso no es lo que un diccionario está destinado a hacer. ¿Puedes pensar en una definición y encontrar al instante la palabra correspondiente en tu diccionario favorito en O(1) vez? Si desea una clase con ese tipo de funcionalidad (un diccionario bidireccional), tendrá que compilarla usted mismo (o Google para una de las muchas implementaciones en Internet).

Answer 2

Utilice otro Dictionary<> y úselo en orden inverso de clave/valor.

Answer 3

estoy un poco tarde en este caso, pero LINQ es su amigo aquí:

MyDict.FirstOrDefault(pair => pair.Value == "the value you want").Key; 

le permite hacer lo que quiere.

Answer 4

Desearía que esto estuviera en la biblioteca del sistema, pero es bastante fácil de hacer.

A continuación, voy a proporcionar el esqueleto de escribir una clase de este tipo, cuyo uso se ve como:

var twoWayDict = new TwoWayDict<string, int>(); 

twoWayDict["zero"] = 0; 
// twoWayDict["zero"] == 0 
// twoWayDict.Reverse[0] == "zero" 

twoWayDict.Reverse[1] = "one"; 
// twoWayDict["one"] == 1 
// twoWayDict.Reverse[1] == "one" 

que tener en cuenta, uno de gotcha para un diccionario bidireccional es que usted debe esperar que toda la entrada para ser estrechamente acoplado. En otras palabras, si vuelve a utilizar una clave o un valor, borrará los datos anteriores vinculados con:

twoWayDict["zero"] = 0; 

// Then later... 
twoWayDict.Reverse[0] = "ZERO"; 
// Now twoWayDict["ZERO"] == 0 

// Later still... 
// Exception: Key not found! "zero" was dropped when you re-used value 0 
Console.WriteLine(twoWayDict["zero"]); 

Por último, he aquí algunos ejemplos de código. Es mínimo: debería servir de base para cualquiera que quiera desarrollar su propia versión. Tenga en cuenta que implemento una clase contenedora para que pueda proporcionar una propiedad "Invertir" sin exponer directamente el diccionario interno.

// Generics note: K indicates "key" type and V indicates "value" type 
using System.Collections.Generic; 

namespace YourNamespaceHere.Collections 
{ 
    public class TwoWayDict<K, V> 
    { 
    private Dictionary<K, V> _dictKV; 
    private Dictionary<V, K> _dictVK; 
    private ReverseDict _reverseDict; 

    public TwoWayDict() 
    { 
     _dictKV = new Dictionary<K, V>(); 
     _dictVK = new Dictionary<V, K>(); 
     _reverseDict = new ReverseDict(this); 
    } 

    public ReverseDict Reverse 
    { 
     get { return _reverseDict; } 
    } 

    // TwoWayDict[key] -> value 
    public V this[K key] 
    { 
     get { return _dictKV[key]; } 
     set 
     { 
     // Remove any existing key/value pair 
     Remove(key); 

     _dictKV[key] = value; 
     _dictVK[value] = key; 
     } 
    } 

    public void Remove(K key) 
    { 
     if (_dictKV.ContainsKey(key)) 
     { 
     _dictVK.Remove(_dictKV[key]); 
     _dictKV.Remove(key); 
     } 
    } 

    // Wrapper that allows TwoWayDict to expose a convenient 
    // 'Reverse' property. 
    public class ReverseDict 
    { 
     private TwoWayDict<K, V> _parent; 
     public ReverseDict(TwoWayDict<K, V> parent) 
     { 
     _parent = parent; 
     } 

     public K this[V reverseKey] 
     { 
     get { return _parent._dictVK[reverseKey]; } 
     set { _parent[value] = reverseKey; } 
     } 

     public void Remove(V value) 
     { 
     if (_parent._dictVK.ContainsKey(value)) 
     { 
      _parent.Remove(_parent._dictVK[value]); 
     } 
     } 
    }  
    } 
} 

Answer 5

De hecho, me utilizar una clase que combina un ArrayList con un diccionario para que pueda mirar hacia arriba nodos hijo basándose en el nombre u orden de agregados, y mantener el orden original de los objetos a medida que se añaden.

Los objetos se agregan primero a ArrayList, luego el índice de ese objeto en ArrayList se agrega al diccionario con la tecla deseada.

Esto me permite acceder por clave o por posición, de una manera muy óptima, manteniendo el orden de los objetos a medida que se agregaron.

Las áreas conectadas a observar están agregando otro objeto usando una clave existente, que huérfana el objeto original y eliminando cualquier elemento del vector que hará que los índices en el Diccionario se corrompan, señalando los valores incorrectos.

Pensé que compartiría mi valor de dos centavos, espero que ayude a alguien.