मैं Html.DropDownListविस्तार विधि का उपयोग करने की कोशिश कर रहा हूं, लेकिन यह पता नहीं लगा सकता कि इसका उपयोग कैसे किया जाए।
मान लीजिए कि मेरे पास इस तरह का एक ज्ञान है:
public enum ItemTypes
{
Movie = 1,
Game = 2,
Book = 3
}मैं Html.DropDownListएक्सटेंशन विधि का उपयोग करके इन मूल्यों के साथ ड्रॉपडाउन कैसे बनाऊं ?
या मेरा सबसे अच्छा शर्त केवल लूप बनाने के लिए और एचटीएमएल तत्वों को मैन्युअल रूप से बनाना है?
जवाबों:
@Html.EnumDropDownListFor(
x => x.YourEnumField,
"Select My Type",
new { @class = "form-control" })@Html.DropDownList("MyType",
EnumHelper.GetSelectList(typeof(MyType)) ,
"Select My Type",
new { @class = "form-control" })मैंने रुण के उत्तर को विस्तार विधि में रोल किया:
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
ASP.NET MVCवहाँ एक देशी तरीका है: stackoverflow.com/a/22295360/1361084
मुझे पता है कि मुझे इस पर पार्टी के लिए देर हो रही है, लेकिन सोचा कि आप इस संस्करण को उपयोगी पा सकते हैं, क्योंकि यह आपको ड्रॉप डाउन में एन्यूमरेशन स्थिरांक के बजाय वर्णनात्मक तारों का उपयोग करने की अनुमति देता है। ऐसा करने के लिए, प्रत्येक एन्यूमरेशन प्रविष्टि को [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)आशा है कि यह आपकी मदद करता है!
** EDIT 2014-JAN-23: Microsoft ने अभी MVC 5.1 जारी किया है, जिसमें अब EnumDropDownListFor सुविधा है। अफसोस की बात है कि यह [विवरण] विशेषता का सम्मान नहीं करता है इसलिए ऊपर का कोड अभी भी खड़ा है । Microsoft के रिलीज़ नोटों में Enum खंड ।
अद्यतन: यह समर्थन करता है प्रदर्शन विशेषता का[Display(Name = "Sample")] , लेकिन कोई भी इसका उपयोग कर सकता है।
[अपडेट - बस इस पर ध्यान दिया, और कोड यहां कोड के एक विस्तारित संस्करण की तरह दिखता है: https://blogs.msdn.microsoft.com/stuartleeks/2010/05/21/asp-net-mvc-creating-a- dropdownlist-helper-for-enums / , कुछ जोड़ के साथ। यदि ऐसा है, तो एट्रिब्यूशन उचित प्रतीत होगा ;-)]
System.Web.Mvc.Htmlतो यह कहता है कि DropDownListForइसे नहीं पाया जा सकता है, लेकिन न तो इसे हल कर सकते हैं। आपको मैन्युअल रूप से करना होगा using System.Web.Mvc.Html;। बस इतना y'know।
में ASP.NET MVC 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 बनाने के लिए अंतर्निहित Html.DropDownList()फ़ंक्शन की तुलना में कम लचीलेपन का मतलब है ।
C # 3 आदि को चालू करता है और यह बहुत आसान बनाता है। मेरे पास एक enumकॉल है 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 बनाता है। कोई अपराध नहीं, ऐश। :)
select new { ID = (int)s, Name = s.ToString() };
यहाँ एक बेहतर समझाया समाधान है:
https://www.spicelogic.com/Blog/enum-dropdownlistfor-asp-net-mvc-5
यहाँ कहो कि आपका मॉडल है:
नमूना उपयोग:
जनरेट किया गया UI:
और HTML उत्पन्न की
हेल्पर एक्सटेंशन सोर्स कोड स्नैप शॉट:
आप मेरे द्वारा दिए गए लिंक से नमूना परियोजना डाउनलोड कर सकते हैं।
संपादित करें: यहाँ कोड है:
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 की आवश्यकता होती है, इसलिए Prise के समाधान का एक विकल्प इस प्रकार है। यह आपको बस लिखने की अनुमति देगा:
@Html.DropDownListFor(m => m.SelectedItemType, Model.SelectedItemType.ToSelectList())[जहाँ SelectItemType आपके आइटम प्रकार के मॉडल पर एक फ़ील्ड है, और आपका मॉडल गैर-शून्य है]
इसके अलावा, आपको वास्तव में एक्सटेंशन विधि को जेनेरिक करने की आवश्यकता नहीं है क्योंकि आप टाइपो (टी) के बजाय enumValue.GetType () का उपयोग कर सकते हैं।
संपादित करें: एकीकृत साइमन समाधान यहाँ भी, और 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();
}
}तो बिना विस्तार कार्यों के यदि आप सरल और आसान की तलाश में हैं .. तो यही मैंने किया
<%= Html.DropDownListFor(x => x.CurrentAddress.State, new SelectList(Enum.GetValues(typeof(XXXXX.Sites.YYYY.Models.State))))%>जहां XXXXX.Sites.YYYY.Models.State एक एनम है
शायद हेल्पर फंक्शन करने के लिए बेहतर है, लेकिन जब समय कम होगा तो यह काम पूरा कर देगा।
पुरस्कार और रूण के उत्तरों पर विस्तार करते हुए, यदि आप अपने चयनित सूची आइटम मानचित्र के मूल्य विशेषता को एन्यूमरेशन प्रकार के पूर्णांक मान के बजाय स्ट्रिंग मान के स्थान पर रखना चाहते हैं, तो निम्न कोड का उपयोग करें:
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);
}प्रत्येक Enumeration value को TEnum ऑब्जेक्ट के रूप में मानने के बजाय, हम इसे ऑब्जेक्ट के रूप में मान सकते हैं और फिर इसे अनबॉक्स किए गए मान को प्राप्त करने के लिए पूर्णांक में डाल सकते हैं।
ध्यान दें: मैंने उन प्रकारों को प्रतिबंधित करने के लिए एक सामान्य प्रकार की बाधा भी जोड़ी है जिसके लिए यह विस्तार केवल संरचना (Enum का आधार प्रकार) के लिए उपलब्ध है, और एक रन-टाइम प्रकार सत्यापन है जो सुनिश्चित करता है कि जो संरचना में पारित हुआ है वह वास्तव में एक Enum है।
अद्यतन 10/23/12: अंतर्निहित प्रकार और फिक्स्ड गैर-संकलन मुद्दे के लिए सामान्य प्रकार के पैरामीटर को जोड़ा गया। .NET 4+ को प्रभावित किया।
ToSelectList<TEnum, TEnumValue>(this TEnum enumObj) { ... }
Value = Convert.ToInt32(e)। (int)eसंकलन नहीं है। :(
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);
}eको int।
ID = Convert.ToInt32(e)।
इसे पूरा करने का एक आसान तरीका है - बिना ओवरकिल के लगता है कि सभी एक्सटेंशन सामान यह है:
आपकी दुश्मनी:
public enum SelectedLevel
{
Level1,
Level2,
Level3,
Level4
}अपने नियंत्रक के अंदर Enum को एक सूची में बाँधें:
List<SelectedLevel> myLevels = Enum.GetValues(typeof(SelectedLevel)).Cast<SelectedLevel>().ToList();उसके बाद इसे ViewBag में फेंक दें:
ViewBag.RequiredLevel = new SelectList(myLevels);अंत में बस इसे देखने के लिए बाध्य करें:
@Html.DropDownList("selectedLevel", (SelectList)ViewBag.RequiredLevel, new { @class = "form-control" })यह अब तक मैंने पाया सबसे आसान तरीका है और इसके लिए किसी भी एक्सटेंशन या किसी भी चीज की आवश्यकता नहीं है।
अद्यतन : नीचे एंड्रयूज टिप्पणी देखें।
Level1 = 1, तो "Level1"इसके बजाय ड्रॉपडाउन का मूल्य होगा 1।
इसके लिए मुझे जो सबसे अच्छा समाधान मिला वह था इस ब्लॉग का संयोजन को साइमन गोल्डस्टोन के जवाब के साथ ।
यह मॉडल में एनम के उपयोग की अनुमति देता है। अनिवार्य रूप से विचार एक पूर्णांक संपत्ति के साथ-साथ एनम का उपयोग करना है, और पूर्णांक संपत्ति का अनुकरण करना है।
फिर अपने प्रदर्शन पाठ के साथ मॉडल की व्याख्या करने के लिए [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
@Html.DropDownListFor(model => model.Type, Enum.GetNames(typeof(Rewards.Models.PropertyType)).Select(e => new SelectListItem { Text = e }))यह रुम और पुरस्कार 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पर कॉल करने के लिए उपयोग करते हैं वह चयनित आइटम है।
Id = Convert.ToInt32(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).NET कोर में आप इसका उपयोग कर सकते हैं:
@Html.DropDownListFor(x => x.Foo, Html.GetEnumSelectList<MyEnum>())<select asp-for="Model.Foo" class="form-control" asp-items="@Html.GetEnumSelectList<MyEnum>()"></select>।
अब यह सुविधा MVC 5.1 के माध्यम से आउट-ऑफ-द-बॉक्स समर्थित है @Html.EnumDropDownListFor()
निम्नलिखित लिंक की जाँच करें:
https://docs.microsoft.com/en-us/aspnet/mvc/overview/releases/mvc51-release-notes#Enum
यह वास्तव में शर्म की बात है कि इस तरह की सुविधा को लागू करने में Microsoft को 5 साल लग गए जो कि ऊपर मतदान के अनुसार मांग में है!
साइमन के उत्तर पर निर्माण, एक समान दृष्टिकोण एनम मूल्यों को संसाधन फ़ाइल से प्रदर्शित करने के लिए है, बजाय एनम के भीतर एक विवरण विशेषता के। यदि आपकी साइट को एक से अधिक भाषाओं में प्रस्तुत करने की आवश्यकता है और यदि आपके पास Enums के लिए एक विशिष्ट संसाधन फ़ाइल है, तो आप एक कदम आगे जा सकते हैं और केवल Enum मान रख सकते हैं, यह उपयोगी है, अपने Enum में और उन्हें विस्तार से देखें एक सम्मेलन जैसे [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.EditorFor (x => x.MyProperty) के साथ कॉल करूंगा, या आदर्श रूप से पूरे फॉर्म को एक नीट में " 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))
}यदि यह आपकी रुचि है, तो मैंने अपने ब्लॉग पर यहाँ अधिक विस्तृत उत्तर दिया है:
वैसे मैं वास्तव में पार्टी के लिए देर से आया हूं, लेकिन इसके लायक क्या है, मैंने इस विषय के बारे में ब्लॉग किया है जिससे मैं बना हूं EnumHelper वर्ग बनाता जो बहुत आसान परिवर्तन को सक्षम बनाता है।
http://jnye.co/Posts/4/creating-a-dropdown-list-from-an-enum-in-mvc-and-c%23
आपके नियंत्रक में:
//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);आपके विचार में:
@Html.DropDownList("DropDownList")
@* OR *@
@Html.DropDownListFor(m => m.Property, ViewBag.DropDownList as SelectList, null)सहायक वर्ग:
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() });
}
}मुझे इस पर बहुत देर हो चुकी है, लेकिन मुझे बस कोड की एक पंक्ति के साथ ऐसा करने का एक अच्छा तरीका मिल गया है, अगर आप असंबद्ध मेलोडी को जोड़ने के लिए खुश हैं नुगेट पैकेज (जॉन स्कीट से एक अच्छा, छोटा पुस्तकालय) ।
यह समाधान बेहतर है क्योंकि:
तो, यहाँ इस काम को पाने के लिए कदम हैं:
अपने मॉडल पर एक संपत्ति जोड़ें जैसे:
//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.DropDownListFor का उपयोग कर सकते हैं।
इस एक्सटेंशन पद्धति का एक और निर्धारण - वर्तमान संस्करण ने एनम के वर्तमान मान का चयन नहीं किया। मैंने अंतिम पंक्ति तय की:
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);
}आप Griffin.MvcContrib में मेरे कस्टम HtmlHelpers का भी उपयोग कर सकते हैं। निम्नलिखित कोड:
@Html2.CheckBoxesFor(model => model.InputType) <br />
@Html2.RadioButtonsFor(model => model.InputType) <br />
@Html2.DropdownFor(model => model.InputType) <br />उत्पन्न करता है:
मैं इस सवाल का जवाब एक अलग तरीके से देना चाहूंगा जहां, उपयोगकर्ता को controllerया Linqअभिव्यक्ति में कुछ भी करने की आवश्यकता नहीं है । इस तरफ...
मेरे पास एक 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*/
}अब मैं सैंटो बस dropdownयह का उपयोग करके बना enum।
@Html.DropDownList("accessLevel",new SelectList(AccessLevelEnum.GetValues(typeof(AccessLevelEnum))),new { @class = "form-control" })या
@Html.DropDownListFor(m=>m.accessLevel,new SelectList(AccessLevelEnum.GetValues(typeof(AccessLevelEnum))),new { @class = "form-control" })यदि आप किसी इंडेक्स का चयन करना चाहते हैं तो यह प्रयास करें
@Html.DropDownListFor(m=>m.accessLevel,new SelectList(AccessLevelEnum.GetValues(typeof(AccessLevelEnum)) , AccessLevelEnum.NoAccess ),new { @class = "form-control" })यहां मैंने AccessLevelEnum.NoAccessड्रॉपडाउन का चयन करने के लिए डिफ़ॉल्ट के लिए एक अतिरिक्त पैरामीटर के रूप में उपयोग किया है ।
मुझे यहाँ एक उत्तर मिला । हालाँकि, मेरी कुछ बातों में [Description(...)]विशेषता है, इसलिए मैंने इसके लिए समर्थन प्रदान करने के लिए कोड को संशोधित किया है:
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
);
}उम्मीद है की वो मदद करदे।
@ साइमन गोल्डस्टोन: आपके समाधान के लिए धन्यवाद, यह पूरी तरह से मेरे मामले में लागू किया जा सकता है। एकमात्र समस्या मुझे वीबी में इसका अनुवाद करना है। लेकिन अब यह किया गया है और अन्य लोगों के समय को बचाने के लिए (यदि उन्हें इसकी आवश्यकता है) तो मैं इसे यहां रखूंगा:
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अंत आप इसे इस तरह उपयोग करते हैं:
@Html.EnumDropDownListFor(Function(model) (model.EnumField))मैंने एक्सेप्टन मेथड बनाने का काम किया, जो कि अनिवार्य रूप से यहाँ उत्तर को स्वीकार करने के लिए है। Gist का अंतिम आधा Enum के साथ विशेष रूप से संबंधित है।
@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" }
})