铸造诠释枚举在C＃

如何将一个int为C＃中的enum ？

Answer 1

从string：

 YourEnum foo = (YourEnum) Enum.Parse(typeof(YourEnum), yourString); // the foo.ToString().Contains(",") check is necessary for enumerations marked with an [Flags] attribute if (!Enum.IsDefined(typeof(YourEnum), foo) && !foo.ToString().Contains(",")) throw new InvalidOperationException($"{yourString} is not an underlying value of the YourEnum enumeration.") 

从int：

 YourEnum foo = (YourEnum)yourInt; 

更新：

从数字你也可以

 YourEnum foo = (YourEnum)Enum.ToObject(typeof(YourEnum) , yourInt); 

Answer 2

只是施展而已：

 MyEnum e = (MyEnum)3; 

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

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

Answer 3

或者，使用扩展方法而不是一行代码：

 public static T ToEnum<T>(this string enumString) { return (T) Enum.Parse(typeof (T), enumString); } 

用法：

 Color colorEnum = "Red".ToEnum<Color>(); 

要么

 string color = "Red"; var colorEnum = color.ToEnum<Color>(); 

Answer 4

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

如何工作

.NET中的枚举是一种将一组值（字段）映射到基本types（缺省值为int ）的结构。 但是，您实际上可以select枚举映射到的整型：

 public enum Foo : short 

在这种情况下，枚举被映射为short数据types，这意味着它将被存储在内存中，并且在您投射并使用它时将performance得很短。

如果从IL的angular度来看，一个（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__的types是int16。 这基本上意味着只要types匹配 ，就可以在枚举中存储任何你想要的东西。

在这一点上我想指出， System.Enum是一个值types，这基本上意味着BarFlag将占用4个字节的内存和Foo将占用2 – 例如底层types的大小（它实际上更多比那复杂，但嘿…）。

答案

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

为了安全起见，我认为最好的做法是知道基础types是相同的还是隐式的可转换的，并且确保枚举值存在（它们在默认情况下不被检查！）。

要查看这是如何工作的，请尝试下面的代码：

 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也有效！ 从上面的编译器angular度来看，这是有道理的： value__字段只填充5或6，当Console.WriteLine调用ToString() ， e1的名字被parsing，而e2的名字不是。

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

另外请注意，即使编译器实际检查了这一点，我仍然明白枚举的基本types。 我正在这样做，以确保我不会遇到任何惊喜。 要看到这些惊人的行动，你可以使用下面的代码（实际上我已经看到这在数据库代码中发生了很多）：

 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(); } 

Answer 5

以下面的例子：

 int one = 1; MyEnum e = (MyEnum)one; 

Answer 6

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

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

我觉得这是最好的解决scheme。

Answer 7

下面是Enums的一个很好的工具类

 public static class EnumHelper { public static int[] ToIntArray<T>(T[] value) { int[] result = new int[value.Length]; for (int i = 0; i < value.Length; i++) result[i] = Convert.ToInt32(value[i]); return result; } public static T[] FromIntArray<T>(int[] value) { T[] result = new T[value.Length]; for (int i = 0; i < value.Length; i++) result[i] = (T)Enum.ToObject(typeof(T),value[i]); return result; } internal static T Parse<T>(string value, T defaultValue) { if (Enum.IsDefined(typeof(T), value)) return (T) Enum.Parse(typeof (T), value); int num; if(int.TryParse(value,out num)) { if (Enum.IsDefined(typeof(T), num)) return (T)Enum.ToObject(typeof(T), num); } return defaultValue; } } 

Answer 8

对于数值，这是更安全的，因为它会返回一个对象，无论如何：

 public static class EnumEx { static public bool TryConvert<T>(int value, out T result) { result = default(T); bool success = Enum.IsDefined(typeof(T), value); if (success) { result = (T)Enum.ToObject(typeof(T), value); } return success; } } 

Answer 9

如果您已经准备好了4.0 .NET Framework，则有一个新的Enum.TryParse（）函数非常有用，可以很好地与[Flags]属性配合使用。 请参阅Enum.TryParse方法（string，TEnum％）

Answer 10

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

 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); } } 

Answer 11

有时你有一个MyEnumtypes的对象。 喜欢

 var MyEnumType = typeof(MyEnumType); 

然后：

 Enum.ToObject(typeof(MyEnum), 3) 

Answer 12

要将string转换为ENUM或将int转换为ENUM常量，我们需要使用Enum.Parse函数。 这里是一个YouTubevideohttps://www.youtube.com/watch?v=4nhx4VwdRDk其中实际显示的string，同样适用于int。

代码如下所示，其中“red”是string，“MyColors”是具有颜色常量的颜色ENUM。

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

Answer 13

稍微摆脱原来的问题，但我发现堆栈溢出问题的答案获取int值从枚举有用。 使用public const int属性创build一个静态类，使您可以轻松地收集一堆相关的int常量，然后在使用它们时不必将它们转换为int 。

 public static class Question { public static readonly int Role = 2; public static readonly int ProjectFunding = 3; public static readonly int TotalEmployee = 4; public static readonly int NumberOfServers = 5; public static readonly int TopBusinessConcern = 6; } 

显然，一些枚举types的function将会丢失，但是为了存储一堆数据库id常量，这看起来像是一个非常整洁的解决scheme。

Answer 14

这parsing整数或string的目标枚举与Dot.NET 4.0部分匹配使用类似在上面的Tawani的工具类generics。 我正在使用它来转换可能不完整的命令行开关variables。 由于枚举不能为null，因此应该逻辑地提供一个默认值。 它可以这样调用：

 var result = EnumParser<MyEnum>.Parse(valueToParse, MyEnum.FirstValue); 

代码如下：

 using System; public class EnumParser<T> where T : struct { public static T Parse(int toParse, T defaultVal) { return Parse(toParse + "", defaultVal); } public static T Parse(string toParse, T defaultVal) { T enumVal = defaultVal; if (defaultVal is Enum && !String.IsNullOrEmpty(toParse)) { int index; if (int.TryParse(toParse, out index)) { Enum.TryParse(index + "", out enumVal); } else { if (!Enum.TryParse<T>(toParse + "", true, out enumVal)) { MatchPartialName(toParse, ref enumVal); } } } return enumVal; } public static void MatchPartialName(string toParse, ref T enumVal) { foreach (string member in enumVal.GetType().GetEnumNames()) { if (member.ToLower().Contains(toParse.ToLower())) { if (Enum.TryParse<T>(member + "", out enumVal)) { break; } } } } } 

仅供参考：问题是关于整数，没有人提到，也将显式转换为Enum.TryParse（）

Answer 15

从一个string：（Enum.Parse是过时的，使用Enum.TryParse）

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

Answer 16

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

 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; } 

Answer 17

在我的情况下，我需要从一个WCF服务返回枚举。 我还需要一个友好的名字，而不仅仅是enum.ToString（）。

这是我的WCF类。

 [DataContract] public class EnumMember { [DataMember] public string Description { get; set; } [DataMember] public int Value { get; set; } public static List<EnumMember> ConvertToList<T>() { Type type = typeof(T); if (!type.IsEnum) { throw new ArgumentException("T must be of type enumeration."); } var members = new List<EnumMember>(); foreach (string item in System.Enum.GetNames(type)) { var enumType = System.Enum.Parse(type, item); members.Add( new EnumMember() { Description = enumType.GetDescriptionValue(), Value = ((IConvertible)enumType).ToInt32(null) }); } return members; } } 

下面是从Enum获取Description的扩展方法。

  public static string GetDescriptionValue<T>(this T source) { FieldInfo fileInfo = source.GetType().GetField(source.ToString()); DescriptionAttribute[] attributes = (DescriptionAttribute[])fileInfo.GetCustomAttributes(typeof(DescriptionAttribute), false); if (attributes != null && attributes.Length > 0) { return attributes[0].Description; } else { return source.ToString(); } } 

执行：

 return EnumMember.ConvertToList<YourType>(); 

Answer 18

从 Enum投入的不同方式

 enum orientation : byte { north = 1, south = 2, east = 3, west = 4 } class Program { static void Main(string[] args) { orientation myDirection = orientation.north; Console.WriteLine(“myDirection = {0}”, myDirection); //output myDirection =north Console.WriteLine((byte)myDirection); //output 1 string strDir = Convert.ToString(myDirection); Console.WriteLine(strDir); //output north string myString = “north”; //to convert string to Enum myDirection = (orientation)Enum.Parse(typeof(orientation),myString); } } 

Answer 19

我不知道在哪里得到这个枚举扩展的一部分，但它是从计算器。 我很抱歉！ 但是我拿了这个，用Flags把它修改成枚举。 对于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; 

Answer 20

以下是更好的扩展方法

 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; } 

Answer 21

它可以帮助您将任何input数据转换为用户所需的枚举 。 假设你有一个枚举类似下面默认的int 。 请首先在您的枚举中添加一个默认值。 如果找不到与input值匹配的匹配方法，则使用该方法。

 public enum FriendType { Default, Audio, Video, Image } public static class EnumHelper<T> { public static T ConvertToEnum(dynamic value) { var result = default(T); var tempType = 0; //see Note below if (value != null && int.TryParse(value.ToString(), out tempType) && Enum.IsDefined(typeof(T), tempType)) { result = (T)Enum.ToObject(typeof(T), tempType); } return result; } } 

注意：在这里，我尝试将值parsing为int，因为枚举是默认情况下int如果你定义这样的枚举是字节types。

 public enum MediaType : byte { Default, Audio, Video, Image } 

您需要从辅助方法更改parsing

 int.TryParse(value.ToString(), out tempType) 

至

byte.TryParse(value.ToString(), out tempType)

我检查我的方法以下input

 EnumHelper<FriendType>.ConvertToEnum(null); EnumHelper<FriendType>.ConvertToEnum(""); EnumHelper<FriendType>.ConvertToEnum("-1"); EnumHelper<FriendType>.ConvertToEnum("6"); EnumHelper<FriendType>.ConvertToEnum(""); EnumHelper<FriendType>.ConvertToEnum("2"); EnumHelper<FriendType>.ConvertToEnum(-1); EnumHelper<FriendType>.ConvertToEnum(0); EnumHelper<FriendType>.ConvertToEnum(1); EnumHelper<FriendType>.ConvertToEnum(9); 

对不起我的英语不好