为什么要枚举.ToString box/callvirt，而不是推送地址和调用?还有其他特殊情况吗

我有几个月前写的这个框架，它生成了一个调用这个性能服务的类。框架的使用者使用方法创建一个接口，使用属性进行注释，并调用一个工厂方法，该方法创建他们可以用来调用此性能服务的接口的实现。该服务只支持两个数据字符串和long。我使用具有可收集程序集的反射发射来生成实现接口的类。

一切都很好，但今天有人告诉我，当他们试图传入一个将转换为字符串的枚举时，他们得到了一个AV。在代码中，检查类型是否为值类型，如果是，则推送地址(ldarga或ldflda，具体取决于使用者创建的接口(，然后调用ToString。所以我创建了一个小的调试应用程序，我看到C#编译器会装箱一个枚举，然后在装箱的枚举上调用ToString。

所以我有点困惑。我处理值类型的方式不正确吗？C#编译器为枚举上的toString生成的IL是正确的方法吗？还有其他类似的特殊情况吗

更新答案：所以看起来我需要看看值类型是否实现了tostring，以及它是否没有装箱。对于值类型，我想这适用于对象方法，tostring，gethashcode，equals。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection.Emit;
using System.Reflection;
namespace ConsoleApplication15
{
    public struct H
    {
    }
    class Program
    {
        static void Main(string[] args)
        {
            //Test<AttributeTargets>(AttributeTargets.ReturnValue); //-- fails
            //Test<int>(10); //-- works
           // TestBox<AttributeTargets>(AttributeTargets.ReturnValue); //-- works
            //Test<H>(new H()); // fails
            TestCorrect<H>(new H()); // works 
            TestCorrect<int>(10); // works 
            Console.ReadLine();
        }
        private static void TestCorrect<T>(T t)
    where T : struct
        {
            MethodInfo method = typeof(T).GetMethod(
                "ToString",
                BindingFlags.Public | BindingFlags.Instance,
                null,
                Type.EmptyTypes,
                null);
            var m = new DynamicMethod("x", typeof(string), new[] { typeof(T) });
            var i = m.GetILGenerator();
            if (method.DeclaringType == typeof(T))
            {
                i.Emit(OpCodes.Ldarga, 0);
                i.Emit(OpCodes.Call, method);
            }
            else
            {
                i.Emit(OpCodes.Ldarg_0);
                i.Emit(OpCodes.Box, typeof(T));
                i.Emit(OpCodes.Callvirt, method);
            }
            i.Emit(OpCodes.Ret);
            string result = (m.CreateDelegate(typeof(Func<T, string>)) as Func<T, string>)(t);
            Console.WriteLine(result);
        }
        private static void Test<T>(T t)
            where T : struct
        {
            MethodInfo method = typeof(T).GetMethod(
                "ToString",
                BindingFlags.Public | BindingFlags.Instance,
                null,
                Type.EmptyTypes,
                null);
            var m = new DynamicMethod("x", typeof(string), new[] { typeof(T) });
            var i = m.GetILGenerator();
            i.Emit(OpCodes.Ldarga, 0);
            i.Emit(OpCodes.Call, method);
            i.Emit(OpCodes.Ret);
            string result = (m.CreateDelegate(typeof(Func<T, string>)) as Func<T, string>)(t);
            Console.WriteLine(result);
        }
        private static void TestBox<T>(T t)
            where T : struct
        {
            // this is how the C# compiler call to string on enum.
            MethodInfo method = typeof(T).GetMethod(
                "ToString",
                BindingFlags.Public | BindingFlags.Instance,
                null,
                Type.EmptyTypes,
                null);
            var m = new DynamicMethod("x", typeof(string), new[] { typeof(T) });
            var i = m.GetILGenerator();
            i.Emit(OpCodes.Ldarg_0);
            i.Emit(OpCodes.Box, typeof(T));
            i.Emit(OpCodes.Callvirt, method);
            i.Emit(OpCodes.Ret);
            string result = (m.CreateDelegate(typeof(Func<T, string>)) as Func<T, string>)(t);
            Console.WriteLine(result);
        }
    }
}