Wie erstellen Sie eine Dropdownliste aus einer Aufzählung in ASP.NET MVC?

Question

Ich versuche, die Html.DropDownList Erweiterungsmethode, kann aber nicht herausfinden, wie man sie mit einer Aufzählung verwenden kann.

Nehmen wir an, ich habe eine Aufzählung wie diese:

public enum ItemTypes
{
    Movie = 1,
    Game = 2,
    Book = 3
}

Wie erstelle ich eine Auswahlliste mit diesen Werten unter Verwendung der Html.DropDownList Erweiterungsmethode?

Oder ist meine beste Wette, um einfach eine for-Schleife erstellen und die Html-Elemente manuell erstellen?

Answer 1

Für MVC v5.1 verwenden Sie Html.EnumDropDownListFor

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

---

Für MVC v5 verwenden Sie EnumHelper

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

---

Für MVC 5 und niedriger

Ich habe die Antwort von Rune in eine Erweiterungsmethode umgewandelt:

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

Dies ermöglicht es Ihnen zu schreiben:

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

von using MyApp.Common

Answer 2

Ich weiß, ich bin spät dran, aber ich dachte, Sie könnten diese Variante nützlich finden, da sie Ihnen auch erlaubt, beschreibende Zeichenfolgen anstelle von Aufzählungskonstanten in der Dropdown-Liste zu verwenden. Um dies zu tun, dekorieren Sie jeden Aufzählungseintrag mit einem [System.ComponentModel.Description]-Attribut.

Zum Beispiel:

public enum TestEnum
{
  [Description("Full test")]
  FullTest,

  [Description("Incomplete or partial test")]
  PartialTest,

  [Description("No test performed")]
  None
}

Hier ist mein Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Reflection;
using System.ComponentModel;
using System.Linq.Expressions;

 ...

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

Sie können dies dann in Ihrer Ansicht tun:

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

Ich hoffe, das hilft Ihnen!

**ÄNDERUNG 2014-JAN-23: Microsoft hat gerade MVC 5.1 veröffentlicht, das nun eine EnumDropDownListFor-Funktion hat. Leider scheint es nicht das [Description]-Attribut zu respektieren, so dass der Code oben noch steht. Enum-Abschnitt in Microsofts Versionshinweise für MVC 5.1.

Update: Das Programm unterstützt die Anzeige Attribut [Display(Name = "Sample")] aber das kann man verwenden.

[Update - ich habe dies gerade bemerkt, und der Code sieht aus wie eine erweiterte Version des Codes hier: https://blogs.msdn.microsoft.com/stuartleeks/2010/05/21/asp-net-mvc-creating-a-dropdownlist-helper-for-enums/ mit ein paar Ergänzungen. Wenn ja, dann wäre eine Namensnennung angebracht ;-)]

Answer 3

Unter ASP.NET MVC 5.1 fügten sie die EnumDropDownListFor() Helper, so dass keine benutzerdefinierten Erweiterungen erforderlich sind:

Modell :

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

Siehe :

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

Tag Helper verwenden (ASP.NET MVC 6) :

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

Answer 4

Ich bin auf das gleiche Problem gestoßen, habe diese Frage gefunden und dachte, dass die von Ash angebotene Lösung nicht das ist, was ich suche; wenn ich das HTML selbst erstellen muss, bedeutet das weniger Flexibilität im Vergleich zu den integrierten Html.DropDownList() Funktion.

Es stellte sich heraus, dass C#3 usw. dies ziemlich einfach macht. Ich habe eine enum genannt. TaskStatus :

var statuses = from TaskStatus s in Enum.GetValues(typeof(TaskStatus))
               select new { ID = s, Name = s.ToString() };
ViewData["taskStatus"] = new SelectList(statuses, "ID", "Name", task.Status);

Dies schafft eine gute alte SelectList die Sie wie gewohnt in der Ansicht verwenden können:

<td><b>Status:</b></td><td><%=Html.DropDownList("taskStatus")%></td></tr>

Die anonyme Art und LINQ macht dies so viel mehr elegant IMHO. Nicht böse gemeint, Ash :)

Answer 5

Hier ist eine bessere gekapselte Lösung:

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

Sagen wir, das ist Ihr Modell:

Verwendungsbeispiel:

Generierte UI:

Und generiertes HTML

Der Quellcode der Helper-Erweiterung als Momentaufnahme:

Sie können das Beispielprojekt über den von mir angegebenen Link herunterladen.

EDIT: Hier ist der 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();
    }
}