Comment voulez-vous créer une liste déroulante à partir d'un enum ASP.NET MVC?

Pour MVC v5.1 utiliser le langage Html.EnumDropDownListFor

@Html.EnumDropDownListFor(
    x => x.YourEnumField,
    "Select My Type", 
    new { @class = "form-control" })

---

Pour MVC v5 utilisation EnumHelper

@Html.DropDownList("MyType", 
   EnumHelper.GetSelectList(typeof(MyType)) , 
   "Select My Type", 
   new { @class = "form-control" })

---

Pour MVC 5 et inférieur

J'ai roulé Rune de réponse dans une méthode d'extension:

namespace MyApp.Common
{
    public static class MyExtensions{
        public static SelectList ToSelectList<TEnum>(this TEnum enumObj)
            where TEnum : struct, IComparable, IFormattable, IConvertible
        {
            var values = from TEnum e in Enum.GetValues(typeof(TEnum))
                select new { Id = e, Name = e.ToString() };
            return new SelectList(values, "Id", "Name", enumObj);
        }
    }
}

Cela permet d'écrire:

ViewData["taskStatus"] = task.Status.ToSelectList();

par using MyApp.Common

Dans ASP.NET MVC 5.1, ils ont ajouté la EnumDropDownListFor() helper, donc pas besoin d'extensions personnalisées:

Modèle:

public enum MyEnum
{
[Display(Name = "First Value - desc..")]
FirstValue,
[Display(Name = "Second Value - desc...")]
SecondValue
}

Vue:

@Html.EnumDropDownListFor(model => model.MyEnum)

À l'aide de la Balise Helper (ASP.NET MVC 6):

<select asp-for="@Model.SelectedValue" asp-items="Html.GetEnumSelectList<MyEnum>()">

Voici une meilleure encapsulé solution:

https://www.spicelogic.com/Blog/enum-dropdownlistfor-asp-net-mvc-5

Dire ici, c'est votre modèle:

Exemple D'Utilisation:

Généré de l'INTERFACE utilisateur:

Et HTML généré

Le Helper Code Source de l'Extension snap shot:

Vous pouvez télécharger l'exemple de projet à partir du lien que j'ai fourni.

EDIT: Voici le code:

public static class EnumEditorHtmlHelper
{
///<summary>
///Creates the DropDown List (HTML Select Element) from LINQ 
///Expression where the expression returns an Enum type.
///</summary>
///<typeparam name="TModel">The type of the model.</typeparam>
///<typeparam name="TProperty">The type of the property.</typeparam>
///<param name="htmlHelper">The HTML helper.</param>
///<param name="expression">The expression.</param>
///<returns></returns>
public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper,
Expression<Func<TModel, TProperty>> expression) 
where TModel : class
{
TProperty value = htmlHelper.ViewData.Model == null 
? default(TProperty) 
: expression.Compile()(htmlHelper.ViewData.Model);
string selected = value == null ? String.Empty : value.ToString();
return htmlHelper.DropDownListFor(expression, createSelectList(expression.ReturnType, selected));
}
///<summary>
///Creates the select list.
///</summary>
///<param name="enumType">Type of the enum.</param>
///<param name="selectedItem">The selected item.</param>
///<returns></returns>
private static IEnumerable<SelectListItem> createSelectList(Type enumType, string selectedItem)
{
return (from object item in Enum.GetValues(enumType)
let fi = enumType.GetField(item.ToString())
let attribute = fi.GetCustomAttributes(typeof (DescriptionAttribute), true).FirstOrDefault()
let title = attribute == null ? item.ToString() : ((DescriptionAttribute) attribute).Description
select new SelectListItem
{
Value = item.ToString(), 
Text = title, 
Selected = selectedItem == item.ToString()
}).ToList();
}
}

Sans fonctions d'Extension si vous êtes à la recherche pour simple et facile.. C'est ce que j'ai fait

<%= Html.DropDownListFor(x => x.CurrentAddress.State, new SelectList(Enum.GetValues(typeof(XXXXX.Sites.YYYY.Models.State))))%>

où XXXXX.Sites.AAAA.Modèles.L'état est un enum

Probablement mieux à faire fonction d'assistance, mais quand le temps est court, cela va faire le travail.

Pour résoudre le problème d'avoir le numéro au lieu de texte à l'aide de la Prise de la méthode d'extension.

public static SelectList ToSelectList<TEnum>(this TEnum enumObj)
{
var values = from TEnum e in Enum.GetValues(typeof(TEnum))
select new { ID = (int)Enum.Parse(typeof(TEnum),e.ToString())
, Name = e.ToString() };
return new SelectList(values, "Id", "Name", enumObj);
}

La meilleure solution que j'ai trouvé pour cet été combinant ce blog avec Simon Goldstone réponse.

Cela permet l'utilisation d'enum dans le modèle. Essentiellement, l'idée est d'utiliser un nombre entier de propriété ainsi que l'enum, et imiter l'entier de la propriété.

Puis utilisez le bouton [System.ComponentModel.Description] attribut pour annoter le modèle avec votre texte d'affichage, et l'utilisation d'un "EnumDropDownListFor" extension de votre point de vue.

Ce fait à la fois la vue et le modèle très lisible et maintenable.

Modèle:

public enum YesPartialNoEnum
{
[Description("Yes")]
Yes,
[Description("Still undecided")]
Partial,
[Description("No")]
No
}
//........
[Display(Name = "The label for my dropdown list")]
public virtual Nullable<YesPartialNoEnum> CuriousQuestion{ get; set; }
public virtual Nullable<int> CuriousQuestionId
{
get { return (Nullable<int>)CuriousQuestion; }
set { CuriousQuestion = (Nullable<YesPartialNoEnum>)value; }
}

Vue:

@using MyProject.Extensions
{
//...
@Html.EnumDropDownListFor(model => model.CuriousQuestion)
//...
}

Extension (directement à partir de Simon Goldstone réponse, inclus ici par souci d'exhaustivité):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.ComponentModel;
using System.Reflection;
using System.Linq.Expressions;
using System.Web.Mvc.Html;
namespace MyProject.Extensions
{
//Extension methods must be defined in a static class
public static class MvcExtensions
{
private static Type GetNonNullableModelType(ModelMetadata modelMetadata)
{
Type realModelType = modelMetadata.ModelType;
Type underlyingType = Nullable.GetUnderlyingType(realModelType);
if (underlyingType != null)
{
realModelType = underlyingType;
}
return realModelType;
}
private static readonly SelectListItem[] SingleEmptyItem = new[] { new SelectListItem { Text = "", Value = "" } };
public static string GetEnumDescription<TEnum>(TEnum 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();
}
public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression)
{
return EnumDropDownListFor(htmlHelper, expression, null);
}
public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression, object htmlAttributes)
{
ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
Type enumType = GetNonNullableModelType(metadata);
IEnumerable<TEnum> values = Enum.GetValues(enumType).Cast<TEnum>();
IEnumerable<SelectListItem> items = from value in values
select new SelectListItem
{
Text = GetEnumDescription(value),
Value = value.ToString(),
Selected = value.Equals(metadata.Model)
};
//If the enum is nullable, add an 'empty' item to the collection
if (metadata.IsNullableValueType)
items = SingleEmptyItem.Concat(items);
return htmlHelper.DropDownListFor(expression, items, htmlAttributes);
}
}
}

@Html.DropDownListFor(model => model.Type, Enum.GetNames(typeof(Rewards.Models.PropertyType)).Select(e => new SelectListItem { Text = e }))

C'est la version pour Rasoir:

@{
var itemTypesList = new List<SelectListItem>();
itemTypesList.AddRange(Enum.GetValues(typeof(ItemTypes)).Cast<ItemTypes>().Select(
(item, index) => new SelectListItem
{
Text = item.ToString(),
Value = (index).ToString(),
Selected = Model.ItemTypeId == index
}).ToList());
}
@Html.DropDownList("ItemTypeId", itemTypesList)

Bâtiment sur Simon réponse, une approche similaire est d'obtenir les valeurs Enum d'affichage à partir d'un fichier de Ressources, au lieu d'un attribut de description au sein de l'Enum lui-même. Ceci est utile si votre site doit être rendu dans plus d'une langue et si vous avez un spécifique de fichier de ressources pour les Enums, vous pouvez aller plus loin et ont simplement les valeurs de l'Enum, dans votre Enum et de référence de l'extension par une convention telle que [EnumName]_[EnumValue] - en fin de compte moins de frappe!

L'extension ressemble alors à:

public static IHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> html, Expression<Func<TModel, TEnum>> expression)
{            
var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var enumType = Nullable.GetUnderlyingType(metadata.ModelType) ?? metadata.ModelType;
var enumValues = Enum.GetValues(enumType).Cast<object>();
var items = from enumValue in enumValues                        
select new SelectListItem
{
Text = GetResourceValueForEnumValue(enumValue),
Value = ((int)enumValue).ToString(),
Selected = enumValue.Equals(metadata.Model)
};
return html.DropDownListFor(expression, items, string.Empty, null);
}
private static string GetResourceValueForEnumValue<TEnum>(TEnum enumValue)
{
var key = string.Format("{0}_{1}", enumValue.GetType().Name, enumValue);
return Enums.ResourceManager.GetString(key) ?? enumValue.ToString();
}

Ressources dans les Énumérations.Fichier Resx à la recherche comme
ItemTypes_Movie : Film

Une autre chose que j'aimerais faire, c'est, au lieu d'appeler la méthode d'extension directement, je préfère l'appeler avec un @Html.EditorFor(x => x.MyProperty), ou idéalement juste d'avoir l'ensemble du formulaire, dans l'une des plus intéressantes @Html.EditorForModel(). Pour ce faire, j'ai changer le modèle de chaîne de ressembler à cette

@using MVCProject.Extensions
@{
var type = Nullable.GetUnderlyingType(ViewData.ModelMetadata.ModelType) ?? ViewData.ModelMetadata.ModelType;
@(typeof (Enum).IsAssignableFrom(type) ? Html.EnumDropDownListFor(x => x) : Html.TextBoxFor(x => x))
}

Si cela vous intéresse, j'ai mis beaucoup de réponse plus détaillée ici sur mon blog:

http://paulthecyclist.com/2013/05/24/enum-dropdown/

Dans .NET Core, vous pouvez utiliser seulement ceci:

@Html.DropDownListFor(x => x.Foo, Html.GetEnumSelectList<MyEnum>())

Un correctif pour cette extension de la méthode de la version actuelle ne sélectionnez pas l'enum de la valeur actuelle. J'ai corrigé la dernière ligne:

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()
};
return new SelectList(values, "ID", "Name", ((int)Enum.Parse(typeof(TEnum), enumObj.ToString())).ToString());
}

C'est ma version de la méthode d'assistance.
J'utilise ceci:

var values = from int e in Enum.GetValues(typeof(TEnum))
select new { ID = e, Name = Enum.GetName(typeof(TEnum), e) };

Au lieu de:

var values = from TEnum e in Enum.GetValues(typeof(TEnum))
select new { ID = (int)Enum.Parse(typeof(TEnum),e.ToString())
, Name = e.ToString() };

Ici, il est:

public static SelectList ToSelectList<TEnum>(this TEnum self) where TEnum : struct
{
if (!typeof(TEnum).IsEnum)
{
throw new ArgumentException("self must be enum", "self");
}
Type t = typeof(TEnum);
var values = from int e in Enum.GetValues(typeof(TEnum))
select new { ID = e, Name = Enum.GetName(typeof(TEnum), e) };
return new SelectList(values, "ID", "Name", self);
}

J'aimerais répondre à cette question d'une autre manière, l'utilisateur n'a pas besoin de faire quoi que ce soit controller ou Linq expression. De cette manière...

J'ai un ENUM

public enum AccessLevelEnum
{
///<summary>
///The user cannot access
///</summary>
[EnumMember, Description("No Access")]
NoAccess = 0x0,
///<summary>
///The user can read the entire record in question
///</summary>
[EnumMember, Description("Read Only")]
ReadOnly = 0x01,
///<summary>
///The user can read or write
///</summary>
[EnumMember, Description("Read /Modify")]
ReadModify = 0x02,
///<summary>
///User can create new records, modify and read existing ones
///</summary>
[EnumMember, Description("Create /Read /Modify")]
CreateReadModify = 0x04,
///<summary>
///User can read, write, or delete
///</summary>
[EnumMember, Description("Create /Read /Modify /Delete")]
CreateReadModifyDelete = 0x08,
/*///<summary>
///User can read, write, or delete
///</summary>
[EnumMember, Description("Create /Read /Modify /Delete /Verify /Edit Capture Value")]
CreateReadModifyDeleteVerify = 0x16*/
}

Maintenant, je canto, il suffit de créer un dropdown en utilisant ce enum.

@Html.DropDownList("accessLevel",new SelectList(AccessLevelEnum.GetValues(typeof(AccessLevelEnum))),new { @class = "form-control" })

OU

@Html.DropDownListFor(m=>m.accessLevel,new SelectList(AccessLevelEnum.GetValues(typeof(AccessLevelEnum))),new { @class = "form-control" })

Si vous voulez faire un index sélectionné, puis essayez ce

@Html.DropDownListFor(m=>m.accessLevel,new SelectList(AccessLevelEnum.GetValues(typeof(AccessLevelEnum)) , AccessLevelEnum.NoAccess ),new { @class = "form-control" })

Ici, j'ai utilisé AccessLevelEnum.NoAccess comme un paramètre supplémentaire pour la valeur par défaut en sélectionnant le menu déroulant.

@Simon Goldstone: Merci pour votre solution, il peut être parfaitement appliqué dans mon cas. Le seul problème est que j'ai eu à le traduire dans VB. Mais maintenant c'est fait et pour sauver du temps aux autres (dans le cas où ils en ont besoin) je l'ai mis ici:

Imports System.Runtime.CompilerServices
Imports System.ComponentModel
Imports System.Linq.Expressions
Public Module HtmlHelpers
Private Function GetNonNullableModelType(modelMetadata As ModelMetadata) As Type
Dim realModelType = modelMetadata.ModelType
Dim underlyingType = Nullable.GetUnderlyingType(realModelType)
If Not underlyingType Is Nothing Then
realModelType = underlyingType
End If
Return realModelType
End Function
Private ReadOnly SingleEmptyItem() As SelectListItem = {New SelectListItem() With {.Text = "", .Value = ""}}
Private Function GetEnumDescription(Of TEnum)(value As TEnum) As String
Dim fi = value.GetType().GetField(value.ToString())
Dim attributes = DirectCast(fi.GetCustomAttributes(GetType(DescriptionAttribute), False), DescriptionAttribute())
If Not attributes Is Nothing AndAlso attributes.Length > 0 Then
Return attributes(0).Description
Else
Return value.ToString()
End If
End Function
<Extension()>
Public Function EnumDropDownListFor(Of TModel, TEnum)(ByVal htmlHelper As HtmlHelper(Of TModel), expression As Expression(Of Func(Of TModel, TEnum))) As MvcHtmlString
Return EnumDropDownListFor(htmlHelper, expression, Nothing)
End Function
<Extension()>
Public Function EnumDropDownListFor(Of TModel, TEnum)(ByVal htmlHelper As HtmlHelper(Of TModel), expression As Expression(Of Func(Of TModel, TEnum)), htmlAttributes As Object) As MvcHtmlString
Dim metaData As ModelMetadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData)
Dim enumType As Type = GetNonNullableModelType(metaData)
Dim values As IEnumerable(Of TEnum) = [Enum].GetValues(enumType).Cast(Of TEnum)()
Dim items As IEnumerable(Of SelectListItem) = From value In values
Select New SelectListItem With
{
.Text = GetEnumDescription(value),
.Value = value.ToString(),
.Selected = value.Equals(metaData.Model)
}
' If the enum is nullable, add an 'empty' item to the collection
If metaData.IsNullableValueType Then
items = SingleEmptyItem.Concat(items)
End If
Return htmlHelper.DropDownListFor(expression, items, htmlAttributes)
End Function
End Module

Fin Vous l'utiliser comme ceci:

@Html.EnumDropDownListFor(Function(model) (model.EnumField))

@Html.DropdownListFor(model=model->Gender,new List<SelectListItem>
{
new ListItem{Text="Male",Value="Male"},
new ListItem{Text="Female",Value="Female"},
new ListItem{Text="--- Select -----",Value="-----Select ----"}
}
)

Ici un Martin Faartoft variation où vous pouvez mettre des étiquettes personnalisées qui est agréable pour la localisation.

public static class EnumHtmlHelper
{
public static SelectList ToSelectList<TEnum>(this TEnum enumObj, Dictionary<int, string> customLabels)
where TEnum : struct, IComparable, IFormattable, IConvertible
{
var values = from TEnum e in Enum.GetValues(typeof(TEnum))
select new { Id = e, Name = customLabels.First(x => x.Key == Convert.ToInt32(e)).Value.ToString() };
return new SelectList(values, "Id", "Name", enumObj);
}
}

Utilisation:

@Html.DropDownListFor(m => m.Category, Model.Category.ToSelectList(new Dictionary<int, string>() { 
{ 1, ContactResStrings.FeedbackCategory }, 
{ 2, ContactResStrings.ComplainCategory }, 
{ 3, ContactResStrings.CommentCategory },
{ 4, ContactResStrings.OtherCategory }
}), new { @class = "form-control" })
@Html.ValidationMessageFor(m => m.Category)

Dans MVC4, je ferais comme ceci

@Html.DropDownList("RefType", new SelectList(Enum.GetValues(typeof(WebAPIApp.Models.RefType))), " Select", new { @class = "form-control" })
public enum RefType
{
Web = 3,
API = 4,
Security = 5,
FE = 6
}
public class Reference
{
public int Id { get; set; }
public RefType RefType { get; set; }
}

1 - Créer votre ENUM

public enum LicenseType
{
xxx = 1,
yyy = 2
}

2 - Créer votre Classe de Service

public class LicenseTypeEnumService
{
public static Dictionary<int, string> GetAll()
{
var licenseTypes = new Dictionary<int, string>();
licenseTypes.Add((int)LicenseType.xxx, "xxx");
licenseTypes.Add((int)LicenseType.yyy, "yyy");
return licenseTypes;
}
public static string GetById(int id)
{
var q = (from p in this.GetAll() where p.Key == id select p).Single();
return q.Value;
}
}

3 - Définir le ViewBag dans votre contrôleur

var licenseTypes = LicenseTypeEnumService.GetAll();
ViewBag.LicenseTypes = new SelectList(licenseTypes, "Key", "Value");

4 - Lier votre DropDownList

@Html.DropDownList("LicenseType", (SelectList)ViewBag.LicenseTypes)