c# एमवीसी 5.1 EnumDropDownListFor से मूल्य निकालें/निकालें




asp.net-mvc razor (4)

आप एक ड्रॉप डाउन सूची बना सकते हैं:

@{ // you can put the following in a back-end method and pass through ViewBag
   var selectList = Enum.GetValues(typeof(UserStatus))
                        .Cast<UserStatus>()
                        .Where(e => e != UserStatus.Pending)
                        .Select(e => new SelectListItem 
                            { 
                                Value = ((int)e).ToString(),
                                Text = e.ToString()
                            });
}
@Html.DropDownListFor(m => m.Status, selectList)

मेरे पास एनम्स की एक सूची है जिसका उपयोग मैं उपयोगकर्ता प्रबंधन पृष्ठ के लिए कर रहा हूं। मैं एमवीसी 5.1 में नया एचटीएमएलहेल्पर का उपयोग कर रहा हूं जो मुझे एनम वैल्यू के लिए ड्रॉपडाउन सूची बनाने की अनुमति देता है। अब मुझे सूची से लंबित मूल्य को हटाने की आवश्यकता है, यह मान केवल प्रोग्रामेटिक रूप से सेट किया जाएगा और इसे उपयोगकर्ता द्वारा कभी भी सेट नहीं किया जाना चाहिए।

enum:

public enum UserStatus
{
    Pending = 0,
    Limited = 1,
    Active = 2
}

राय:

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

क्या वैसे भी है, या तो मौजूदा नियंत्रण को ओवरराइड करना, या कस्टम एचटीएमएलहेल्पर लिखना जो मुझे परिणामस्वरूप सूची से बाहर निकलने के लिए एक enum, या enums निर्दिष्ट करने की अनुमति देगा? या आप सुझाव देंगे कि मैं उत्पन्न होने के बाद ड्रॉपडाउन सूची से मूल्य को हटाने के लिए jQuery के साथ कुछ क्लाइंट पक्ष करता हूं?

धन्यवाद!


आप enum में मानों के माध्यम से looping द्वारा ड्रॉपडाउन स्वयं बना सकते हैं और केवल <option> अगर यह लंबित नहीं है।

यहां बताया गया है कि इसे कैसे काम करना चाहिए, लेकिन जैसा कि आप देख सकते हैं, मुझे यकीन नहीं है कि आप विकल्प टैग के मूल्य या पाठ के लिए क्या उपयोग करेंगे।

<select>
foreach (var status in Enum.GetValues(typeof(UserStatus)))
{
    if(status != UserStatus.Pending)
    {
        <option value="status.???">@status.???</option>
    }
}
</select>

@ Dav_i के उत्तर से संशोधित।

यह सही नहीं है, लेकिन मैं इसका उपयोग कर रहा हूं। नीचे HtmlHelper विस्तार है। एक्सटेंशन विधि EnumDropDownListFor .NET से EnumDropDownListFor तरह EnumDropDownListFor , और Enum मान पर लागू होने पर DisplayAttribute उपयोग करें।

/// <summary>
/// Returns an HTML select element for each value in the enumeration that is
/// represented by the specified expression and predicate.
/// </summary>
/// <typeparam name="TModel">The type of the model.</typeparam>
/// <typeparam name="TEnum">The type of the value.</typeparam>
/// <param name="htmlHelper">The HTML helper instance that this method extends.</param>
/// <param name="expression">An expression that identifies the object that contains the properties to display.</param>
/// <param name="optionLabel">The text for a default empty item. This parameter can be null.</param>
/// <param name="predicate">A <see cref="Func{TEnum, bool}"/> to filter the items in the enums.</param>
/// <param name="htmlAttributes">An object that contains the HTML attributes to set for the element.</param>
/// <returns>An HTML select element for each value in the enumeration that is represented by the expression and the predicate.</returns>
/// <exception cref="ArgumentNullException">If expression is null.</exception>
/// <exception cref="ArgumentException">If TEnum is not Enum Type.</exception>
public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression, Func<TEnum, bool> predicate, string optionLabel, object htmlAttributes) where TEnum : struct, IConvertible
{
    if (expression == null)
    {
        throw new ArgumentNullException("expression");
    }

    if (!typeof(TEnum).IsEnum)
    {
        throw new ArgumentException("TEnum");
    }

    ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
    IList<SelectListItem> selectList = Enum.GetValues(typeof(TEnum))
            .Cast<TEnum>()
            .Where(e => predicate(e))
            .Select(e => new SelectListItem
                {
                    Value = Convert.ToUInt64(e).ToString(),
                    Text = ((Enum)(object)e).GetDisplayName(),
                }).ToList();
    if (!string.IsNullOrEmpty(optionLabel)) {
        selectList.Insert(0, new SelectListItem {
            Text = optionLabel,
        });
    }

    return htmlHelper.DropDownListFor(expression, selectList, htmlAttributes);
}

/// <summary>
/// Gets the name in <see cref="DisplayAttribute"/> of the Enum.
/// </summary>
/// <param name="enumeration">A <see cref="Enum"/> that the method is extended to.</param>
/// <returns>A name string in the <see cref="DisplayAttribute"/> of the Enum.</returns>
public static string GetDisplayName(this Enum enumeration)
{
    Type enumType = enumeration.GetType();
    string enumName = Enum.GetName(enumType, enumeration);
    string displayName = enumName;
    try
    {
        MemberInfo member = enumType.GetMember(enumName)[0];

        object[] attributes = member.GetCustomAttributes(typeof(DisplayAttribute), false);
        DisplayAttribute attribute = (DisplayAttribute)attributes[0];
        displayName = attribute.Name;

        if (attribute.ResourceType != null)
    {
            displayName = attribute.GetName();
        }
    }
    catch { }
    return displayName;
}

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

@Html.EnumDropDownListFor(
    model => model.UserStatus,
    (userStatus) => { return userStatus != UserStatus.Active; },
    null,
    htmlAttributes: new { @class = "form-control" });

यह सक्रिय के विकल्प के बिना एक एनम ड्रॉपडाउन सूची बनाएगा।


नीचे HtmlHelper का विस्तार है। यह ASP.NET से EnumDropDownListFor एक्सटेंशन के समान है, लेकिन यह आइटम डिस्प्ले नाम द्वारा SelectListItem को टाइप करता है। इसका एक सुझावपूर्ण नाम है: मूल एक्सटेंशन के साथ संघर्ष के लिए सॉर्टेडएनमड्रॉपडाउन लिस्टफ़ोर।

    /// <summary>
    /// 
    /// </summary>
    /// <typeparam name="TModel">The type of the model.</typeparam>
    /// <typeparam name="TEnum">The type of the value.</typeparam>
    /// <param name="htmlHelper">The HTML helper instance that this method extends.</param>
    /// <param name="expression">An expression that identifies the object that contains the properties to display</param>
    /// <param name="initalValue">The unselected item initial value</param>
    /// <param name="htmlAttributes"></param>
    /// <returns></returns>
    public static MvcHtmlString SortedEnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression, string initalValue, object htmlAttributes = null)
    {

        ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

        Type enumType = GetNonNullableModelType(metadata);
        Type baseEnumType = Enum.GetUnderlyingType(enumType);
        List<SelectListItem> items = new List<SelectListItem>();

        foreach (FieldInfo field in enumType.GetFields(BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public))
        {
            string text = field.Name;
            string value = Convert.ChangeType(field.GetValue(null), baseEnumType).ToString();
            bool selected = field.GetValue(null).Equals(metadata.Model);

            foreach (DisplayAttribute displayAttribute in field.GetCustomAttributes(true).OfType<DisplayAttribute>())
            {
                text = displayAttribute.GetName();
            }

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

        items = new List<SelectListItem>(items.OrderBy(s => s.Text));
        items.Insert(0, new SelectListItem { Text = initalValue, Value = "" });

        return htmlHelper.DropDownListFor(expression, items, htmlAttributes);

    }        

    private static Type GetNonNullableModelType(ModelMetadata modelMetadata)
    {
        Type realModelType = modelMetadata.ModelType;
        Type underlyingType = Nullable.GetUnderlyingType(realModelType);

        if (underlyingType != null)
        {
            realModelType = underlyingType;
        }

        return realModelType;
    }

यदि आप अचयनित आइटम इंटिटिया से परेशान नहीं होना चाहते हैं, तो बस इस तरह एक ओवरलोड बनाएं:

public static MvcHtmlString SortedEnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TEnum>> expression, object htmlAttributes = null)
        {
            MvcHtmlString helper = SortedEnumDropDownListFor(htmlHelper, expression, string.Empty, htmlAttributes);
            return helper;
        }

और आप जाने के लिए अच्छे हैं। मुझे उम्मीद है यह मदद करेगा।







html-helper