c# to c++ - Cast int à enum en C #




11 Answers

À partir d'une chaîne:

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.")

D'un int:

YourEnum foo = (YourEnum)yourInt;

Mettre à jour:

De nombre vous pouvez aussi

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

Comment un int peut-il être converti en une enum en C #?




Sinon, utilisez une méthode d'extension à la place d'une ligne:

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

Usage:

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

OU

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



Prenons l'exemple suivant:

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



Ci-dessous, une belle classe utilitaire pour 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;
    }
}



Si vous êtes prêt pour le .NET Framework 4.0, il existe une nouvelle fonction Enum.TryParse () qui est très utile et qui fonctionne bien avec l'attribut [Flags]. Voir Enum.TryParse, méthode (String, TEnum%)




Parfois, vous avez un objet du type MyEnum . Comme

var MyEnumType = typeof(MyEnumType);

Ensuite:

Enum.ToObject(typeof(MyEnum), 3)



Pour convertir une chaîne en ENUM ou int en ENUM constante, nous devons utiliser la fonction Enum.Parse. Voici une vidéo sur YouTube https://www.youtube.com/watch?v=4nhx4VwdRDk qui montre réellement avec chaîne et la même chose s'applique à int.

Le code va comme indiqué ci-dessous où "rouge" est la chaîne et "MyColors" est la couleur ENUM qui contient les constantes de couleur.

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



Ceci analyse des entiers ou des chaînes en une énumération cible avec une correspondance partielle dans dot.NET 4.0 à l'aide de génériques comme dans la classe d'utilitaires de Tawani ci-dessus. Je l'utilise pour convertir des variables de commutateur de ligne de commande qui peuvent être incomplètes. Comme une énumération ne peut pas être nulle, vous devez logiquement fournir une valeur par défaut. On peut appeler ça comme ça:

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

Voici le code:

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

FYI: La question portait sur les entiers, que personne n'a mentionné ne sera également explicitement converti en Enum.TryParse ()




Ce qui suit est légèrement meilleure méthode d'extension

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



Différentes façons de lancer à et de 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);


 }
}



Il peut vous aider à convertir les données d’entrée en un enum souhaité par l’utilisateur. Supposons que vous ayez une énumération comme ci-dessous qui, par défaut, int . Veuillez ajouter une valeur par défaut au début de votre énumération. Qui est utilisé par medersh quand il n’ya pas de correspondance avec la valeur en entrée.

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

NB: J'essaye ici d'analyser la valeur dans int, car enum est par défaut int Si vous définissez enum comme ceci, il s'agit d' un type d' octet .

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

Vous devez changer la méthode d'analyse syntaxique à partir de

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

à

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

Je vérifie ma méthode pour les entrées suivantes

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

Désolé pour mon anglais




Related