lấy khóa từ điển theo giá trị

Làm cách nào để lấy khóa Từ điển theo giá trị trong C #?

Dictionary<string, string> types = new Dictionary<string, string>()
{
            {"1", "one"},
            {"2", "two"},
            {"3", "three"}
};

Tôi muốn một cái gì đó như thế này:

getByValueKey(string value);

getByValueKey("one")phải trở về "1".

Cách tốt nhất để làm điều này là gì? Có lẽ HashTable, SortedLists?

Các giá trị không nhất thiết phải là duy nhất nên bạn phải thực hiện tra cứu. Bạn có thể làm một cái gì đó như thế này:

var myKey = types.FirstOrDefault(x => x.Value == "one").Key;

Nếu các giá trị là duy nhất và được chèn ít thường xuyên hơn đọc, thì hãy tạo một từ điển nghịch đảo trong đó các giá trị là khóa và khóa là giá trị.

Bạn có thể làm điều đó:

1. Bằng cách lặp qua tất cả các KeyValuePair<TKey, TValue>từ trong từ điển (đây sẽ là một cú đánh hiệu suất khá lớn nếu bạn có một số mục trong từ điển)
2. Sử dụng hai từ điển, một cho ánh xạ giá trị-khóa và một cho ánh xạ khóa-giá trị (sẽ chiếm gấp đôi không gian trong bộ nhớ).

Sử dụng Phương pháp 1 nếu hiệu suất không phải là một sự cân nhắc, sử dụng Phương pháp 2 nếu bộ nhớ không phải là một sự cân nhắc.

Ngoài ra, tất cả các khóa phải là duy nhất, nhưng các giá trị không bắt buộc phải là duy nhất. Bạn có thể có nhiều hơn một khóa với giá trị được chỉ định.

Có bất kỳ lý do nào bạn không thể đảo ngược mối quan hệ khóa-giá trị?

Tôi đã ở trong một tình huống mà Linq ràng buộc không có sẵn và phải mở rộng lambda một cách rõ ràng. Nó dẫn đến một chức năng đơn giản:

public static T KeyByValue<T, W>(this Dictionary<T, W> dict, W val)
{
    T key = default;
    foreach (KeyValuePair<T, W> pair in dict)
    {
        if (EqualityComparer<W>.Default.Equals(pair.Value, val))
        {
            key = pair.Key;
            break;
        }
    }
    return key;
}

Gọi nó như sau:

public static void Main()
{
    Dictionary<string, string> dict = new Dictionary<string, string>()
    {
        {"1", "one"},
        {"2", "two"},
        {"3", "three"}
    };

    string key = KeyByValue(dict, "two");       
    Console.WriteLine("Key: " + key);
}

Hoạt động trên .NET 2.0 và trong các môi trường hạn chế khác.

có thể một cái gì đó như thế này:

foreach (var keyvaluepair in dict)
{
    if(Object.ReferenceEquals(keyvaluepair.Value, searchedObject))
    {
        //dict.Remove(keyvaluepair.Key);
        break;
    }
}

Tôi đã tạo một lớp tra cứu kép:

/// <summary>
/// dictionary with double key lookup
/// </summary>
/// <typeparam name="T1">primary key</typeparam>
/// <typeparam name="T2">secondary key</typeparam>
/// <typeparam name="TValue">value type</typeparam>
public class cDoubleKeyDictionary<T1, T2, TValue> {
    private struct Key2ValuePair {
        internal T2 key2;
        internal TValue value;
    }
    private Dictionary<T1, Key2ValuePair> d1 = new Dictionary<T1, Key2ValuePair>();
    private Dictionary<T2, T1> d2 = new Dictionary<T2, T1>();

    /// <summary>
    /// add item
    /// not exacly like add, mote like Dictionary[] = overwriting existing values
    /// </summary>
    /// <param name="key1"></param>
    /// <param name="key2"></param>
    public void Add(T1 key1, T2 key2, TValue value) {
        lock (d1) {
            d1[key1] = new Key2ValuePair {
                key2 = key2,
                value = value,
            };
            d2[key2] = key1;
        }
    }

    /// <summary>
    /// get key2 by key1
    /// </summary>
    /// <param name="key1"></param>
    /// <param name="key2"></param>
    /// <returns></returns>
    public bool TryGetValue(T1 key1, out TValue value) {
        if (d1.TryGetValue(key1, out Key2ValuePair kvp)) {
            value = kvp.value;
            return true;
        } else {
            value = default;
            return false;
        }
    }

    /// <summary>
    /// get key1 by key2
    /// </summary>
    /// <param name="key2"></param>
    /// <param name="key1"></param>
    /// <remarks>
    /// 2x O(1) operation
    /// </remarks>
    /// <returns></returns>
    public bool TryGetValue2(T2 key2, out TValue value) {
        if (d2.TryGetValue(key2, out T1 key1)) {
            return TryGetValue(key1, out value);
        } else {
            value = default;
            return false;
        }
    }

    /// <summary>
    /// get key1 by key2
    /// </summary>
    /// <param name="key2"></param>
    /// <param name="key1"></param>
    /// <remarks>
    /// 2x O(1) operation
    /// </remarks>
    /// <returns></returns>
    public bool TryGetKey1(T2 key2, out T1 key1) {
        return d2.TryGetValue(key2, out key1);
    }

    /// <summary>
    /// get key1 by key2
    /// </summary>
    /// <param name="key2"></param>
    /// <param name="key1"></param>
    /// <remarks>
    /// 2x O(1) operation
    /// </remarks>
    /// <returns></returns>
    public bool TryGetKey2(T1 key1, out T2 key2) {
        if (d1.TryGetValue(key1, out Key2ValuePair kvp1)) {
            key2 = kvp1.key2;
            return true;
        } else {
            key2 = default;
            return false;
        }
    }

    /// <summary>
    /// remove item by key 1
    /// </summary>
    /// <param name="key1"></param>
    public void Remove(T1 key1) {
        lock (d1) {
            if (d1.TryGetValue(key1, out Key2ValuePair kvp)) {
                d1.Remove(key1);
                d2.Remove(kvp.key2);
            }
        }
    }

    /// <summary>
    /// remove item by key 2
    /// </summary>
    /// <param name="key2"></param>
    public void Remove2(T2 key2) {
        lock (d1) {
            if (d2.TryGetValue(key2, out T1 key1)) {
                d1.Remove(key1);
                d2.Remove(key2);
            }
        }
    }

    /// <summary>
    /// clear all items
    /// </summary>
    public void Clear() {
        lock (d1) {
            d1.Clear();
            d2.Clear();
        }
    }

    /// <summary>
    /// enumerator on key1, so we can replace Dictionary by cDoubleKeyDictionary
    /// </summary>
    /// <param name="key1"></param>
    /// <returns></returns>
    public TValue this[T1 key1] {
        get => d1[key1].value;
    }

    /// <summary>
    /// enumerator on key1, so we can replace Dictionary by cDoubleKeyDictionary
    /// </summary>
    /// <param name="key1"></param>
    /// <returns></returns>
    public TValue this[T1 key1, T2 key2] {
        set {
            lock (d1) {
                d1[key1] = new Key2ValuePair {
                    key2 = key2,
                    value = value,
                };
                d2[key2] = key1;
            }
        }
    }

types.Values.ToList().IndexOf("one");

Values.ToList () chuyển đổi giá trị từ điển của bạn thành Danh sách các đối tượng. IndexOf ("một") tìm kiếm Danh sách mới của bạn đang tìm kiếm "một" và trả về Chỉ mục phù hợp với chỉ mục của cặp Khóa / Giá trị trong từ điển.

Phương pháp này không quan tâm đến các khóa từ điển, nó chỉ đơn giản trả về chỉ mục của giá trị mà bạn đang tìm kiếm.

Hãy nhớ rằng có thể có nhiều hơn một giá trị "một" trong từ điển của bạn. Và đó là lý do không có phương pháp "lấy chìa khóa".

Mã bên dưới chỉ hoạt động nếu Nó chứa dữ liệu giá trị duy nhất

public string getKey(string Value)
{
    if (dictionary.ContainsValue(Value))
    {
        var ListValueData=new List<string>();
        var ListKeyData = new List<string>();

        var Values = dictionary.Values;
        var Keys = dictionary.Keys;

        foreach (var item in Values)
        {
            ListValueData.Add(item);
        }

        var ValueIndex = ListValueData.IndexOf(Value);
        foreach (var item in Keys)
        {
            ListKeyData.Add(item);
        }

        return  ListKeyData[ValueIndex];

    }
    return string.Empty;
}

Tôi có cách rất đơn giản để làm điều này. Nó làm việc hoàn hảo cho tôi.

Dictionary<string, string> types = new Dictionary<string, string>();

types.Add("1", "one");
types.Add("2", "two");
types.Add("3", "three");

Console.WriteLine("Please type a key to show its value: ");
string rLine = Console.ReadLine();

if(types.ContainsKey(rLine))
{
    string value_For_Key = types[rLine];
    Console.WriteLine("Value for " + rLine + " is" + value_For_Key);
}