दिलचस्प पोस्ट
एंड्रॉइड टुकड़े स्क्रीन रोटेशन या कॉन्फ़िगरेशन परिवर्तन के दौरान एक AsyncTask को बनाए रखना SQL सर्वर: क्या एक ही समय में दो तालिकाओं में सम्मिलित करना संभव है? बैच फ़ाइल: ढूँढें यदि उपस्ट्रिंग स्ट्रिंग में है (फ़ाइल में नहीं) देशी वस्तुओं को एक बुरा अभ्यास क्यों बढ़ा रहा है? SimpleXML से @ पहुंच का उपयोग करना Int को स्ट्रिंग में परिवर्तित करना c एन्क्रिप्शन / डिक्रिप्शन दो अलग-अलग OpenSL संस्करणों के बीच अच्छी तरह से काम नहीं करता है "यूएनसी पथ के बिना बैच फ़ाइल को नेटवर्क साझा करने से कैसे समर्थित नहीं है" संदेश? AngularJS घड़ी डोम परिवर्तन क्या हम जावा में अहस्ताक्षरित बाइट बना सकते हैं? क्रॉस डोमेन आइफ्रेम समस्या किसी भी गुणवत्ता को खोने के बिना एक छवि का आकार बदलना स्काई चालाक विधि मैं अभी तक समझ नहीं सकता कैसे प्रक्रिया कांटा () के बीच स्मृति साझा करने के लिए? स्टार्टअप पर मैं अपना ऐप कैसे प्रारंभ करूं?

आप एएसपी.नेट एमवीसी में एनएम्प से एक ड्रॉपडाउन सूची कैसे बनाते हैं?

मैं Html.DropDownList एक्सटेंशन विधि का उपयोग करने की कोशिश कर रहा हूं, लेकिन यह गणना नहीं कर सकता कि यह Html.DropDownList साथ कैसे उपयोग करें।

मान लीजिए मेरे पास इस तरह से गणन है:

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

मैं Html.DropDownList एक्सटेंशन विधि का उपयोग करके इन मानों के साथ एक ड्रॉपडाउन बनाने के बारे में कैसे जा सकता हूं?

या मेरी सबसे अच्छी शर्त है कि बस लूप के लिए एक बनाने और मैन्युअल रूप से एचटीएमएल तत्व बनाना?

वेब के समाधान से एकत्रित समाधान "आप एएसपी.नेट एमवीसी में एनएम्प से एक ड्रॉपडाउन सूची कैसे बनाते हैं?"

एमवीसी v5.1 के लिए Html.EnumDropDownListFor का उपयोग करें

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

एमवीसी वी 5 का उपयोग एनोमहेल्पर के लिए

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

एमवीसी 5 और कम के लिए

मैंने एक विस्तार विधि में रू्यून का जवाब लुढ़का:

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

यह आपको लिखने की अनुमति देता है:

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

using MyApp.Common

मुझे पता है कि मैं इस पर पार्टी के लिए देर कर रहा हूं, लेकिन सोचा कि आपको यह संस्करण उपयोगी पा सकते हैं, क्योंकि यह एक भी आपको ड्रॉप डाउन में गणितीय स्थिरांक के बजाय वर्णनात्मक स्ट्रिंग का उपयोग करने की अनुमति देता है। ऐसा करने के लिए, एक [System.ComponentModel.Description] विशेषता के साथ प्रत्येक गणन प्रविष्टि को सजाने के लिए।

उदाहरण के लिए:

 public enum TestEnum { [Description("Full test")] FullTest, [Description("Incomplete or partial test")] PartialTest, [Description("No test performed")] None } 

यहां मेरा कोड है:

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

आप अपने विचार में ऐसा कर सकते हैं:

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

आशा है कि यह आपको मदद करता है!

संपादित करें 2014-जन -201: माइक्रोसॉफ्ट ने अभी एमवीसी 5.1 जारी की है, जिसमें अब एक एन्मोड्रॉपडाउनलाइस्टफ़ोर सुविधा है। दुर्भाग्य से यह [विवरण] विशेषता का सम्मान नहीं करता है, इसलिए कोड ऊपर अभी भी खड़ा है। ( माइक्रोसॉफ्ट के रिलीज नोट्स के लिए http://www.asp.net/mvc/overview/releases/mvc51-release-notes#Enum देखें ।)

अद्यतन: यह प्रदर्शन विशेषता का समर्थन करता है [Display(Name = "Sample")] हालांकि, ऐसा कोई भी इसका उपयोग कर सकता है

[अपडेट – बस इसे देखा, और कोड कोड का एक विस्तारित संस्करण जैसा दिखता है: http://blogs.msdn.com/b/stuartleeks/archive/2010/05/21/asp-net-mvc-creating- ए-ड्रॉपडाउनलिस्ट-हेल्पर-फॉर-एन्नम.एस्पक्स , कुछ जोड़ों के साथ। यदि हां, तो एट्रिब्यूशन उचित लगेगा ;-)]

एएसपी.नेट एमवीसी 5.1 में , उन्होंने EnumDropDownListFor() सहायक को जोड़ा, इसलिए कस्टम एक्सटेंशन के लिए कोई ज़रूरत नहीं:

आदर्श :

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

देखें :

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

टैग सहायक (ASP.NET MVC 6) का उपयोग करना :

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

मैंने एक ही समस्या में टकराया, इस प्रश्न को मिला, और सोचा कि ऐश द्वारा प्रदान किए गए समाधान मैं नहीं चाहता था; एचटीएमएल बनाने के लिए स्वयं का मतलब है कि अंतर्निहित Html.DropDownList() फ़ंक्शन के मुकाबले कम लचीलापन है।

सी # 3 आदि को बदल देता है यह बहुत आसान है मेरे पास TaskStatus नामक एक 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); 

यह एक अच्छा राजभाषा ' SelectList बनाता है जिसे इस्तेमाल किया जा सकता है जैसे कि आप इस दृश्य में उपयोग करते हैं:

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

अनाम प्रकार और LINQ यह इतना अधिक सुरुचिपूर्ण IMHO बनाता है कोई अपराध नहीं करना, ऐश 🙂

यहां बेहतर समसामयिक समाधान है:

http://www.spicelogic.com/Journal/ASP-NET-MVC-DropDownListFor-Html-Helper-Enum-5

यहां कहो आपका मॉडल:

यहां छवि विवरण दर्ज करें

नमूना उपयोग:

यहां छवि विवरण दर्ज करें

उत्पन्न UI: यहां छवि विवरण दर्ज करें

और एचटीएमएल उत्पन्न

यहां छवि विवरण दर्ज करें

हेल्पर एक्सटेंशन स्रोत कोड स्नैप शॉट:

यहां छवि विवरण दर्ज करें

आप मुझे प्रदान की गई लिंक से नमूना प्रोजेक्ट डाउनलोड कर सकते हैं

संपादित करें: यहां कोड है:

 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 केवल एक IEnumerable की आवश्यकता है, तो पुरस्कार के विकल्प के लिए एक विकल्प निम्नानुसार है यह आपको बस लिखने की अनुमति देगा:

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

[जहां selectItemType आपके आइटम प्रकार प्रकार मॉडल पर फ़ील्ड है, और आपका मॉडल गैर-रिक्त है]

साथ ही, आपको वास्तव में एक्सटेंशन विधि को सामान्य बनाने की आवश्यकता नहीं है क्योंकि आप टाइपफ (टी) के बजाय enumValue.GetType () का उपयोग कर सकते हैं।

संपादित करें: एकीकृत साइमन का समाधान यहां भी है, और इसमें टोडेस्क्रिप्शन विस्तार विधि शामिल है।

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

तो एक्सटेंशन फ़ंक्शन के बिना यदि आप सरल और आसान लग रहे हैं .. यह मैंने जो किया है

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

जहां XXXXX.Sites.YYYY.Models.State एक enum है

शायद सहायक कार्य करने के लिए बेहतर है, लेकिन समय कम होने पर यह काम पूरा हो जाएगा।

पुरस्कार और रूण के उत्तर का विस्तार, यदि आप अपने चयन सूची आइटम का मान विशेषता करना चाहते हैं, तो मान कोड के बजाय पूर्णांक मान के लिए मानचित्र, निम्न कोड का उपयोग करें:

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

प्रत्येक गणना मूल्य को TEnum ऑब्जेक्ट के रूप में व्यवहार करने के बजाय, हम इसे एक वस्तु के रूप में इलाज कर सकते हैं और फिर इसे अनबॉक्सित मान प्राप्त करने के लिए पूर्णांक में डाल सकते हैं।

नोट: मैंने उन प्रकारों को प्रतिबंधित करने के लिए एक सामान्य प्रकार की बाधा भी डाल दी है जिसके लिए यह एक्सटेंशन केवल स्ट्रैक्ट्स (ऐन्यूम के आधार प्रकार) के लिए उपलब्ध है, और एक रन-टाइम प्रकार सत्यापन है जो यह सुनिश्चित करता है कि वास्तव में एक एन्यूएम

10/23/12 अपडेट करें: अंतर्निहित प्रकार के लिए जेनेरिक प्रकार पैरामीटर और .NET 4+ को प्रभावित करने वाले निश्चित गैर-संकलन समस्या।

पुरस्कार के विस्तार विधि का उपयोग करके पाठ के बजाय संख्या प्राप्त करने की समस्या को हल करने के लिए

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

इसके लिए मैंने जो सबसे अच्छा उपाय पाया है, वह इस ब्लॉग को साइमन गोल्डस्टोन के उत्तर से जोड़ रहा था।

यह मॉडल में enum का उपयोग करने की अनुमति देता है अनिवार्य रूप से यह विचार है कि एक पूर्णांक संपत्ति के साथ ही एन्यूम का उपयोग करना है, और पूर्णांक संपत्ति का अनुकरण करना है।

फिर अपने डिस्प्ले टेक्स्ट के साथ मॉडल को एनोटेट करने के लिए [System.ComponentModel.Description] विशेषता का उपयोग करें, और अपने दृश्य में "EnumDropDownListFor" एक्सटेंशन का उपयोग करें

यह दृश्य और मॉडल को बहुत ही पठनीय और रख-रखाव दोनों बनाता है।

आदर्श:

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

राय:

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

एक्सटेंशन ( साइमन गोल्डस्टोन के उत्तर से सीधे, पूर्णता के लिए यहां शामिल है):

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

आप Enum.GetValues जैसे कुछ का उपयोग करना चाहते हैं

यह करने के लिए एक सुपर आसान तरीका – बिना विस्तार के सभी सामान जो यह लगता है कि यह ओवरकिल है:

आपका मान:

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

अपने नियंत्रक के अंदर Enum एक सूची में बाँध:

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

उसके बाद इसे एक दृश्यबैग में फेंकें:

  ViewBag.RequiredLevel = new SelectList(myLevels); 

अंत में बस इसे देखें:

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

यह मैंने पाया सबसे आसान तरीका है और उसे किसी भी एक्सटेंशन या किसी भी चीज़ की आवश्यकता नहीं है जो पागल हो।

अद्यतनः एंड्रयूज़ की टिप्पणी नीचे दी गई है।

यह आईडी के रूप में Enum int मान का उपयोग करने के लिए रूण और पुरस्कार के उत्तरों को बदल दिया गया है

नमूना Enum:

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

एक्सटेंशन विधि:

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

उपयोग का नमूना:

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

एक्सटेंशन विधि वाले नामस्थान आयात करना याद रखें

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

जेनरेट किए गए HTML का नमूना:

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

ध्यान दें कि जिस आइटम पर आप ToSelectList को कॉल करने के लिए उपयोग करते हैं वह चयनित आइटम है

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

यह रेज़र के लिए संस्करण है:

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

मैं इस पर बहुत देर हो चुकी हूं, लेकिन अगर आपको Unconstrained मेलोडी नुगेट पैकेज (जॉन स्कीट से एक अच्छी, छोटी लाइब्रेरी) जोड़ने के लिए खुश हैं, तो मुझे एक कोड की एक पंक्ति के साथ ऐसा करने का वास्तव में अच्छा तरीका है।

यह समाधान बेहतर है क्योंकि:

  1. यह (सामान्य प्रकार की बाधाओं के साथ) यह सुनिश्चित करता है कि मूल्य वास्तव में एक मान मान है (बिना शर्त मेलोडी के कारण)
  2. यह अनावश्यक मुक्केबाजी से बचा जाता है (बिना असंबंधित मेलोडी के कारण)
  3. यह प्रत्येक कॉल पर प्रतिबिंब का उपयोग करने से बचने के लिए सभी विवरणों को कैश करता है (बिना शर्त मेलोडी के कारण)
  4. यह अन्य समाधानों की तुलना में कम कोड है!

इसलिए, यह काम करने के लिए यहां दिए गए कदम हैं:

  1. पैकेज मैनेजर कंसोल में, "इंस्टॉल-पैकेज अनकंस्टेनेड मेलोडी"
  2. इस तरह अपने मॉडल पर एक संपत्ति जोड़ें:

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

अब जब आपके पास अपने मॉडल पर चुने गए SelectListItem की सूची है, तो आप @Html.DropDownList या @ Html.DropDownList का उपयोग स्रोत के रूप में इस प्रॉपर्टी का उपयोग कर सकते हैं।

साइमन के उत्तर पर निर्माण, एक समान दृष्टिकोण ऐन्यू मूल्यों को एक संसाधन फ़ाइल से प्रदर्शित करने के लिए, ऐन्यू में खुद के विवरण विशेषता के बजाय प्राप्त करना है यह उपयोगी है अगर आपकी साइट को एक से अधिक भाषा में प्रदान की जानी चाहिए और यदि आपके पास एनोम के लिए एक विशिष्ट संसाधन फ़ाइल है, तो आप एक कदम आगे जा सकते हैं और आपके ऐन्यू में ऐन्यू वैल्यू, और विस्तार से उन्हें संदर्भित कर सकते हैं एक सम्मेलन [EnumName] _ [EnumValue] – अंत में कम टाइपिंग!

विस्तार तब दिखता है जैसे:

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

Enums.Resx फाइल में संसाधन ItemTypes_Movie की तरह लग रहा है: फिल्म

एक अन्य चीज जिसे मैं करना पसंद करता हूं, वह विस्तार विधि को सीधे कॉल करने के बजाय, मैं इसे @ एचटीएमएल। एडिटोरफोर (एक्स => एक्स। माइपरप्रोटी) के साथ कॉल करना चाहता हूं या आदर्श रूप में सिर्फ एक पूरे @ Html.EditorForModel ()। ऐसा करने के लिए मैं इस तरह दिखने के लिए स्ट्रिंग टेम्पलेट को बदलता हूं

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

यदि यह रुचियां आपको हैं, तो मैंने अपने ब्लॉग पर अधिक विस्तृत उत्तर दिया है:

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

अब यह सुविधा MVC 5.1 में @Html.EnumDropDownListFor() माध्यम से आउट-द-बॉक्स का समर्थन करती है @Html.EnumDropDownListFor()

निम्न लिंक की जांच करें:

http://www.asp.net/mvc/overview/releases/mvc51-release-notes#Enum

यह सचमुच शर्म की बात है कि उसने माइक्रोसॉफ्ट को 5 साल तक इस तरह की सुविधा को लागू करने के लिए लिया, जो कि ऊपर वोटिंग के अनुसार मांग में है!

इस विस्तार विधि के लिए एक और तय – वर्तमान संस्करण enum के वर्तमान मूल्य का चयन नहीं किया। मैंने अंतिम पंक्ति तय की:

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

यदि आप स्थानीयकरण समर्थन जोड़ना चाहते हैं तो बस s.toString () विधि को इस तरह से बदलें:

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

यहां प्रकार (संसाधन) आप संसाधन को लोड करना चाहते हैं, और फिर आपको स्थानीय स्ट्रिंग मिलता है, यह भी उपयोगी है अगर आपके एन्युमरेटर में कई शब्द हैं

यह सहायक पद्धति का मेरा संस्करण है मैं इसका उपयोग करता हूं:

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

उसके बदले में:

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

यह रहा:

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

You can also use my custom HtmlHelpers in Griffin.MvcContrib. निम्नलिखित कोड:

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

Generates:

यहां छवि विवरण दर्ज करें

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

Well I'm really late to the party, but for what it is worth, I have blogged about this very subject whereby I create a EnumHelper class that enables very easy transformation.

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

In your controller:

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

In your View:

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

The helper class:

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

@Simon Goldstone: Thanks for your solution, it can be perfectly applied in my case. The only problem is I had to translate it to VB. But now it is done and to save other people's time (in case they need it) I put it here:

 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 You use it like this:

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

I ended up creating extention methods to do what is essentially the accept answer here. The last half of the Gist deals with Enum specifically.

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

I found an answer here http://blogs.msdn.com/b/stuartleeks/archive/2010/05/21/asp-net-mvc-creating-a-dropdownlist-helper-for-enums.aspx ; however, some of my enums have [Description(...)] attribute, so I've modified the code to provide support for that:

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

उम्मीद है की वो मदद करदे।

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

1- Create your ENUM

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

2- Create your Service Class

 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- Set the ViewBag in your controller

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

4- Bind your DropDownList

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

Here a Martin Faartoft variation where you can put custom labels which is nice for localization.

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

Use in view:

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