Bagaimana Anda membuat dropdownlist dari enum di ASP.NET MVC?

Saya mencoba menggunakan Html.DropDownListmetode ekstensi tetapi tidak tahu cara menggunakannya dengan enumerasi.

Katakanlah saya memiliki penghitungan seperti ini:

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

Bagaimana cara saya membuat dropdown dengan nilai-nilai ini menggunakan Html.DropDownListmetode ekstensi?

Atau apakah taruhan terbaik saya adalah dengan membuat for for dan membuat elemen Html secara manual?

Untuk MVC v5.1 gunakan Html.EnumDropDownListFor

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

Untuk MVC v5 gunakan EnumHelper

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

Untuk MVC 5 dan lebih rendah

Saya menggulung jawaban Rune ke dalam metode ekstensi:

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

Ini memungkinkan Anda untuk menulis:

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

oleh using MyApp.Common

Saya tahu saya terlambat ke pesta tentang hal ini, tetapi saya pikir Anda mungkin menemukan varian ini berguna, karena yang ini juga memungkinkan Anda untuk menggunakan string deskriptif daripada konstanta enumerasi dalam drop down. Untuk melakukan ini, hiasi setiap entri enumerasi dengan atribut [System.ComponentModel.Description].

Sebagai contoh:

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

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

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

Ini kode saya:

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

Anda kemudian dapat melakukan ini dalam pandangan Anda:

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

Semoga ini bisa membantu Anda!

** EDIT 2014-JAN-23: Microsoft baru saja merilis MVC 5.1, yang sekarang memiliki fitur EnumDropDownListFor. Sayangnya itu tampaknya tidak menghormati atribut [Deskripsi] sehingga kode di atas masih berdiri. Lihat bagian Enum di catatan rilis Microsoft untuk MVC 5.1.

Pembaruan: Itu memang mendukung atribut Display[Display(Name = "Sample")] , jadi orang dapat menggunakannya.

[Perbarui - perhatikan saja ini, dan kode ini terlihat seperti versi kode yang diperluas di sini: https://blogs.msdn.microsoft.com/stuartleeks/2010/05/21/asp-net-mvc-creating-a- dropdownlist-helper-for-enums / , dengan beberapa tambahan. Jika demikian, atribusi akan tampak adil ;-)]

Di ASP.NET MVC 5.1 , mereka menambahkan EnumDropDownListFor()helper, jadi tidak perlu untuk ekstensi khusus:

Model :

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

Lihat :

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

Menggunakan Tag Helper (ASP.NET MVC 6) :

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

Saya bertemu dengan masalah yang sama, menemukan pertanyaan ini, dan berpikir bahwa solusi yang diberikan oleh Ash bukan yang saya cari; Harus membuat HTML sendiri berarti kurang fleksibel dibandingkan dengan Html.DropDownList()fungsi bawaan.

Ternyata C # 3 dll membuat ini sangat mudah. Saya telah sebuah enumdisebut 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);

Ini menghasilkan ol yang bagus SelectListyang bisa digunakan seperti yang biasa Anda lihat:

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

Tipe anonim dan LINQ membuat IMHO ini jauh lebih elegan. Tidak ada pelanggaran yang dimaksudkan, Ash. :)

Berikut ini adalah solusi enkapsulasi yang lebih baik:

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

Katakan di sini adalah model Anda:

Penggunaan sampel:

UI yang dihasilkan:

Dan menghasilkan HTML

Snapshot Kode Sumber Ekstensi Pembantu:

Anda dapat mengunduh proyek sampel dari tautan yang saya berikan.

EDIT: Inilah kodenya:

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

Html.DropDownListFor hanya membutuhkan IEnumerable, jadi alternatif untuk solusi Prise adalah sebagai berikut. Ini memungkinkan Anda untuk menulis:

@Html.DropDownListFor(m => m.SelectedItemType, Model.SelectedItemType.ToSelectList())

[Di mana SelectedItemType adalah bidang pada model ItemTypes jenis Anda, dan model Anda bukan nol]

Selain itu, Anda tidak perlu membuat generik metode ekstensi karena Anda dapat menggunakan enumValue.GetType () daripada typeof (T).

EDIT: Solusi Simon terintegrasi di sini juga, dan termasuk metode ekstensi ToDescription.

public static class EnumExtensions
{
    public static IEnumerable<SelectListItem> ToSelectList(this Enum enumValue)
    {
        return from Enum e in Enum.GetValues(enumValue.GetType())
               select new SelectListItem
               {
                   Selected = e.Equals(enumValue),
                   Text = e.ToDescription(),
                   Value = e.ToString()
               };
    }

    public static string ToDescription(this Enum value)
    {
        var attributes = (DescriptionAttribute[])value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), false);
        return attributes.Length > 0 ? attributes[0].Description : value.ToString();
    }
}

Jadi tanpa fungsi Extension jika Anda mencari yang sederhana dan mudah .. Inilah yang saya lakukan

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

di mana XXXXX.Sites.YYYY.Models.State adalah enum

Mungkin lebih baik melakukan fungsi helper, tetapi ketika waktu singkat ini akan menyelesaikan pekerjaan.

Memperluas jawaban Hadiah dan Rune, jika Anda ingin memiliki atribut nilai peta item daftar pilih Anda ke nilai integer dari tipe Enumerasi, daripada nilai string, gunakan kode berikut:

public static SelectList ToSelectList<T, TU>(T enumObj) 
    where T : struct
    where TU : struct
{
    if(!typeof(T).IsEnum) throw new ArgumentException("Enum is required.", "enumObj");

    var values = from T e in Enum.GetValues(typeof(T))
                 select new { 
                    Value = (TU)Convert.ChangeType(e, typeof(TU)),
                    Text = e.ToString() 
                 };

    return new SelectList(values, "Value", "Text", enumObj);
}

Alih-alih memperlakukan setiap nilai Enumerasi sebagai objek TEnum, kita bisa memperlakukannya sebagai objek lalu melemparkannya ke integer untuk mendapatkan nilai yang tidak dikotak.

Catatan: Saya juga menambahkan batasan tipe generik untuk membatasi tipe yang ekstensi ini hanya tersedia untuk struct (tipe dasar Enum), dan validasi tipe run-time yang memastikan bahwa struct yang dilewati memang merupakan Enum.

Pembaruan 10/23/12: Menambahkan parameter tipe umum untuk tipe dasar dan memperbaiki masalah non-kompilasi yang mempengaruhi .NET 4+.

Untuk mengatasi masalah mendapatkan nomor alih-alih teks menggunakan metode ekstensi Prise.

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

Cara super mudah untuk menyelesaikan ini - tanpa semua ekstensi yang tampaknya berlebihan adalah ini:

Enum Anda:

    public enum SelectedLevel
    {
       Level1,
       Level2,
       Level3,
       Level4
    }

Di dalam pengontrol Anda mengikat Enum ke Daftar:

    List<SelectedLevel> myLevels = Enum.GetValues(typeof(SelectedLevel)).Cast<SelectedLevel>().ToList();

Setelah itu buang ke dalam ViewBag:

    ViewBag.RequiredLevel = new SelectList(myLevels);

Akhirnya cukup ikat ke View:

    @Html.DropDownList("selectedLevel", (SelectList)ViewBag.RequiredLevel, new { @class = "form-control" })

Sejauh ini, ini adalah cara termudah yang saya temukan dan tidak memerlukan ekstensi atau apapun yang gila.

UPDATE : Lihat komentar Andrews di bawah ini.

Solusi terbaik yang saya temukan untuk ini adalah menggabungkan blog ini dengan jawaban Simon Goldstone .

Ini memungkinkan penggunaan enum dalam model. Intinya idenya adalah menggunakan properti integer serta enum, dan meniru properti integer.

Kemudian gunakan atribut [System.ComponentModel.Description] untuk membubuhi keterangan model dengan teks tampilan Anda, dan gunakan ekstensi "EnumDropDownListFor" di tampilan Anda.

Ini membuat tampilan dan model sangat mudah dibaca dan dipelihara.

Model:

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

Melihat:

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

Ekstensi (langsung dari jawaban Simon Goldstone , termasuk di sini untuk kelengkapan):

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

Anda ingin melihat menggunakan sesuatu seperti Enum.GetValues

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

Ini adalah jawaban Rune & Hadiah yang diubah untuk menggunakan nilai Enum intsebagai ID.

Sampel Enum:

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

Metode ekstensi:

    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", (int)Enum.Parse(typeof(TEnum), enumObj.ToString()));
    }

Contoh penggunaan:

 <%=  Html.DropDownList("MyEnumList", ItemTypes.Game.ToSelectList()) %>

Ingatlah untuk Mengimpor namespace yang berisi metode Extension

<%@ Import Namespace="MyNamespace.LocationOfExtensionMethod" %>

Contoh HTML yang dihasilkan:

<select id="MyEnumList" name="MyEnumList">
    <option value="1">Movie</option>
    <option selected="selected" value="2">Game</option>
    <option value="3">Book </option>
</select>

Perhatikan bahwa item yang Anda gunakan untuk memanggil ToSelectListadalah item yang dipilih.

Ini adalah versi untuk Razor:

@{
    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)

Di .NET Core Anda bisa menggunakan ini:

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

Sekarang fitur ini didukung di luar kotak di MVC 5.1 hingga @Html.EnumDropDownListFor()

Periksa tautan berikut:

https://docs.microsoft.com/en-us/aspnet/mvc/overview/releases/mvc51-release-notes#Enum

Sangat memalukan bahwa Microsoft membutuhkan waktu 5 tahun untuk mengimplementasikan fitur seperti yang sangat diminati menurut pemungutan suara di atas!

Membangun pada jawaban Simon, pendekatan yang sama adalah untuk mendapatkan nilai-nilai Enum untuk ditampilkan dari file Sumber Daya, bukan dalam atribut deskripsi dalam Enum itu sendiri. Ini bermanfaat jika situs Anda perlu diterjemahkan dalam lebih dari satu bahasa dan jika Anda memiliki file sumber daya spesifik untuk Enums, Anda dapat melangkah lebih jauh dan hanya memiliki nilai Enum, di Enum Anda dan merujuknya dari ekstensi dengan sebuah konvensi seperti [EnumName] _ [EnumValue] - akhirnya kurang mengetik!

Ekstensi tersebut kemudian terlihat seperti:

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

Sumber daya dalam file Enums.Resx tampak seperti ItemTypes_Movie: Film

Satu hal lain yang ingin saya lakukan adalah, daripada memanggil metode ekstensi secara langsung, saya lebih suka menyebutnya dengan @ Html.EditorFor (x => x.MyProperty), atau idealnya hanya memiliki seluruh bentuk, dalam satu @ rapi Html.EditorForModel (). Untuk melakukan ini, saya mengubah templat string menjadi seperti ini

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

Jika ini menarik minat Anda, saya telah memberikan jawaban yang jauh lebih rinci di blog saya:

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

Yah saya benar-benar terlambat ke pesta, tetapi untuk apa nilainya, saya telah membuat blog tentang subjek ini di mana saya membuat EnumHelperkelas yang memungkinkan transformasi yang sangat mudah.

http://jnye.co/Posts/4/creating-a-dropdown-list-from-an-enum-in-mvc-and-c%23

Di controller Anda:

//If you don't have an enum value use the type
ViewBag.DropDownList = EnumHelper.SelectListFor<MyEnum>();

//If you do have an enum value use the value (the value will be marked as selected)    
ViewBag.DropDownList = EnumHelper.SelectListFor(MyEnum.MyEnumValue);

Menurut Anda:

@Html.DropDownList("DropDownList")
@* OR *@
@Html.DropDownListFor(m => m.Property, ViewBag.DropDownList as SelectList, null)

Kelas pembantu:

public static class EnumHelper
{
    // Get the value of the description attribute if the   
    // enum has one, otherwise use the value.  
    public static string GetDescription<TEnum>(this TEnum value)
    {
        var fi = value.GetType().GetField(value.ToString());

        if (fi != null)
        {
            var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);

            if (attributes.Length > 0)
            {
                return attributes[0].Description;
            }
        }

        return value.ToString();
    }

    /// <summary>
    /// Build a select list for an enum
    /// </summary>
    public static SelectList SelectListFor<T>() where T : struct
    {
        Type t = typeof(T);
        return !t.IsEnum ? null
                         : new SelectList(BuildSelectListItems(t), "Value", "Text");
    }

    /// <summary>
    /// Build a select list for an enum with a particular value selected 
    /// </summary>
    public static SelectList SelectListFor<T>(T selected) where T : struct
    {
        Type t = typeof(T);
        return !t.IsEnum ? null
                         : new SelectList(BuildSelectListItems(t), "Text", "Value", selected.ToString());
    }

    private static IEnumerable<SelectListItem> BuildSelectListItems(Type t)
    {
        return Enum.GetValues(t)
                   .Cast<Enum>()
                   .Select(e => new SelectListItem { Value = e.ToString(), Text = e.GetDescription() });
    }
}

Saya sangat terlambat dalam hal ini, tetapi saya baru saja menemukan cara yang sangat keren untuk melakukan ini dengan satu baris kode, jika Anda senang menambahkan paket Melody NuGet yang tidak dibatasi (perpustakaan kecil yang bagus dari Jon Skeet).

Solusi ini lebih baik karena:

1. Ini memastikan (dengan batasan tipe generik) bahwa nilainya benar-benar merupakan nilai enum (karena Melodi Tidak Dibatasi)
2. Ini menghindari tinju yang tidak perlu (karena Melody yang tidak dibatasi)
3. Itu cache semua deskripsi untuk menghindari menggunakan refleksi pada setiap panggilan (karena Melody yang tidak dibatasi)
4. Itu kode kurang dari solusi lain!

Jadi, inilah langkah-langkah untuk membuatnya bekerja:

1. Di Package Manager Console, "Instal-Paket Tidak Terbatas"

2. Tambahkan properti pada model Anda seperti ini:

   //Replace "YourEnum" with the type of your enum
   public IEnumerable<SelectListItem> AllItems
   {
       get
       {
           return Enums.GetValues<YourEnum>().Select(enumValue => new SelectListItem { Value = enumValue.ToString(), Text = enumValue.GetDescription() });
       }
   }

Sekarang Anda memiliki Daftar SelectListItem terbuka pada model Anda, Anda dapat menggunakan @ Html.DropDownList atau @ Html.DropDownListFor menggunakan properti ini sebagai sumber.

Perbaikan lain untuk metode ekstensi ini - versi saat ini tidak memilih nilai enum saat ini. Saya memperbaiki baris terakhir:

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

Jika Anda ingin menambahkan dukungan lokalisasi, ubah saja metode s.toString () menjadi seperti ini:

ResourceManager rManager = new ResourceManager(typeof(Resources));
var dayTypes = from OperatorCalendarDay.OperatorDayType s in Enum.GetValues(typeof(OperatorCalendarDay.OperatorDayType))
               select new { ID = s, Name = rManager.GetString(s.ToString()) };

Di sini typeof (Sumber) adalah sumber yang ingin Anda muat, dan kemudian Anda mendapatkan String yang dilokalkan, juga berguna jika enumerator Anda memiliki nilai dengan banyak kata.

Ini adalah versi metode penolong saya. Saya menggunakan ini:

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

Alih-alih itu:

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

Ini dia:

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

Anda juga dapat menggunakan HtmlHelpers khusus saya di Griffin.MvcContrib. Kode berikut:

@Html2.CheckBoxesFor(model => model.InputType) <br />
@Html2.RadioButtonsFor(model => model.InputType) <br />
@Html2.DropdownFor(model => model.InputType) <br />

Menghasilkan:

https://github.com/jgauffin/griffin.mvccontrib

Saya ingin menjawab pertanyaan ini dengan cara yang berbeda di mana, pengguna tidak perlu melakukan apa pun di dalam controlleratau Linqekspresi. Cara ini...

Saya punya 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*/
    }

Sekarang saya hanya bisa membuat dropdowndengan menggunakan ini enum.

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

ATAU

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

Jika Anda ingin membuat indeks dipilih maka coba ini

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

Di sini saya telah menggunakan AccessLevelEnum.NoAccesssebagai parameter tambahan untuk memilih dropdown secara default.

Saya menemukan jawaban di sini . Namun, beberapa enum saya memiliki [Description(...)]atribut, jadi saya telah memodifikasi kode untuk memberikan dukungan untuk itu:

    enum Abc
    {
        [Description("Cba")]
        Abc,

        Def
    }


    public static MvcHtmlString EnumDropDownList<TEnum>(this HtmlHelper htmlHelper, string name, TEnum selectedValue)
    {
        IEnumerable<TEnum> values = Enum.GetValues(typeof(TEnum))
            .Cast<TEnum>();

        List<SelectListItem> items = new List<SelectListItem>();
        foreach (var value in values)
        {
            string text = value.ToString();

            var member = typeof(TEnum).GetMember(value.ToString());
            if (member.Count() > 0)
            {
                var customAttributes = member[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
                if (customAttributes.Count() > 0)
                {
                    text = ((DescriptionAttribute)customAttributes[0]).Description;
                }
            }

            items.Add(new SelectListItem
            {
                Text = text,
                Value = value.ToString(),
                Selected = (value.Equals(selectedValue))
            });
        }

        return htmlHelper.DropDownList(
            name,
            items
            );
    }

Semoga itu bisa membantu.

@Simon Goldstone: Terima kasih atas solusi Anda, ini dapat diterapkan dengan sempurna dalam kasus saya. Satu-satunya masalah adalah saya harus menerjemahkannya ke VB. Tapi sekarang sudah selesai dan untuk menghemat waktu orang lain (jika mereka membutuhkannya) saya taruh di sini:

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

End Anda menggunakannya seperti ini:

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

Saya akhirnya menciptakan metode ekstensi untuk melakukan apa yang pada dasarnya adalah jawaban terima di sini. Setengah terakhir dari Gist berkaitan dengan Enum secara khusus.

https://gist.github.com/3813767

@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 ----"}
}
)

@Html.DropDownListFor(model => model.MaritalStatus, new List<SelectListItem> 
{  

new SelectListItem { Text = "----Select----", Value = "-1" },


new SelectListItem { Text = "Marrid", Value = "M" },


 new SelectListItem { Text = "Single", Value = "S" }

})