c# - 으로 - int enum 변환




int를 C#에서 열거 형으로 캐스트합니다. (14)

C #에서 intenum 으로 캐스팅 할 수 있습니까?



그냥 던져 :

MyEnum e = (MyEnum)3;

Enum.IsDefined 사용하여 범위 내에 있는지 확인할 수 있습니다.

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

다음은 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;
    }
}

다음은 약간 더 나은 확장 방법입니다.

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

더 이상이 enum 확장의 일부를 어디에서 얻을지 모르지만 에서 왔습니다. 나는 이것을 유감스럽게 생각한다! 하지만 이걸 가져 와서 Flags로 enum을 수정했습니다. 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;

때로는 MyEnum 유형의 객체가 있습니다. 처럼

var MyEnumType = typeof(MyEnumType);

그때:

Enum.ToObject(typeof(MyEnum), 3)

문자열에서 : (Enum.Parse가 오래되었습니다. Enum.TryParse를 사용하십시오.)

enum Importance
{}

Importance importance;

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

문자열에서 :

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

숫자 값의 경우이 값은 무엇이든 상관없이 객체를 반환하므로 더 안전합니다.

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

약간 원래 질문에서 멀리지고,하지만 스택 오버플로 질문에 대한 답변을 발견 enum 유용한 int 값을 가져와 . public const int 속성을 사용하여 정적 클래스를 만들어 관련 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;
}

분명히 일부 열거 형 기능은 손실 될 것이지만 많은 데이터베이스 ID 상수를 저장하는 데는 꽤 깔끔한 솔루션처럼 보입니다.


이 코드를 사용하여 int 열을 내 enum으로 캐스팅합니다.

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

나는 그것을 최상의 해결책으로 생각한다.


이것은 위의 Tawani의 유틸리티 클래스에서와 같이 generics를 사용하여 dot.NET 4.0에서 부분 일치가있는 대상 열거 형에 정수 또는 문자열을 구문 분석합니다. 불완전한 명령 줄 스위치 변수를 변환하는 데 사용하고 있습니다. enum은 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 ()에서 명시 적으로 변환하지 않습니다.


제 경우에는 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;
    }
}

열거 형에서 설명을 가져 오는 Extension 메서드는 다음과 같습니다.

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

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


 }
}




casting