泛型枚举到整型的 C # 非装箱转换？

我想你可以一直使用系统。反射。发出以创建动态方法，并发出不装箱的指令，尽管这可能是无法验证的。

如果不使用反射，我不确定这在 C # 中是否可行。发射。如果你使用反射。发出，您可以将枚举的值加载到堆栈上，然后将其视为整型。

但是，您必须编写相当多的代码，因此需要检查在执行此操作时是否真正获得了任何性能。

我相信相应的 IL 将是:

.method public hidebysig instance int32  Foo<valuetype
.ctor ([mscorlib]System.ValueType) TEnum>(!!TEnum 'value') cil managed
{
.maxstack  8
IL_0000:  ldarg.1
IL_000b:  ret
}

请注意，如果您的枚举是从 long(一个64位整数)派生的，则此操作将失败

剪辑

关于这个方法的另一个想法。反射。Emit 可以创建上面的方法，但是绑定到它的唯一方法是通过一个虚拟调用(即它实现了一个可以调用的编译时已知的接口/抽象)或者一个间接调用(即通过一个委托调用)。我想这两种情况都比装箱/拆箱的开销要慢。

另外，不要忘记 JIT 并不笨，它可以为你解决这个问题。(剪辑 看看埃里克 · 利伯特对最初问题的评论——他说，抖动目前并没有执行这种优化。)

与所有与性能相关的问题一样: 度量、度量、度量！

我知道我来晚了，但是如果你只是需要这样一个安全的铸造，你可以使用以下 Delegate.CreateDelegate:

public static int Identity(int x){return x;}
// later on..
Func<int,int> identity = Identity;
Delegate.CreateDelegate(typeof(Func<int,TEnum>),identity.Method) as Func<int,TEnum>

现在不需要编写 Reflection.Emit或表达式树，您就有了一个方法，可以在不装箱或解箱的情况下将 int 转换为枚举。请注意，这里的 TEnum必须有一个基础类型 int，否则将抛出一个异常，说明它不能被绑定。

编辑: 另一种方法也可以，而且可能写得少一点..。

Func<TEnum,int> converter = EqualityComparer<TEnum>.Default.GetHashCode;

这样可以将32位 或者更少枚举从 TEnum 转换为 int。而不是反过来。进去。净3.5 + ，EnumEqualityComparer的优化，基本上把这个返回 (int)value;

您正在支付使用委托的开销，但它肯定比装箱好。

这是相当古老的，但如果你仍然回到这里寻找一个解决方案，工程。净额5/。Net 核心(或带有不安全软件包的 netfx) ，并保持最优..。

[JitGeneric(typeof(StringComparison), typeof(int))]
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static bool TryConvert<TEnum, T>(this TEnum @enum, out T val)
where TEnum : struct, Enum
where T : struct, IConvertible, IFormattable, IComparable
{
if (Unsafe.SizeOf<T>() == Unsafe.SizeOf<TEnum>())
{
val = Unsafe.As<TEnum, T>(ref @enum);
return true;
}
val = default;
return false;
}

一个例子的用法可能是这样的:

public static int M(MethodImplOptions flags) => flags.TryConvert(out int v) ? v : 0;

在 sharplab 上我们可以看到，这个方法被完全内联了: Https://sharplab.io/#gist:802b8d21ee1de26e791294ba48f69d97

... 我甚至“晚了”:)

但是只是延伸到上一篇文章(迈克尔 B) ，它做了所有有趣的工作

并使我对为通用情况制作包装器感兴趣(如果您想实际将通用转换为枚举)

优化了一点。 (注意: 主要是在 Func < >/committee 上使用‘ as’-作为 Enum，值类型不允许这样做)

public static class Identity<TEnum, T>
{
public static readonly Func<T, TEnum> Cast = (Func<TEnum, TEnum>)((x) => x) as Func<T, TEnum>;
}

你可以像这样使用它。

enum FamilyRelation { None, Father, Mother, Brother, Sister, };
class FamilyMember
{
public FamilyRelation Relation { get; set; }
public FamilyMember(FamilyRelation relation)
{
this.Relation = relation;
}
}
class Program
{
static void Main(string[] args)
{
FamilyMember member = Create<FamilyMember, FamilyRelation>(FamilyRelation.Sister);
}
static T Create<T, P>(P value)
{
if (typeof(T).Equals(typeof(FamilyMember)) && typeof(P).Equals(typeof(FamilyRelation)))
{
FamilyRelation rel = Identity<FamilyRelation, P>.Cast(value);
return (T)(object)new FamilyMember(rel);
}
throw new NotImplementedException();
}
}

... for (int)-just (int) rel

这与此处发布的答案类似，但是使用表达式树发出 il 以在类型之间进行强制转换。Expression.Convert就行了。已编译的委托(caster)由内部静态类缓存。因为源对象可以从参数中推断出来，所以我猜它提供了更干净的调用。例如，通用上下文:

static int Generic<T>(T t)
{
int variable = -1;


// may be a type check - if(...
variable = CastTo<int>.From(t);


return variable;
}

课程:

/// <summary>
/// Class to cast to type <see cref="T"/>
/// </summary>
/// <typeparam name="T">Target type</typeparam>
public static class CastTo<T>
{
/// <summary>
/// Casts <see cref="S"/> to <see cref="T"/>.
/// This does not cause boxing for value types.
/// Useful in generic methods.
/// </summary>
/// <typeparam name="S">Source type to cast from. Usually a generic type.</typeparam>
public static T From<S>(S s)
{
return Cache<S>.caster(s);
}


private static class Cache<S>
{
public static readonly Func<S, T> caster = Get();


private static Func<S, T> Get()
{
var p = Expression.Parameter(typeof(S));
var c = Expression.ConvertChecked(p, typeof(T));
return Expression.Lambda<Func<S, T>>(c, p).Compile();
}
}
}

你可以用其他的实现来替换 caster的 func。我将比较一些实现的性能:

direct object casting, ie, (T)(object)S


caster1 = (Func<T, T>)(x => x) as Func<S, T>;


caster2 = Delegate.CreateDelegate(typeof(Func<S, T>), ((Func<T, T>)(x => x)).Method) as Func<S, T>;


caster3 = my implementation above


caster4 = EmitConverter();
static Func<S, T> EmitConverter()
{
var method = new DynamicMethod(string.Empty, typeof(T), new[] { typeof(S) });
var il = method.GetILGenerator();


il.Emit(OpCodes.Ldarg_0);
if (typeof(S) != typeof(T))
{
il.Emit(OpCodes.Conv_R8);
}
il.Emit(OpCodes.Ret);


return (Func<S, T>)method.CreateDelegate(typeof(Func<S, T>));
}

盒装石膏 :

static void TestMethod<T>(T t)
{
CastTo<int>.From(t); //computes delegate once and stored in a static variable


int value = 0;
var watch = Stopwatch.StartNew();
for (int i = 0; i < 10000000; i++)
{
value = (int)(object)t;


// similarly value = CastTo<int>.From(t);


// etc
}
watch.Stop();
Console.WriteLine(watch.Elapsed.TotalMilliseconds);
}