C#泛型枚举类型与int互相转换的实现及CS0030报错解决

你给类加的where T : Enum泛型约束，只是用来限制T必须是枚举类型，本身不携带任何关于枚举底层存储类型的信息：

• 枚举的合法底层存储类型远不止int一种，sbyte、byte、short、ushort、uint、long、ulong、char都可以作为枚举的底层
• C#的强制转换语法要求，编译器必须在编译阶段验证两个类型之间存在合法的转换规则，才能放行(int)arg这类写法
• 对于泛型参数T，编译器根本不知道你后续会传入什么具体的枚举：万一传了一个底层是byte的枚举，转int是安全的，但如果要把一个很大的int值转回这个byte类型的枚举，就会溢出。这种不确定的场景下，编译器直接抛出CS0030错误是符合静态类型校验逻辑的。

而之前测试的固定枚举场景，比如DayOfWeek，编译器在编译阶段就能直接读到这个枚举的元数据，明确知道它的底层是int，所以强制转换的逻辑是完全合法的。

根据不同的性能要求，可以选择不同的实现方式：

基础兼容方案（适配所有.NET版本） #

直接借助CLR内置的类型转换API完成转换，不需要任何额外依赖，是老版本.NET环境下最常用的写法：

void DoSomething(T arg)
{
    // 枚举转int：Convert会自动识别枚举的底层值完成转换
    int intValue = Convert.ToInt32(arg);
    // int转回枚举：Enum.ToObject会根据传入的目标枚举类型生成对应的值
    T enumValue = (T)Enum.ToObject(typeof(T), intValue);
}

该方案的特点是兼容性拉满，从.NET Framework 1.0到最新的.NET版本都能正常运行，但转换过程中存在枚举值装箱、拆箱的固定开销，对每秒调用几千次以上的性能敏感场景会有可观测的损耗。

避坑提醒：不要图省事儿写(int)(object)arg这类依赖装箱中转的写法。这个写法确实能通过编译，但不仅有和Convert方案一致的开销，也不会校验枚举的底层类型，万一碰到底层不是int的枚举，运行时会直接抛InvalidCastException，稳定性比Convert方案差很多。

高性能方案（零装箱开销） #

如果对转换性能有要求，可以通过缓存强类型转换委托、或者非安全内存重解释的方式，把转换开销降到和固定枚举直接强制转换完全一致的水平：

• 委托缓存方案（不需要开启不安全代码权限）
  第一次遇到某个具体的枚举类型作为泛型参数T时，通过表达式树编译生成对应的强类型转换逻辑，缓存到静态字段里反复调用，全程没有装箱操作：

  // 静态缓存强类型转换委托，类初始化的时候只生成一次
  private static readonly Func<T, int> _enumToInt = BuildEnumToIntConverter();
  private static readonly Func<int, T> _intToEnum = BuildIntToEnumConverter();
  
  private static Func<T, int> BuildEnumToIntConverter()
  {
      var parameter = Expression.Parameter(typeof(T), "arg");
      var convertExpression = Expression.Convert(parameter, typeof(int));
      return Expression.Lambda<Func<T, int>>(convertExpression, parameter).Compile();
  }
  
  private static Func<int, T> BuildIntToEnumConverter()
  {
      var parameter = Expression.Parameter(typeof(int), "value");
      var convertExpression = Expression.Convert(parameter, typeof(T));
      return Expression.Lambda<Func<int, T>>(convertExpression, parameter).Compile();
  }
  
  void DoSomething(T arg)
  {
      int a = _enumToInt(arg);
      T origin = _intToEnum(a);
  }
  

• 内存重解释方案（极致性能）
  引入System.Runtime.CompilerServices.UnsafeNuGet包后，可以直接对值类型的内存做重解释，没有委托调用的额外开销，是性能最高的实现：

  void DoSomething(T arg)
  {
      // 枚举转int
      int a = Unsafe.As<T, int>(arg);
      // int转回枚举
      T origin = Unsafe.As<int, T>(a);
  }
  

  注意：这个写法只适合你确定所有传入枚举的底层类型都是int的场景。如果传入的枚举底层是long、ulong这类占内存更大的类型，直接做内存重解释会读到错误的值，甚至引发内存访问异常。

内容的提问来源于stack exchange，提问作者CesarGon