Question

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

我需要使用这个

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

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

Answer 1

使用另一个Dictionary<>并按键/值的相反顺序使用它。

Answer 2

我在这方面有点晚了，但LINQ是你的朋友：

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

允许您按照自己的意愿行事。

Answer 3

我希望这是在系统库中，但是很容易推出自己的库。

下面，我将提供编写这样一个类的框架，其用法如下：

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"

请记住，双向字典的一个问题是你应该期望所有输入都是紧密耦合的。换句话说，如果您重复使用一个键或一个值，您将删除之前链接的数据：

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"]);

最后，这是一些示例代码。这是最小的 - 它应该成为任何想要充实自己版本的人的基础。请注意，我实现了一个包装类，因此我可以提供“Reverse”属性而不直接公开内部字典。

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

这不是字典的意思。你能想到一个定义，并在O(1)时间内在你喜欢的词典中找到匹配的单词吗？如果您想要一个具有该类功能的类（双向字典），您必须自己构建它（或Google用于Internet上的许多实现之一）。

Answer 5

我实际上使用了一个将ArrayList与Dictionary结合起来的类，这样我就可以根据添加的名称或顺序查找子节点，并在添加对象时保持原始顺序。

首先将对象添加到ArrayList，然后使用所需的键将ArrayList中该对象的索引添加到字典中。

这允许我以非常优化的方式按键或位置访问，同时在添加对象时保持对象的顺序。

要注意的领域是使用现有密钥添加另一个对象，该密钥将孤立原始对象并从向量中移除任何元素，这将导致字典中的索引被破坏，指向错误的值。

以为我会分享我的两分钱 - 希望它可以帮助别人。

如何在c＃中使用字典两种方式

5 个答案: