[c#] 铸造int以在C#中枚举



Answers

只是施展它:

MyEnum e = (MyEnum)3;

你可以使用Enum.IsDefined检查它是否在范围内:

if (Enum.IsDefined(typeof(MyEnum), 3)) { ... }
Question

如何将int为C#中的enum




如果您有一个用作位掩码的整数,并且可以在[Flags]枚举中表示一个或多个值,则可以使用此代码将单个标志值解析为列表:

for (var flagIterator = 0x1; flagIterator <= 0x80000000; flagIterator <<= 1)
{
    // Check to see if the current flag exists in the bit mask
    if ((intValue & flagIterator) != 0)
    {
        // If the current flag exists in the enumeration, then we can add that value to the list
        // if the enumeration has that flag defined
        if (Enum.IsDefined(typeof(MyEnum), flagIterator))
            ListOfEnumValues.Add((MyEnum)flagIterator);
    }
}



要将字符串转换为ENUM或将int转换为ENUM常量,我们需要使用Enum.Parse函数。 这是一个YouTube视频https://www.youtube.com/watch?v=4nhx4VwdRDk ,它实际上演示了字符串,同样适用于int。

代码如下所示,其中“red”是字符串,“MyColors”是具有颜色常量的颜色ENUM。

MyColors EnumColors = (MyColors)Enum.Parse(typeof(MyColors), "Red");



以下是更好的扩展方法

public static string ToEnumString<TEnum>(this int enumValue)
        {
            var enumString = enumValue.ToString();
            if (Enum.IsDefined(typeof(TEnum), enumValue))
            {
                enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
            }
            return enumString;
        }



我不知道我在哪里得到这个枚举扩展的部分,但它来自于。 我很抱歉! 但是我拿了这个并用Flags修改为enums。 对于Flags的枚举,我这样做了:

  public static class Enum<T> where T : struct
  {
     private static readonly IEnumerable<T> All = Enum.GetValues(typeof (T)).Cast<T>();
     private static readonly Dictionary<int, T> Values = All.ToDictionary(k => Convert.ToInt32(k));

     public static T? CastOrNull(int value)
     {
        T foundValue;
        if (Values.TryGetValue(value, out foundValue))
        {
           return foundValue;
        }

        // For enums with Flags-Attribut.
        try
        {
           bool isFlag = typeof(T).GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
           if (isFlag)
           {
              int existingIntValue = 0;

              foreach (T t in Enum.GetValues(typeof(T)))
              {
                 if ((value & Convert.ToInt32(t)) > 0)
                 {
                    existingIntValue |= Convert.ToInt32(t);
                 }
              }
              if (existingIntValue == 0)
              {
                 return null;
              }

              return (T)(Enum.Parse(typeof(T), existingIntValue.ToString(), true));
           }
        }
        catch (Exception)
        {
           return null;
        }
        return null;
     }
  }

例:

[Flags]
public enum PetType
{
  None = 0, Dog = 1, Cat = 2, Fish = 4, Bird = 8, Reptile = 16, Other = 32
};

integer values 
1=Dog;
13= Dog | Fish | Bird;
96= Other;
128= Null;



从一个字符串:(Enum.Parse已过时,使用Enum.TryParse)

enum Importance
{}

Importance importance;

if (Enum.TryParse(value, out importance))
{
}



这是一个标志枚举感知安全转换方法:

public static bool TryConvertToEnum<T>(this int instance, out T result)
  where T: struct
{
  var enumType = typeof (T);
  if (!enumType.IsEnum)
  {
    throw new ArgumentException("The generic type must be an enum.");
  }
  var success = Enum.IsDefined(enumType, instance);
  if (success)
  {
    result = (T)Enum.ToObject(enumType, instance);
  }
  else
  {
    result = default(T);
  }
  return success;
}



我正在使用这段代码将int转换为我的枚举:

if (typeof(YourEnum).IsEnumDefined(valueToCast)) return (YourEnum)valueToCast;
else { //handle it here, if its not defined }

我觉得这是最好的解决方案。




我想要得到一个完整的答案,人们必须知道枚举如何在.NET内部工作。

事情怎么样

.NET中的枚举是一种将一组值(字段)映射到基本类型(缺省值为int )的结构。 但是,您实际上可以选择枚举映射到的整型:

public enum Foo : short

在这种情况下,枚举被映射到short数据类型,这意味着它将作为一个简短的内容存储在内存中,并且在您投射并使用它时会表现得很短。

如果你从IL的角度来看它,一个(normal,int)枚举看起来像这样:

.class public auto ansi serializable sealed BarFlag extends System.Enum
{
    .custom instance void System.FlagsAttribute::.ctor()
    .custom instance void ComVisibleAttribute::.ctor(bool) = { bool(true) }

    .field public static literal valuetype BarFlag AllFlags = int32(0x3fff)
    .field public static literal valuetype BarFlag Foo1 = int32(1)
    .field public static literal valuetype BarFlag Foo2 = int32(0x2000)

    // and so on for all flags or enum values

    .field public specialname rtspecialname int32 value__
}

这里需要注意的是value__与枚举值分开存储。 在上面的枚举Foo的情况下, value__的类型是int16。 这基本上意味着只要类型匹配 ,就可以在枚举中存储任何你想要的东西。

在这一点上,我想指出System.Enum是一个值类型,它基本上意味着BarFlag在内存中占用4个字节,而Foo占用2个 - 例如基础类型的大小(实际上更多比这更复杂,但嘿......)。

答案

所以,如果你有一个你想映射到一个枚举的整数,运行时只需要做两件事:复制4个字节并将其命名为其他名称(枚举的名称)。 复制是隐含的,因为数据存储为值类型 - 这基本上意味着如果使用非托管代码,则可以简单地交换枚举和整数而不复制数据。

为了安全起见,我认为最好的做法是知道底层类型是相同的还是隐式的可转换的,并确保枚举值存在(它们在默认情况下不会被检查!)。

要了解其工作原理,请尝试以下代码:

public enum MyEnum : int
{
    Foo = 1,
    Bar = 2,
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)5;
    var e2 = (MyEnum)6;

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}

请注意,投射到e2也有效! 从上面的编译器角度来看,这是有道理的: value__字段仅填充5或6,当Console.WriteLine调用ToString()e1的名称被解析,而e2的名称不被解析。

如果这不是你想要的,使用Enum.IsDefined(typeof(MyEnum), 6)来检查你正在映射的值是否映射到一个定义的枚举。

还要注意,即使编译器实际检查了这一点,我仍然清楚地知道枚举的基础类型。 我正在这样做,以确保我不会遇到任何意外。 为了在行动中看到这些惊喜,你可以使用下面的代码(实际上,我发现这在数据库代码中发生了很多):

public enum MyEnum : short
{
    Mek = 5
}

static void Main(string[] args)
{
    var e1 = (MyEnum)32769; // will not compile, out of bounds for a short

    object o = 5;
    var e2 = (MyEnum)o;     // will throw at runtime, because o is of type int

    Console.WriteLine("{0} {1}", e1, e2);
    Console.ReadLine();
}






Links