Comment puis-je convertir la liste <string> à la liste <myEnumType>?

Question

Je n'ai pas pu convertir List<string> en List<myEnumType>. Je ne sais pas pourquoi?

string Val = it.Current.Value.ToString(); // works well here 
List<myEnumType> ValList = new List<myEnumType>(Val.Split(',')); // compile failed 

de la cause myEnumType type défini en tant que type chaîne de ENUM comme cela,

public enum myEnumType 
{ 
    strVal_1, 
    strVal_2, 
    strVal_3, 
} 

Y at-il quelque chose de mal? Apprécié pour vos réponses.

Answer 1

EDIT: Oups, j'ai également manqué l'étiquette C# 2. Je vais laisser les autres options disponibles ci-dessous, mais:

En C# 2, vous êtes probablement mieux à l'aide List<T>.ConvertAll:

List<MyEnumType> enumList = stringList.ConvertAll(delegate(string x) { 
    return (MyEnumType) Enum.Parse(typeof(MyEnumType), x); }); 

ou Unconstrained Melody:

List<MyEnumType> enumList = stringList.ConvertAll(delegate(string x) { 
    return Enums.ParseName<MyEnumType>(x); }); 

Notez que cela ne supposons que vous avez vraiment un List<string> pour commencer, ce qui est correct pour votre titre mais pas pour le corps dans votre question. Heureusement, il y a une méthode Array.ConvertAll statique équivalente que vous auriez à utiliser comme ceci:

MyEnumType[] enumArray = Array.ConvertAll(stringArray, delegate (string x) { 
    return (MyEnumType) Enum.Parse(typeof(MyEnumType), x); }); 

---

réponse originale

Deux options:

• Utilisez Enum.Parse et une distribution dans une requête LINQ:

  var enumList = stringList 
        .Select(x => (MyEnumType) Enum.Parse(typeof(MyEnumType), x)) 
        .ToList(); 
  

ou

var enumList = stringList.Select(x => Enum.Parse(typeof(MyEnumType), x)) 
          .Cast<MyEnumType>() 
          .ToList(); 

• Utilisez mon projet Unconstrained Melody:

  var enumList = stringList.Select(x => Enums.ParseName<MyEnumType>(x)) 
           .ToList(); 
  

Answer 2

En C# 2.0:

List<myEnumType> ValList = new List<myEnumType>(); 
foreach (string x in Val.Split(',')) 
    ValList.Add((MyEnumType) Enum.Parse(typeof(MyEnumType), x)); 

Answer 3

 List<String> list = new List<String>(); 

     list.Add("strVal_1"); 
     list.Add("strVal_2"); 
     list.Add("strVal_3"); 

     List<myEnumType> enumList = new List<myEnumType>(); 

     foreach (var item in list) 
     { 
      enumList.Add((myEnumType)Enum.Parse(typeof(myEnumType), item)); 
     } 

Answer 4

Créer une méthode d'extension et Select faire le travail:

public static class ExtensionClass 
{ 
    public static myEnumType GetEnumValue(this string input) 
    { 
     if (input == myEnumType.strVal_1.ToString()) 
      return myEnumType.strVal_1; 
     return input == myEnumType.strVal_2.ToString() ? myEnumType.strVal_2 : myEnumType.strVal_3; 
    } 
} 

List<myEnumType> ValList = new List<myEnumType>(Val.Split(',').Select(p=>p.GetEnumValue())); 

I Missed c tag # 2.0 :)

Answer 5

J'ai ajouté une méthode d'extension à IEnumerable<string> de le faire pour moi. La réponse de Skeet est bonne, évidemment, mais elle lèvera une exception si les chaînes ne sont pas valides pour l'énumération (que vous pouvez ou ne pouvez pas vouloir), et c'est une ligne plutôt laide.

public static class StringEnumerableExtensions { 
    public static IEnumerable<T> StringsToEnums<T>(this IEnumerable<string> strs) where T : struct, IConvertible { 
     Type t = typeof(T); 

     var ret = new List<T>(); 

     if(t.IsEnum) { 
      T outStr; 
      foreach(var str in strs) { 
       if(Enum.TryParse(str, out outStr)) { 
        ret.Add(outStr); 
       } 
      } 
     } 

     return ret; 
    } 
} 

Donné ce ENUM:

public enum ColorEnum { Blue, Yellow } 

Vous pouvez utiliser comme ceci:

var colors = new List<string>() {"Blue","Yellow","Black"}; 
var colorEnums = colors.StringsToEnums<ColorEnum>(); 

Et vous obtiendrez une liste avec juste Blue et Yellow.