也许是这样的:

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

下面的代码只在包含唯一值数据时有效:

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;
}

你可以这样做:

通过循环遍历字典中的所有KeyValuePair<TKey, TValue>(如果字典中有许多条目，这将是一个相当大的性能打击) 使用两个字典，一个用于值到键映射，一个用于键到值映射(这会占用两倍的内存空间)。

如果不考虑性能，请使用方法1;如果不考虑内存，请使用方法2。

此外，所有键都必须是唯一的，但值不要求是唯一的。您可以有多个具有指定值的键。

Dictionary<K,V>扩展。我已经用了很长时间了::

public static bool TryGetKey<K, V>(this IDictionary<K, V> instance, V value, out K key)
{
    foreach (var entry in instance)
    {
        if (!entry.Value.Equals(value))
        {
            continue;
        }
        key = entry.Key;
        return true;
    }
    key = default(K);
    return false;
}

并使用as:

public static void Main()
{
    Dictionary<string, string> dict = new Dictionary<string, string>()
    {
        {"1", "one"},
        {"2", "two"},
        {"3", "three"}
    };
     
     string value="two"; 
     if (dict.TryGetKey(value, out var returnedKey))
         Console.WriteLine($"Found Key {returnedKey}");
     else
         Console.WriteLine($"No key found for value {value}");
}

值不一定是唯一的，所以必须进行查找。你可以这样做:

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

如果值是唯一的，并且插入的频率低于读取，那么创建一个反向字典，其中值是键，键是值。

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

values . tolist()将您的字典值转换为对象列表。 IndexOf("one")搜索你的新列表，寻找"one"，并返回与字典中Key/Value对的索引匹配的Index。

这个方法并不关心字典中的键，它只是返回您正在寻找的值的索引。

请记住，在你的字典中可能有不止一个“1”值。这就是没有“get key”方法的原因。