C#Dictionary中使用枚举的效率问题

使用字典的好处

 
  System.Collections.Generic命名空间下的Dictionary，它的功能非常好用，且功能与现实中的字典是一样的。
  它同样拥有目录和正文，目录用来进行第一次的粗略查找，正文进行第二次精确查找。通过将数据进行分组，形成目录，正文则是分组后的结果。它是一种空间换时间的方式，牺牲大的内存换取高效的查询效率。所以，功能使用率查询>新增时优先考虑字典。

        public static Tvalue DicTool<Tkey, Tvalue>(Tkey key, Dictionary<Tkey, Tvalue> dic)
        {
            return dic.TryGetValue(key, out Tvalue _value) ? _value : (Tvalue)default;
        }

            Stopwatch stopwatch = Stopwatch.StartNew();
            for (int i = 0; i < 1; i++)
            {
                DicTool(0, Dic);
            }
            stopwatch.Stop();
            Console.WriteLine(stopwatch.Elapsed);

执行时间 00:00:00.0003135

            Stopwatch stopwatch = Stopwatch.StartNew();
            for (int i = 0; i < 10000; i++)
            {
                DicTool(0, Dic);
            }
            stopwatch.Stop();
            Console.WriteLine(stopwatch.Elapsed);

执行时间 00:00:00.0005091
从上面可以看出，它进行大量查询时的用时非常短，查询效率极高。但使用时需要避免使用枚举作为关键词进行查询；它会造成查询效率降低。
 

使用枚举作为key时查询效率变低

 

 Stopwatch stopwatch = Stopwatch.StartNew();
            for (int i = 0; i < 10000; i++)
            {
                DicTool(MyEnum.one, Dic);
            }
            stopwatch.Stop();
            Console.WriteLine(stopwatch.Elapsed);

执行时间 00:00:00.0011010
从这里的执行时间可以看出，查询效率大大降低。
 
优化方案： 使用int代替enum，enum强制转型后间接查询；可使查询效率与非枚举的直接查询相近。（还有其他的优化方案，个人只使用过这个）

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

namespace Test
{
    public class Program
    {
        public enum MyEnum : int
        {
            one,
            two,
            three
        }
        public static void Main(string[] args)
        {
            Dictionary<int, int> Dic = new Dictionary<int, int>()
            {
                { (int)MyEnum.one,1},
                { (int)MyEnum.two,2},
                { (int)MyEnum.three,3}
            };
            Stopwatch stopwatch = Stopwatch.StartNew();
            for (int i = 0; i < 10000; i++)
            {
                DicTool((int)MyEnum.one, Dic);
            }
            stopwatch.Stop();
            Console.WriteLine(stopwatch.Elapsed);
        }
        public static Tvalue DicTool<Tkey, Tvalue>(Tkey key, Dictionary<Tkey, Tvalue> dic)
        {
            return dic.TryGetValue(key, out Tvalue _value) ? _value : (Tvalue)default;
        }
    }
}

执行时间 00:00:00.0005005

为什么使用枚举会降低效率

 
使用ILSpy软件反编译源码，得到以下：

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

private int FindEntry(TKey key)
{
    if (key == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.key);
    }
    if (this.buckets != null)
    {
        int num = this.comparer.GetHashCode(key) & 2147483647;
        for (int i = this.buckets[num % this.buckets.Length]; i >= 0; i = this.entries[i].next)
        {
            if (this.entries[i].hashCode == num && this.comparer.Equals(this.entries[i].key, key))
            {
                return i;
            }
        }
    }
    return -1;
}

查看Dictionary源码后可以知道，效率减低来源于this.comparer.GetHashCode(key) 这段代码。
comparer是使用了泛型的成员，它内部使用int类型不会发生装箱，但是由于Enum没有IEquatable接口，内部运行时会引起装箱行为，该行为降低了查询的效率。
  IEquatable源码：

namespace System
{
	[__DynamicallyInvokable]
	public interface IEquatable<T>
	{
		[__DynamicallyInvokable]
		bool Equals(T other);
	}
}

装箱：值类型转换为引用类型（隐式转换）
把数据从栈复制到托管堆中，栈中改为存储数据地址。
拆箱：引用类型转换为值类型（显式转换）