哪个更有效：Dictionary TryGetValue 或 ContainsKey+Item？

Question

从 MSDN 上的Dictionary.TryGetValue Method条目：

此方法结合了 ContainsKey 方法和 Item 属性的功能。

如果未找到键，则 value 参数为值类型 TValue 获取适当的默认值； 例如，整数类型为 0（零），布尔类型为 false，引用类型为 null。

如果您的代码经常尝试访问不在字典中的键，请使用 TryGetValue 方法。 使用此方法比捕获 Item 属性抛出的 KeyNotFoundException 更有效。

此方法接近 O(1) 操作。

从描述中，不清楚它是否比调用 ContainsKey 然后进行查找更有效或更方便。 TryGetValue的实现是先调用 ContainsKey 然后调用 Item 还是实际上比通过单次查找更有效？

换句话说，什么更有效（即哪个执行更少的查找）：

Dictionary<int,int> dict;
//...//
int ival;
if(dict.ContainsKey(ikey))
{
  ival = dict[ikey];
}
else
{
  ival = default(int);
}

或者

Dictionary<int,int> dict;
//...//
int ival;
dict.TryGetValue(ikey, out ival);

注意：我不是在寻找基准！

Answer 1

TryGetValue会更快。

ContainsKey使用与TryGetValue相同的检查，它在内部引用实际的入口位置。 Item属性实际上具有与TryGetValue几乎相同的代码功能，只是它会抛出异常而不是返回 false。

使用ContainsKey后跟Item基本上重复了查找功能，这是本例中的大部分计算。

Answer 2

一个快速的基准测试表明TryGetValue有一点优势：

    static void Main() {
        var d = new Dictionary<string, string> {{"a", "b"}};
        var start = DateTime.Now;
        for (int i = 0; i != 10000000; i++) {
            string x;
            if (!d.TryGetValue("a", out x)) throw new ApplicationException("Oops");
            if (d.TryGetValue("b", out x)) throw new ApplicationException("Oops");
        }
        Console.WriteLine(DateTime.Now-start);
        start = DateTime.Now;
        for (int i = 0; i != 10000000; i++) {
            string x;
            if (d.ContainsKey("a")) {
                x = d["a"];
            } else {
                x = default(string);
            }
            if (d.ContainsKey("b")) {
                x = d["b"];
            } else {
                x = default(string);
            }
        }
   }

这产生

00:00:00.7600000
00:00:01.0610000

假设命中和未命中的均匀混合，使ContainsKey + Item访问速度降低约 40%。

此外，当我将程序更改为始终未命中（即始终查找"b" ）时，这两个版本变得同样快：

00:00:00.2850000
00:00:00.2720000

然而，当我让它“全部成功”时， TryGetValue仍然是一个明显的赢家：

00:00:00.4930000
00:00:00.8110000

Answer 3

由于到目前为止没有一个答案真正回答了这个问题，这是我经过一些研究后发现的一个可以接受的答案：

如果您反编译 TryGetValue，您会看到它正在执行以下操作：

public bool TryGetValue(TKey key, out TValue value)
{
  int index = this.FindEntry(key);
  if (index >= 0)
  {
    value = this.entries[index].value;
    return true;
  }
  value = default(TValue);
  return false;
}

而ContainsKey方法是：

public bool ContainsKey(TKey key)
{
  return (this.FindEntry(key) >= 0);
}

所以 TryGetValue 只是 ContainsKey 加上数组查找（如果该项目存在）。

来源

看起来 TryGetValue 的速度几乎是 ContainsKey+Item 组合的两倍。

Answer 4

谁在乎 ：-）

您可能会问，因为TryGetValue使用起来很TryGetValue - 所以用扩展方法像这样封装它。

public static class CollectionUtils
{
    // my original method
    // public static V GetValueOrDefault<K, V>(this Dictionary<K, V> dic, K key)
    // {
    //    V ret;
    //    bool found = dic.TryGetValue(key, out ret);
    //    if (found)
    //    {
    //        return ret;
    //    }
    //    return default(V);
    // }


    // EDIT: one of many possible improved versions
    public static TValue GetValueOrDefault<K, V>(this IDictionary<K, V> dictionary, K key)
    {
        // initialized to default value (such as 0 or null depending upon type of TValue)
        TValue value;  

        // attempt to get the value of the key from the dictionary
        dictionary.TryGetValue(key, out value);
        return value;
    }

然后只需调用：

dict.GetValueOrDefault("keyname")

或者

(dict.GetValueOrDefault("keyname") ?? fallbackValue) 

Answer 5

你为什么不测试一下？

但我很确定TryGetValue更快，因为它只进行一次查找。 当然，这并不能保证，即不同的实现可能具有不同的性能特征。

我实现字典的方法是创建一个内部Find函数来查找项目的插槽，然后在此基础上构建其余部分。

Answer 6

到目前为止，所有答案虽然很好，但都错过了一个关键点。

进入 API 类（例如 .NET 框架）的方法构成接口定义的一部分（不是 C# 或 VB 接口，而是计算机科学意义上的接口）。

因此，询问调用这样的方法是否更快通常是不正确的，除非速度是正式接口定义的一部分（在这种情况下不是）。

传统上，无论语言、基础设施、操作系统、平台或机器架构如何，这种快捷方式（结合搜索和检索）都更有效。 它也更具可读性，因为它明确表达了您的意图，而不是暗示它（从您的代码结构中）。

所以答案（来自一个灰头土脸的老黑客）绝对是“是”（TryGetValue 比从字典中检索值的 ContainsKey 和 Item [Get] 的组合更可取）。

如果您觉得这听起来很奇怪，可以这样想：即使 TryGetValue、ContainsKey 和 Item [Get] 的当前实现不会产生任何速度差异，您也可以假设将来的实现（例如 .NET v5）很可能是会做（TryGetValue 会更快）。 想想你的软件的生命周期。

顺便说一句，有趣的是，典型的现代接口定义技术仍然很少提供任何正式定义时序约束的方法。 也许.NET v5？

Answer 7

在我的机器上，有大量 RAM，当在 RELEASE 模式（不是调试）下运行时，如果找到Dictionary<>中的所有条目， ContainsKey等于TryGetValue / try-catch 。

当只有几个字典条目未找到时， ContainsKey远远优于它们（在我下面的示例中，将MAXVAL为大于ENTRIES任何值以丢失一些条目）：

结果：

Finished evaluation .... Time distribution:
Size: 000010: TryGetValue: 53,24%, ContainsKey: 1,74%, try-catch: 45,01% - Total: 2.006,00
Size: 000020: TryGetValue: 37,66%, ContainsKey: 0,53%, try-catch: 61,81% - Total: 2.443,00
Size: 000040: TryGetValue: 22,02%, ContainsKey: 0,73%, try-catch: 77,25% - Total: 7.147,00
Size: 000080: TryGetValue: 31,46%, ContainsKey: 0,42%, try-catch: 68,12% - Total: 17.793,00
Size: 000160: TryGetValue: 33,66%, ContainsKey: 0,37%, try-catch: 65,97% - Total: 36.840,00
Size: 000320: TryGetValue: 34,53%, ContainsKey: 0,39%, try-catch: 65,09% - Total: 71.059,00
Size: 000640: TryGetValue: 32,91%, ContainsKey: 0,32%, try-catch: 66,77% - Total: 141.789,00
Size: 001280: TryGetValue: 39,02%, ContainsKey: 0,35%, try-catch: 60,64% - Total: 244.657,00
Size: 002560: TryGetValue: 35,48%, ContainsKey: 0,19%, try-catch: 64,33% - Total: 420.121,00
Size: 005120: TryGetValue: 43,41%, ContainsKey: 0,24%, try-catch: 56,34% - Total: 625.969,00
Size: 010240: TryGetValue: 29,64%, ContainsKey: 0,61%, try-catch: 69,75% - Total: 1.197.242,00
Size: 020480: TryGetValue: 35,14%, ContainsKey: 0,53%, try-catch: 64,33% - Total: 2.405.821,00
Size: 040960: TryGetValue: 37,28%, ContainsKey: 0,24%, try-catch: 62,48% - Total: 4.200.839,00
Size: 081920: TryGetValue: 29,68%, ContainsKey: 0,54%, try-catch: 69,77% - Total: 8.980.230,00

这是我的代码：

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;

    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
                const int ENTRIES = 10000, MAXVAL = 15000, TRIALS = 100000, MULTIPLIER = 2;
                Dictionary<int, int> values = new Dictionary<int, int>();
                Random r = new Random();
                int[] lookups = new int[TRIALS];
                int val;
                List<Tuple<long, long, long>> durations = new List<Tuple<long, long, long>>(8);

                for (int i = 0;i < ENTRIES;++i) try
                    {
                        values.Add(r.Next(MAXVAL), r.Next());
                    }
                    catch { --i; }

                for (int i = 0;i < TRIALS;++i) lookups[i] = r.Next(MAXVAL);

                Stopwatch sw = new Stopwatch();
                ConsoleColor bu = Console.ForegroundColor;

                for (int size = 10;size <= TRIALS;size *= MULTIPLIER)
                {
                    long a, b, c;

                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.WriteLine("Loop size: {0}", size);
                    Console.ForegroundColor = bu;

                    // ---------------------------------------------------------------------
                    sw.Start();
                    for (int i = 0;i < size;++i) values.TryGetValue(lookups[i], out val);
                    sw.Stop();
                    Console.WriteLine("TryGetValue: {0}", a = sw.ElapsedTicks);

                    // ---------------------------------------------------------------------
                    sw.Restart();
                    for (int i = 0;i < size;++i) val = values.ContainsKey(lookups[i]) ? values[lookups[i]] : default(int);
                    sw.Stop();
                    Console.WriteLine("ContainsKey: {0}", b = sw.ElapsedTicks);

                    // ---------------------------------------------------------------------
                    sw.Restart();
                    for (int i = 0;i < size;++i)
                        try { val = values[lookups[i]]; }
                        catch { }
                    sw.Stop();
                    Console.WriteLine("try-catch: {0}", c = sw.ElapsedTicks);

                    // ---------------------------------------------------------------------
                    Console.WriteLine();

                    durations.Add(new Tuple<long, long, long>(a, b, c));
                }

                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("Finished evaluation .... Time distribution:");
                Console.ForegroundColor = bu;

                val = 10;
                foreach (Tuple<long, long, long> d in durations)
                {
                    long sum = d.Item1 + d.Item2 + d.Item3;

                    Console.WriteLine("Size: {0:D6}:", val);
                    Console.WriteLine("TryGetValue: {0:P2}, ContainsKey: {1:P2}, try-catch: {2:P2} - Total: {3:N}", (decimal)d.Item1 / sum, (decimal)d.Item2 / sum, (decimal)d.Item3 / sum, sum);
                    val *= MULTIPLIER;
                }

                Console.WriteLine();
            }
        }
    }

Answer 8

除了设计一个可以在实际环境中给出准确结果的微基准测试之外，您还可以检查 .NET Framework 的参考源。

• System.Collections.Generic.Dictionary<TKey, TValue>.TryGetValue(TKey, out TValue)
• System.Collections.Generic.Dictionary<TKey, TValue>.ContainsKey(TKey)
• System.Collections.Generic.Dictionary<TKey, TValue>.Item(TKey)

它们都调用FindEntry(TKey)方法，该方法完成大部分工作并且不会记住其结果，因此调用TryGetValue速度几乎是ContainsKey + Item两倍。

---

TryGetValue不方便的接口可以使用扩展方法进行调整：

using System.Collections.Generic;

namespace Project.Common.Extensions
{
    public static class DictionaryExtensions
    {
        public static TValue GetValueOrDefault<TKey, TValue>(
            this IDictionary<TKey, TValue> dictionary,
            TKey key,
            TValue defaultValue = default(TValue))
        {
            if (dictionary.TryGetValue(key, out TValue value))
            {
                return value;
            }
            return defaultValue;
        }
    }
}

^{从 C# 7.1 开始，您可以将default(TValue)替换为普通的default 。 类型是推断出来的。}

用法：

var dict = new Dictionary<string, string>();
string val = dict.GetValueOrDefault("theKey", "value used if theKey is not found in dict");

它为查找失败的引用类型返回null ，除非指定了显式默认值。

var dictObj = new Dictionary<string, object>();
object valObj = dictObj.GetValueOrDefault("nonexistent");
Debug.Assert(valObj == null);

val dictInt = new Dictionary<string, int>();
int valInt = dictInt.GetValueOrDefault("nonexistent");
Debug.Assert(valInt == 0);

Answer 9

制作一个快速测试程序，使用 TryGetValue 和字典中的 100 万个项目肯定会有所改进。

结果：

containsKey + Item for 1000000 点击：45ms

1000000 次点击的 TryGetValue：26 毫秒

这是测试应用程序：

static void Main(string[] args)
{
    const int size = 1000000;

    var dict = new Dictionary<int, string>();

    for (int i = 0; i < size; i++)
    {
        dict.Add(i, i.ToString());
    }

    var sw = new Stopwatch();
    string result;

    sw.Start();

    for (int i = 0; i < size; i++)
    {
        if (dict.ContainsKey(i))
            result = dict[i];
    }

    sw.Stop();
    Console.WriteLine("ContainsKey + Item for {0} hits: {1}ms", size, sw.ElapsedMilliseconds);

    sw.Reset();
    sw.Start();

    for (int i = 0; i < size; i++)
    {
        dict.TryGetValue(i, out result);
    }

    sw.Stop();
    Console.WriteLine("TryGetValue for {0} hits: {1}ms", size, sw.ElapsedMilliseconds);

}

Answer 10

如果你想从字典中取出值，TryGetValue(key, out value) 是最好的选择，但如果你正在检查键的存在，新的插入，而不覆盖旧的键，只有在该范围内，ContainsKey(key) 才是最佳选择，基准测试可以确认这一点：

using System;
using System.Threading;
using System.Diagnostics;
using System.Collections.Generic;
using System.Collections;

namespace benchmark
{
class Program
{
    public static Random m_Rand = new Random();
    public static Dictionary<int, int> testdict = new Dictionary<int, int>();
    public static Hashtable testhash = new Hashtable();

    public static void Main(string[] args)
    {
        Console.WriteLine("Adding elements into hashtable...");
        Stopwatch watch = Stopwatch.StartNew();
        for(int i=0; i<1000000; i++)
            testhash[i]=m_Rand.Next();
        watch.Stop();
        Console.WriteLine("Done in {0:F4} -- pause....", watch.Elapsed.TotalSeconds);
        Thread.Sleep(4000);
        Console.WriteLine("Adding elements into dictionary...");
        watch = Stopwatch.StartNew();
        for(int i=0; i<1000000; i++)
            testdict[i]=m_Rand.Next();
        watch.Stop();
        Console.WriteLine("Done in {0:F4} -- pause....", watch.Elapsed.TotalSeconds);
        Thread.Sleep(4000);

        Console.WriteLine("Finding the first free number for insertion");
        Console.WriteLine("First method: ContainsKey");
        watch = Stopwatch.StartNew();
        int intero=0;
        while (testdict.ContainsKey(intero))
        {
            intero++;
        }
        testdict.Add(intero, m_Rand.Next());
        watch.Stop();
        Console.WriteLine("Done in {0:F4} -- added value {1} in dictionary -- pause....", watch.Elapsed.TotalSeconds, intero);
        Thread.Sleep(4000);
        Console.WriteLine("Second method: TryGetValue");
        watch = Stopwatch.StartNew();
        intero=0;
        int result=0;
        while(testdict.TryGetValue(intero, out result))
        {
            intero++;
        }
        testdict.Add(intero, m_Rand.Next());
        watch.Stop();
        Console.WriteLine("Done in {0:F4} -- added value {1} in dictionary -- pause....", watch.Elapsed.TotalSeconds, intero);
        Thread.Sleep(4000);
        Console.WriteLine("Test hashtable");
        watch = Stopwatch.StartNew();
        intero=0;
        while(testhash.Contains(intero))
        {
            intero++;
        }
        testhash.Add(intero, m_Rand.Next());
        watch.Stop();
        Console.WriteLine("Done in {0:F4} -- added value {1} into hashtable -- pause....", watch.Elapsed.TotalSeconds, intero);
        Console.Write("Press any key to continue . . . ");
        Console.ReadKey(true);
    }
}
}

这是一个真实的例子，我有一个服务，对于每个创建的“Item”，它关联一个累进编号，这个编号，每次创建新项目时，必须找到空闲，如果删除一个项目，空闲编号变为免费，当然这不是优化的，因为我有一个缓存当前数字的静态变量，但如果你结束所有数字，你可以重新开始从 0 到 UInt32.MaxValue

测试执行：
将元素添加到哈希表中...
在 0,5908 完成——暂停....
将元素添加到字典中...
在 0,2679 完成 - 暂停....
寻找第一个插入的空闲号码
第一种方法：ContainsKey
在 0,0561 中完成 - 在字典中添加值 1000000 - 暂停....
第二种方法：TryGetValue
在 0,0643 中完成 - 在字典中添加值 1000001 - 暂停....
测试哈希表
在 0,3015 中完成——将值 1000000 添加到哈希表中——暂停....
按任意键继续 。 .

如果你们中的一些人可能会问 containsKeys 是否有优势，我什至尝试用 contains 键反转 TryGetValue，结果是一样的。

所以，对我来说，最后考虑，这完全取决于程序的行为方式。