Comment faire pour récupérer les valeurs de l'enum dans un SelectList

Imaginer que j'ai une énumération comme ceci (juste un exemple):

public enum Direction{
    Horizontal = 0,
    Vertical = 1,
    Diagonal = 2
}

Comment puis-je écrire une routine pour obtenir ces valeurs dans un Système.Web.Mvc.SelectList, étant donné que le contenu de l'énumération sont sujettes à des changements dans l'avenir? Je veux obtenir chaque énumérations nom de l'option de texte, et sa valeur comme la valeur du texte, comme ceci:

<select>
    <option value="0">Horizontal</option>
    <option value="1">Vertical</option>
    <option value="2">Diagonal</option>
</select>

C'est le mieux que je peux venir avec à ce jour:

 public static SelectList GetDirectionSelectList()
 {
    Array values = Enum.GetValues(typeof(Direction));
    List<ListItem> items = new List<ListItem>(values.Length);

    foreach (var i in values)
    {
        items.Add(new ListItem
        {
            Text = Enum.GetName(typeof(Direction), i),
            Value = i.ToString()
        });
    }

    return new SelectList(items);
 }

Toutefois, cela rend toujours l'option de texte comme 'Système.Web.Mvc.ListItem'. Débogage à travers ce me montre aussi que le protocole Enum.GetValues() retourne 'Horizontale, à la Verticale", etc. au lieu de 0, 1 comme je l'ai prévu, ce qui me fait me demander quelle est la différence entre les Enum.GetName() et Enum.GetValue().

C'est un gros double de stackoverflow.com/questions/1102022/... et beaucoup d'autres.

InformationsquelleAutor Lee D | 2009-07-10

asp.net-mvc c#enums

27

Pour obtenir la valeur de l'enum vous avez besoin de jeter l'enum à son type sous-jacent:
```
Value = ((int)i).ToString();
```
- Merci! J'ai pensé à cela, mais la pensée qu'il pourrait y avoir un moyen de le faire sans de la coulée.
InformationsquelleAutor Andrew Hare
83

Il a été un certain temps depuis que j'ai eu à faire cela, mais je pense que cela devrait fonctionner.
```
var directions = from Direction d in Enum.GetValues(typeof(Direction))
           select new { ID = (int)d, Name = d.ToString() };
return new SelectList(directions , "ID", "Name", someSelectedValue);
```
- Fonctionne presque, seulement besoin d'un changement mineur! Votre code sera mis à la valeur du Texte lors de l'OP voulait qu'elle soit un entier. Solution facile si. Changement ID = d à ID = (int)d. Merci pour cette annonce, je n'aurais jamais pensé à ça!
- Grande réponse, mais j'ai trouvé que pour pré-remplir la liste déroulante, la valeur devait être la représentation textuelle de l'enum, pas le entier.
InformationsquelleAutor Brandon
37

Il est une nouvelle fonctionnalité dans ASP.NET MVC 5.1 pour cela.

http://www.asp.net/mvc/overview/releases/mvc51-release-notes#Enum
```
@Html.EnumDropDownListFor(model => model.Direction)
```
- Est-il un taghelper version de cette?
- Oui. <select asp-items="Html.GetEnumSelectList<Direction>()"></select>.
- comment voulez-vous obtenir la valeur sélectionnée dans le contrôleur de cette forme?
InformationsquelleAutor Fred
32

C'est ce que je viens de faire et je pense personnellement sa sexy:
```
 public static IEnumerable<SelectListItem> GetEnumSelectList<T>()
        {
            return (Enum.GetValues(typeof(T)).Cast<T>().Select(
                enu => new SelectListItem() { Text = enu.ToString(), Value = enu.ToString() })).ToList();
        }
```
Je vais faire de la traduction des trucs finalement si la Valeur = enu.ToString() va faire un appel à quelque chose quelque part.
- Je vais avoir un problème avec ce code. La "Valeur" de la SelectList est le même que le "Texte". Lors de l'utilisation des Énumérations avec EntityFramework, la valeur enregistrée dans la base de données doit être un int.
- Ok, bien faire cela, alors: Valeur = (int)enu
- La raison (int)enu ne fonctionne pas dans l'exemple ci-dessus est parce que la Valeur de la propriété de SelectListItem est une chaîne en un entier. ((int)enu).ToString() fonctionne.
- Non, il ne le pourra pas. Dans l'exemple ci-dessus, au moment de la compilation, il ne sait pas le type de T. En tant que tel, vous ne pouvez pas lancer de int comme ça.
- Comme en C# 7.3 vous pouvez maintenant ajouter 'où T : Système.Enum'.
InformationsquelleAutor Dann
22

Je voulais faire quelque chose de très similaire à Dann la solution, mais j'avais besoin de la Valeur d'un int et le texte à la représentation de chaîne de l'Enum. C'est ce que je suis venu avec:
```
public static IEnumerable<SelectListItem> GetEnumSelectList<T>()
    {
        return (Enum.GetValues(typeof(T)).Cast<int>().Select(e => new SelectListItem() { Text = Enum.GetName(typeof(T), e), Value = e.ToString() })).ToList();
    }
```
- C'est de loin la meilleure réponse. La valeur nécessaire pour être de type int représentation de l'enum.
InformationsquelleAutor J.Noel.K
8

Dans ASP.NET Core, MVC, cela se fait avec tag aides.
```
<select asp-items="Html.GetEnumSelectList<Direction>()"></select>
```
- Ce qui fait un bon chemin dans .NET de Base
InformationsquelleAutor Fred

Ou:

foreach (string item in Enum.GetNames(typeof(MyEnum)))
{
    myDropDownList.Items.Add(new ListItem(item, ((int)((MyEnum)Enum.Parse(typeof(MyEnum), item))).ToString()));
}

InformationsquelleAutor zkarolyi

return
            Enum
            .GetNames(typeof(ReceptionNumberType))
            .Where(i => (ReceptionNumberType)(Enum.Parse(typeof(ReceptionNumberType), i.ToString())) < ReceptionNumberType.MCI)
            .Select(i => new
            {
                description = i,
                value = (Enum.Parse(typeof(ReceptionNumberType), i.ToString()))
            });

InformationsquelleAutor Hamid

peut-être pas une réponse exacte à la question, mais dans CRUD scénarios d'habitude je met en œuvre quelque chose comme ceci:

private void PopulateViewdata4Selectlists(ImportJob job)
{
   ViewData["Fetcher"] = from ImportFetcher d in Enum.GetValues(typeof(ImportFetcher))
                              select new SelectListItem
                              {
                                  Value = ((int)d).ToString(),
                                  Text = d.ToString(),
                                  Selected = job.Fetcher == d
                              };
}

PopulateViewdata4Selectlists est appelée avant que la Vue("Création") et la Vue("Edit"), alors, et dans la Vue:

<%= Html.DropDownList("Fetcher") %>

et c'est tout..

InformationsquelleAutor Carl Hörberg

    public static SelectList ToSelectList<TEnum>(this TEnum enumObj) where TEnum : struct
{
if (!typeof(TEnum).IsEnum) throw new ArgumentException("An Enumeration type is required.", "enumObj");
var values = from TEnum e in Enum.GetValues(typeof(TEnum)) select new { ID = (int)Enum.Parse(typeof(TEnum), e.ToString()), Name = e.ToString() };
//var values = from TEnum e in Enum.GetValues(typeof(TEnum)) select new { ID = e, Name = e.ToString() };
return new SelectList(values, "ID", "Name", enumObj);
}
public static SelectList ToSelectList<TEnum>(this TEnum enumObj, string selectedValue) where TEnum : struct
{
if (!typeof(TEnum).IsEnum) throw new ArgumentException("An Enumeration type is required.", "enumObj");
var values = from TEnum e in Enum.GetValues(typeof(TEnum)) select new { ID = (int)Enum.Parse(typeof(TEnum), e.ToString()), Name = e.ToString() };
//var values = from TEnum e in Enum.GetValues(typeof(TEnum)) select new { ID = e, Name = e.ToString() };
if (string.IsNullOrWhiteSpace(selectedValue))
{
return new SelectList(values, "ID", "Name", enumObj);
}
else
{
return new SelectList(values, "ID", "Name", selectedValue);
}
}

InformationsquelleAutor Joao Leme

J'ai plus de classes et de méthodes pour des raisons diverses:

Enum pour la collecte d'éléments

public static class EnumHelper
{
public static List<ItemDto> EnumToCollection<T>()
{
return (Enum.GetValues(typeof(T)).Cast<int>().Select(
e => new ItemViewModel
{
IntKey = e,
Value = Enum.GetName(typeof(T), e)
})).ToList();
}
}

La création de selectlist dans le Contrôleur

int selectedValue = 1; //resolved from anywhere
ViewBag.Currency = new SelectList(EnumHelper.EnumToCollection<Currency>(), "Key", "Value", selectedValue);

Mavue.cshtml

@Html.DropDownListFor(x => x.Currency, null, htmlAttributes: new { @class = "form-control" })

InformationsquelleAutor Miroslav Holec

J'ai eu beaucoup de enum Selectlists et, après beaucoup de la chasse et de criblage, de la trouve que de faire un générique helper fonctionne le mieux pour moi. Il renvoie l'index ou le descripteur comme le Selectlist valeur, et la Description de la Selectlist texte:

Enum:

public enum Your_Enum
{
[Description("Description 1")]
item_one,
[Description("Description 2")]
item_two
}

Helper:

public static class Selectlists
{
public static SelectList EnumSelectlist<TEnum>(bool indexed = false) where TEnum : struct
{
return new SelectList(Enum.GetValues(typeof(TEnum)).Cast<TEnum>().Select(item => new SelectListItem
{
Text = GetEnumDescription(item as Enum),
Value = indexed ? Convert.ToInt32(item).ToString() : item.ToString()
}).ToList(), "Value", "Text");
}
//NOTE: returns Descriptor if there is no Description
private static string GetEnumDescription(Enum value)
{
FieldInfo fi = value.GetType().GetField(value.ToString());
DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attributes != null && attributes.Length > 0)
return attributes[0].Description;
else
return value.ToString();
}
}

Utilisation:
Régler le paramètre "true" pour les indices de valeur:

var descriptorsAsValue = Selectlists.EnumSelectlist<Your_Enum>();
var indicesAsValue = Selectlists.EnumSelectlist<Your_Enum>(true);

InformationsquelleAutor RickL

Vous devez vous connecter pour publier un commentaire.