到目前为止，所有的答案虽然不错，但都忽略了一个关键问题。

API类中的方法(例如。net框架)构成了接口定义的一部分(不是c#或VB接口，而是计算机科学意义上的接口)。

因此，询问调用这样的方法是否更快通常是不正确的，除非速度是正式接口定义的一部分(在本例中并非如此)。

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

所以答案(来自一个灰色的老黑客)肯定是“是的”(TryGetValue比ContainsKey和Item [Get]的组合更可取，以从字典中检索值)。

如果您认为这听起来很奇怪，可以这样想:即使TryGetValue、ContainsKey和Item [Get]的当前实现没有产生任何速度差异，您可以假设未来的实现(例如。net v5)可能会做到(TryGetValue会更快)。考虑软件的生命周期。

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

如果你试图从字典中获取值，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”，它关联一个累进的数字，这个数字，每次你创建一个新项目，必须找到空闲的，如果你删除一个Item，空闲的数字变成空闲的，当然这不是优化的，因为我有一个静态的变量，缓存当前的数字，但如果你结束所有的数字，你可以从0到UInt32重新开始。MaxValue

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

如果你们中的一些人可能会问ContainsKeys是否有优势，我甚至尝试过用Contains key反转TryGetValue，结果是一样的。

所以，对我来说，最后考虑一下，这一切都取决于程序的行为方式。

你为什么不测试一下呢?

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

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

制作一个快速测试程序，使用字典中包含100万个项的TryGetValue显然有很大的改进。

结果:

ContainsKey + Item为1000000次:45ms

1000000次的TryGetValue: 26ms

下面是测试应用程序:

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

}

谁在乎呢? -)

您可能会问这个问题，因为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")

or

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

TryGetValue会更快。

ContainsKey使用与TryGetValue相同的检查，后者在内部引用实际的条目位置。Item属性实际上具有与TryGetValue几乎相同的代码功能，除了它将抛出异常而不是返回false。

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