有人知道缺少枚举通用约束的好解决方法吗？

Question

我想做的是这样的：我有带有组合标记值的枚举。

public static class EnumExtension
{
    public static bool IsSet<T>( this T input, T matchTo ) 
        where T:enum //the constraint I want that doesn't exist in C#3
    {    
        return (input & matchTo) != 0;
    }
}

那么我可以这样做：

MyEnum tester = MyEnum.FlagA | MyEnum.FlagB

if( tester.IsSet( MyEnum.FlagA ) )
    //act on flag a

不幸的是，C# 的泛型约束没有枚举限制，只有类和结构。 C# 不将枚举视为结构（即使它们是值类型），因此我无法添加这样的扩展类型。

有人知道解决方法吗？

Answer 1

我只是想添加 Enum 作为通用约束。

虽然这只是一个使用 ExtraConstraints 的小辅助方法对我来说有点太多的开销。

我决定只创建一个 struct 约束并为 IsEnum 添加运行时检查。 为了将变量从 T 转换为 Enum，我首先将其转换为对象。

    public static Converter<T, string> CreateConverter<T>() where T : struct
    {
        if (!typeof(T).IsEnum) throw new ArgumentException("Given Type is not an Enum");
        return new Converter<T, string>(x => ((Enum)(object)x).GetEnumDescription());
    }

Answer 2

这是我刚刚编写的一些代码，它们似乎可以按照您想要的方式工作，而无需做任何太疯狂的事情。 它不仅限于设置为标志的枚举，但如果需要，总是可以进行检查。

public static class EnumExtensions
{
    public static bool ContainsFlag(this Enum source, Enum flag)
    {
        var sourceValue = ToUInt64(source);
        var flagValue = ToUInt64(flag);

        return (sourceValue & flagValue) == flagValue;
    }

    public static bool ContainsAnyFlag(this Enum source, params Enum[] flags)
    {
        var sourceValue = ToUInt64(source);

        foreach (var flag in flags)
        {
            var flagValue = ToUInt64(flag);

            if ((sourceValue & flagValue) == flagValue)
            {
                return true;
            }
        }

        return false;
    }

    // found in the Enum class as an internal method
    private static ulong ToUInt64(object value)
    {
        switch (Convert.GetTypeCode(value))
        {
            case TypeCode.SByte:
            case TypeCode.Int16:
            case TypeCode.Int32:
            case TypeCode.Int64:
                return (ulong)Convert.ToInt64(value, CultureInfo.InvariantCulture);

            case TypeCode.Byte:
            case TypeCode.UInt16:
            case TypeCode.UInt32:
            case TypeCode.UInt64:
                return Convert.ToUInt64(value, CultureInfo.InvariantCulture);
        }

        throw new InvalidOperationException("Unknown enum type.");
    }
}

Answer 3

如果有人需要通用 IsSet（即时创建，可以改进），或者字符串到 Enum onfly 转换（使用下面介绍的 EnumConstraint）：

  public class TestClass
  { }

  public struct TestStruct
  { }

  public enum TestEnum
  {
    e1,    
    e2,
    e3
  }

  public static class TestEnumConstraintExtenssion
  {

    public static bool IsSet<TEnum>(this TEnum _this, TEnum flag)
      where TEnum : struct
    {
      return (((uint)Convert.ChangeType(_this, typeof(uint))) & ((uint)Convert.ChangeType(flag, typeof(uint)))) == ((uint)Convert.ChangeType(flag, typeof(uint)));
    }

    //public static TestClass ToTestClass(this string _this)
    //{
    //  // #generates compile error  (so no missuse)
    //  return EnumConstraint.TryParse<TestClass>(_this);
    //}

    //public static TestStruct ToTestStruct(this string _this)
    //{
    //  // #generates compile error  (so no missuse)
    //  return EnumConstraint.TryParse<TestStruct>(_this);
    //}

    public static TestEnum ToTestEnum(this string _this)
    {
      // #enum type works just fine (coding constraint to Enum type)
      return EnumConstraint.TryParse<TestEnum>(_this);
    }

    public static void TestAll()
    {
      TestEnum t1 = "e3".ToTestEnum();
      TestEnum t2 = "e2".ToTestEnum();
      TestEnum t3 = "non existing".ToTestEnum(); // default(TestEnum) for non existing 

      bool b1 = t3.IsSet(TestEnum.e1); // you can ommit type
      bool b2 = t3.IsSet<TestEnum>(TestEnum.e2); // you can specify explicite type

      TestStruct t;
      // #generates compile error (so no missuse)
      //bool b3 = t.IsSet<TestEnum>(TestEnum.e1);

    }

  }

如果有人仍然需要示例热来创建 Enum 编码约束：

using System;

/// <summary>
/// would be same as EnumConstraint_T<Enum>Parse<EnumType>("Normal"),
/// but writen like this it abuses constrain inheritence on System.Enum.
/// </summary>
public class EnumConstraint : EnumConstraint_T<Enum>
{

}

/// <summary>
/// provides ability to constrain TEnum to System.Enum abusing constrain inheritence
/// </summary>
/// <typeparam name="TClass">should be System.Enum</typeparam>
public abstract class EnumConstraint_T<TClass>
  where TClass : class
{

  public static TEnum Parse<TEnum>(string value)
    where TEnum : TClass
  {
    return (TEnum)Enum.Parse(typeof(TEnum), value);
  }

  public static bool TryParse<TEnum>(string value, out TEnum evalue)
    where TEnum : struct, TClass // struct is required to ignore non nullable type error
  {
    evalue = default(TEnum);
    return Enum.TryParse<TEnum>(value, out evalue);
  }

  public static TEnum TryParse<TEnum>(string value, TEnum defaultValue = default(TEnum))
    where TEnum : struct, TClass // struct is required to ignore non nullable type error
  {    
    Enum.TryParse<TEnum>(value, out defaultValue);
    return defaultValue;
  }

  public static TEnum Parse<TEnum>(string value, TEnum defaultValue = default(TEnum))
    where TEnum : struct, TClass // struct is required to ignore non nullable type error
  {
    TEnum result;
    if (Enum.TryParse<TEnum>(value, out result))
      return result;
    return defaultValue;
  }

  public static TEnum Parse<TEnum>(ushort value)
  {
    return (TEnum)(object)value;
  }

  public static sbyte to_i1<TEnum>(TEnum value)
  {
    return (sbyte)(object)Convert.ChangeType(value, typeof(sbyte));
  }

  public static byte to_u1<TEnum>(TEnum value)
  {
    return (byte)(object)Convert.ChangeType(value, typeof(byte));
  }

  public static short to_i2<TEnum>(TEnum value)
  {
    return (short)(object)Convert.ChangeType(value, typeof(short));
  }

  public static ushort to_u2<TEnum>(TEnum value)
  {
    return (ushort)(object)Convert.ChangeType(value, typeof(ushort));
  }

  public static int to_i4<TEnum>(TEnum value)
  {
    return (int)(object)Convert.ChangeType(value, typeof(int));
  }

  public static uint to_u4<TEnum>(TEnum value)
  {
    return (uint)(object)Convert.ChangeType(value, typeof(uint));
  }

}

希望这对某人有帮助。

Answer 4

从 C# 7.3 开始，您可以对泛型类型使用 Enum 约束：

public static TEnum Parse<TEnum>(string value) where TEnum : Enum
{
    return (TEnum) Enum.Parse(typeof(TEnum), value);
}

如果要使用 Nullable 枚举，则必须保留原始结构约束：

public static TEnum? TryParse<TEnum>(string value) where TEnum : struct, Enum
{
    if( Enum.TryParse(value, out TEnum res) )
        return res;
    else
        return null;
}

Answer 5

事实上，这是可能的，只是用了一个丑陋的把戏。
但是，它不能用于扩展方法。

public abstract class Enums<Temp> where Temp : class {
    public static TEnum Parse<TEnum>(string name) where TEnum : struct, Temp {
        return (TEnum)Enum.Parse(typeof(TEnum), name); 
    }
}
public abstract class Enums : Enums<Enum> { }

Enums.IsSet<DateTimeKind>("Local")

如果需要，您可以为 Enums 提供一个私有构造函数和一个公共嵌套抽象继承类，其中 Temp 作为 Enum，以防止非枚举的继承版本。

Answer 6

您可以使用 IL Weaving 和 ExtraConstraints

允许您编写此代码

public class Sample
{
    public void MethodWithDelegateConstraint<[DelegateConstraint] T> ()
    {        
    }
    public void MethodWithEnumConstraint<[EnumConstraint] T>()
    {
    }
}

< strong>编译什么

public class Sample
{
    public void MethodWithDelegateConstraint<T>() where T: Delegate
    {
    }

    public void MethodWithEnumConstraint<T>() where T: struct, Enum
    {
    }
}

Answer 7

这并没有回答最初的问题，但 .NET 4 中现在有一个名为 Enum.HasFlag 执行您在示例中尝试执行的操作

Answer 8

我这样做的方法是设置一个结构约束，然后在运行时检查 T 是否是一个枚举。 这并不能完全消除问题，但确实会在一定程度上减轻问题

Answer 9

使用原始代码，在方法内部，您还可以使用反射来测试 T 是否是枚举：

public static class EnumExtension
{
    public static bool IsSet<T>( this T input, T matchTo )
    {
        if (!typeof(T).IsEnum)
        {
            throw new ArgumentException("Must be an enum", "input");
        }
        return (input & matchTo) != 0;
    }
}

Answer 10

从 C# 7.3 开始，现在有一种内置方法可以添加枚举约束：

public class UsingEnum<T> where T : System.Enum { }

来源：https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/where-generic-type-constraint

Answer 11

Darren，如果类型是特定枚举，那么这将起作用 - 为了使通用枚举起作用，您必须将它们转换为整数（或更可能是 uint）来进行布尔数学运算：

public static bool IsSet( this Enum input, Enum matchTo )
{
    return ( Convert.ToUInt32( input ) & Convert.ToUInt32( matchTo ) ) != 0;
}

Answer 12

编辑：这现已在 UnconstrainedMelody 的 0.0.0.2 版本中上线。

（根据我的 关于枚举约束的博客文章。为了获得独立的答案，我在下面列出了基本事实。）

最好的解决方案是等待我将其包含在 UnconstrainedMelody¹ 中。 这是一个库，它采用带有“假”约束的 C# 代码，

where T : struct, IEnumConstraint

将其转换为

where T : struct, System.Enum

并通过构建后步骤

C# 代码。 编写 IsSet 应该不会太难...尽管同时满足基于 Int64 和基于 UInt64 的标志可能很棘手部分。 （我闻到一些辅助方法即将出现，基本上允许我将任何标志枚举视为具有 UInt64 基类型。）

如果您调用 ，您希望行为是什么

tester.IsSet(MyFlags.A | MyFlags.C)

？ 它是否应该检查所有指定的标志是否已设置？ 这将是我的期望。

今晚我会在回家的路上尝试这样做......我希望能够对有用的枚举方法进行快速闪电战，以使库快速达到可用标准，然后放松一下。

编辑：顺便说一句，我不确定 IsSet 作为名称。 选项：

• 包括
• 包含
• HasFlag（或HasFlags）
• IsSet（这当然是一个选项）

欢迎思考。 我确信无论如何，一切都需要一段时间才能确定...

---

¹ 当然，或者将其作为补丁提交...