13

我正在阅读“C# via CLR”，在第 380 页，有一条说明如下：

注意 Enum 类定义了一个 HasFlag 方法，定义如下

public Boolean HasFlag(Enum flag);

使用此方法，您可以像这样重写对 Console.WriteLine 的调用：

Console.WriteLine("Is {0} hidden? {1}", file, attributes.HasFlag(FileAttributes.Hidden));

但是，出于这个原因，我建议您避免使用 HasFlag 方法：

由于它采用 Enum 类型的参数，因此您传递给它的任何值都必须装箱，需要分配内存。”

我无法理解这个加粗的陈述——为什么“

您传递给它的任何值都必须装箱

flag参数类型是，Enum是值类型，为什么会有装箱呢？“您传递给它的任何值都必须装箱”应该意味着当您将值类型传递给参数时会发生装箱Enum flag，对吗？

4

8 回答 8

9

值得注意的是，一个HasFlag<T>(T thing, T flags)比扩展方法快大约 30 倍的泛型Enum.HasFlag可以用大约 30 行代码编写。甚至可以做成扩展方法。不幸的是，在 C# 中不可能将这种方法限制为仅采用枚举类型的东西。因此，即使对于不适用的类型，Intellisense 也会弹出该方法。我认为如果有人使用 C# 或 vb.net 以外的其他语言编写扩展方法，则可能仅在应该弹出时才弹出它，但我对其他语言还不够熟悉，无法尝试这样的事情。

internal static class EnumHelper<T1>
{
    public static Func<T1, T1, bool> TestOverlapProc = initProc;
    public static bool Overlaps(SByte p1, SByte p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(Byte p1, Byte p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(Int16 p1, Int16 p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(UInt16 p1, UInt16 p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(Int32 p1, Int32 p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(UInt32 p1, UInt32 p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(Int64 p1, Int64 p2) { return (p1 & p2) != 0; }
    public static bool Overlaps(UInt64 p1, UInt64 p2) { return (p1 & p2) != 0; }
    public static bool initProc(T1 p1, T1 p2)
    {
        Type typ1 = typeof(T1);
        if (typ1.IsEnum) typ1 = Enum.GetUnderlyingType(typ1);
        Type[] types = { typ1, typ1 };
        var method = typeof(EnumHelper<T1>).GetMethod("Overlaps", types);
        if (method == null) method = typeof(T1).GetMethod("Overlaps", types);
        if (method == null) throw new MissingMethodException("Unknown type of enum");
        TestOverlapProc = (Func<T1, T1, bool>)Delegate.CreateDelegate(typeof(Func<T1, T1, bool>), method);
        return TestOverlapProc(p1, p2);
    }
}
static class EnumHelper
{
    public static bool Overlaps<T>(this T p1, T p2) where T : struct
    {
        return EnumHelper<T>.TestOverlapProc(p1, p2);
    }
}

编辑：以前的版本被破坏了，因为它使用（或至少尝试使用）。EnumHelper<T1, T1>

于 2012-12-18T17:26:57.773 回答
7

在这种情况下，在您进入该HasFlags方法之前，需要两次装箱调用。一种是将值类型的方法调用解析为基类型方法，另一种是将值类型作为引用类型参数传递。如果你这样做var type = 1.GetType();，你可以在 IL 中看到相同的内容，文字1 在调用int之前被装箱。GetType()方法调用的装箱似乎只有在值类型定义本身中没有覆盖方法时，可以在此处阅读更多内容：在值类型上调用方法会导致 .NET 中的装箱吗？

HasFlags接受一个Enum 类参数，所以这里会发生装箱。您正在尝试将什么是值类型传递给期望引用类型的东西。为了将值表示为引用，会发生装箱。

有很多编译器支持值类型及其继承（使用Enum/ ValueType），这在试图解释它时会混淆情况。人们似乎认为，因为Enum和ValueType在值类型的继承链中，拳击突然不适用了。如果这是真的，那么可以说object一切都继承了这一点——但我们知道这是错误的。

这并不能阻止将值类型表示为引用类型会导致装箱的事实。

我们可以在 IL 中证明这一点（查找box代码）：

class Program
{
    static void Main(string[] args)
    {
        var f = Fruit.Apple;
        var result = f.HasFlag(Fruit.Apple);

        Console.ReadLine();
    }
}

[Flags]
enum Fruit
{
    Apple
}



.method private hidebysig static 
    void Main (
        string[] args
    ) cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 28 (0x1c)
    .maxstack 2
    .entrypoint
    .locals init (
        [0] valuetype ConsoleApplication1.Fruit f,
        [1] bool result
    )

    IL_0000: nop
    IL_0001: ldc.i4.0
    IL_0002: stloc.0
    IL_0003: ldloc.0
    IL_0004: box ConsoleApplication1.Fruit
    IL_0009: ldc.i4.0
    IL_000a: box ConsoleApplication1.Fruit
    IL_000f: call instance bool [mscorlib]System.Enum::HasFlag(class [mscorlib]System.Enum)
    IL_0014: stloc.1
    IL_0015: call string [mscorlib]System.Console::ReadLine()
    IL_001a: pop
    IL_001b: ret
} // end of method Program::Main

在将值类型表示为时可以看到相同的情况ValueType，它也会导致装箱：

class Program
{
    static void Main(string[] args)
    {
        int i = 1;
        ValueType v = i;

        Console.ReadLine();
    }
}


.method private hidebysig static 
    void Main (
        string[] args
    ) cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 17 (0x11)
    .maxstack 1
    .entrypoint
    .locals init (
        [0] int32 i,
        [1] class [mscorlib]System.ValueType v
    )

    IL_0000: nop
    IL_0001: ldc.i4.1
    IL_0002: stloc.0
    IL_0003: ldloc.0
    IL_0004: box [mscorlib]System.Int32
    IL_0009: stloc.1
    IL_000a: call string [mscorlib]System.Console::ReadLine()
    IL_000f: pop
    IL_0010: ret
} // end of method Program::Main
于 2012-07-26T08:38:54.783 回答
3

Enum继承自ValueType...一个类！因此拳击。

请注意，Enum该类可以将任何枚举表示为装箱值，无论其基础类型是什么。而诸如此类的值FileAttributes.Hidden将表示为实值类型，int。

编辑：让我们在这里区分类型和表示。Anint在内存中表示为 32 位。它的类型源自ValueType. 一旦您将一个分配int给一个object或派生类（ValueType类，Enum类），您就将它装箱，有效地将其表示更改为现在包含该 32 位以及其他类信息的类。

于 2012-07-26T08:31:21.427 回答
3

自 C# 7.3 以来，引入了通用 Enum 约束，您可以编写一个不依赖反射的快速、非分配版本。它需要编译器标志 /unsafe 但由于 Enum 支持类型只能是固定数量的大小，因此它应该是完全安全的：

using System;
using System.Runtime.CompilerServices;
public static class EnumFlagExtensions
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool HasFlagUnsafe<TEnum>(TEnum lhs, TEnum rhs) where TEnum : unmanaged, Enum
    {
        unsafe
        {
            switch (sizeof(TEnum))
            {
                case 1:
                    return (*(byte*)(&lhs) & *(byte*)(&rhs)) > 0;
                case 2:
                    return (*(ushort*)(&lhs) & *(ushort*)(&rhs)) > 0;
                case 4:
                    return (*(uint*)(&lhs) & *(uint*)(&rhs)) > 0;
                case 8:
                    return (*(ulong*)(&lhs) & *(ulong*)(&rhs)) > 0;
                default:
                    throw new Exception("Size does not match a known Enum backing type.");
            }
        }
    }
}
于 2021-06-28T08:28:11.987 回答
0

当你传递一个以对象为参数的方法的值类型时，就像在 console.writeline 的情况下，会有一个固有的装箱操作。Jeffery Richter 在您提到的同一本书中详细讨论了这一点。

在这种情况下，您使用的是 console.writeline 的 string.format 方法，它采用 object[] 的 params 数组。所以你的布尔值将被转换为对象，因此你得到一个装箱操作。您可以通过在布尔值上调用 .ToString() 来避免这种情况。

于 2012-07-26T08:34:00.247 回答
0

此外，还有不止一个拳击Enum.HasFlag：

public bool HasFlag(Enum flag)
{
    if (!base.GetType().IsEquivalentTo(flag.GetType()))
    {
        throw new ArgumentException(Environment.GetResourceString("Argument_EnumTypeDoesNotMatch", new object[]
        {
            flag.GetType(),
            base.GetType()
        }));
    }
    ulong num = Enum.ToUInt64(flag.GetValue());
    ulong num2 = Enum.ToUInt64(this.GetValue());
    return (num2 & num) == num;
}

查看GetValue方法调用。

更新。看起来 MS 在 .NET 4.5 中优化了这种方法（源代码已从参考源下载）：

    [System.Security.SecuritySafeCritical]
    public Boolean HasFlag(Enum flag) { 
        if (flag == null)
            throw new ArgumentNullException("flag"); 
        Contract.EndContractBlock(); 

        if (!this.GetType().IsEquivalentTo(flag.GetType())) { 
            throw new ArgumentException(Environment.GetResourceString("Argument_EnumTypeDoesNotMatch", flag.GetType(), this.GetType()));
        }

        return InternalHasFlag(flag); 
    }

    [System.Security.SecurityCritical]  // auto-generated 
    [ResourceExposure(ResourceScope.None)]
    [MethodImplAttribute(MethodImplOptions.InternalCall)] 
    private extern bool InternalHasFlag(Enum flags);
于 2012-07-26T08:46:20.273 回答
0

此调用涉及两个拳击操作，而不仅仅是一个。两者都是必需的，原因很简单：对于 和 都Enum.HasFlag()需要类型信息this，而不仅仅是值flag。

大多数时候，一个enum值实际上只是一组位，编译器从enum方法签名中表示的类型中获得了它所需的所有类型信息。

但是，Enum.HasFlags()它首先要做的是调用this.GetType()并flag.GetType()确保它们是相同的。如果你想要无类型版本，你会问if ((attribute & flag) != 0)，而不是调用Enum.HasFlags().

于 2012-07-26T09:14:03.560 回答
0

正如 Timo 所建议的，Martin Tilo Schmitz 的解决方案可以在不需要/unsafeswitch的情况下实现：

public static bool HasAnyFlag<E>(this E lhs, E rhs) where E : unmanaged, Enum
{
    switch (Unsafe.SizeOf<E>())
    {
    case 1:
        return (Unsafe.As<E, byte>(ref lhs) & Unsafe.As<E, byte>(ref rhs)) != 0;
    case 2:
        return (Unsafe.As<E, ushort>(ref lhs) & Unsafe.As<E, ushort>(ref rhs)) != 0;
    case 4:
        return (Unsafe.As<E, uint>(ref lhs) & Unsafe.As<E, uint>(ref rhs)) != 0;
    case 8:
        return (Unsafe.As<E, ulong>(ref lhs) & Unsafe.As<E, ulong>(ref rhs)) != 0;
    default:
        throw new Exception("Size does not match a known Enum backing type.");
    }
}

需要NuGetSystem.Runtime.CompilerServices.Unsafe才能使用 .NET Framework 进行编译。

表现

  • 我不得不提到，任何通用实现仍然比本机检查慢一个数量级，即((int)lhs & (int)rhs) != 0. 我想参考lhs,会rhs阻止优化函数变量的存储。枚举大小的运行时调度增加了另一个开销。
  • 但它仍然比 快一个数量级HasFlag。
  • HasFlag而且，如果在调试版本中关闭优化，性能优势几乎为零。
  • 在优化（发布）版本中使用unsafe { }和使用之间没有显着差异。class Unsafe只有没有优化class Unsafe几乎和HasFlag.
  • 使用作为 supercat 推荐的委托不是合理的选择，因为在大多数 CPU 架构上生成的函数指针调用很慢，而且它完全阻止了内联。
  • MethodImplOptions.AggressiveInlining没有增加任何价值。

结论

仍然没有真正快速且可读的实现来测试枚举中的标志。

于 2022-02-08T17:29:04.030 回答