Atributos HTML para EditorFor () en ASP.NET MVC

¿Por qué no puedo pasar atributos html a EditorFor()? p.ej;

<%= Html.EditorFor(model => model.Control.PeriodType, 
    new { disabled = "disabled", readonly = "readonly" }) %>

No quiero usar metadatos

Actualización : la solución fue llamar a esto desde la vista:

 <%=Html.EditorFor( model => model.Control.PeriodEndDate, new {Modifiable=model.Control.PeriodEndDateModifiable})%>

y usar ViewData["Modifiable"]en mi EditorTemplates / String.ascx personalizado donde tengo cierta lógica de vista que determina si agregar atributos de solo lectura y / o deshabilitados a la entrada El objeto anónimo pasado EditorFor()es un parámetro llamado additionalViewDatay sus propiedades se pasan a la plantilla del editor en el ViewDatacolección.

EditorForfunciona con metadatos, por lo que si desea agregar atributos html, siempre puede hacerlo . Otra opción es simplemente escribir una plantilla personalizada y usar TextBoxFor:

<%= Html.TextBoxFor(model => model.Control.PeriodType, 
    new { disabled = "disabled", @readonly = "readonly" }) %>    

La actualización MVC 5.1 ahora admite directamente el siguiente enfoque, por lo que también funciona para el editor incorporado. http://www.asp.net/mvc/overview/releases/mvc51-release-notes#new-features (Es un caso de Gran pensamiento mental por igual o leen mi respuesta :)

Fin de actualización

Si está utilizando su propia plantilla de editor o con MVC 5.1, que ahora admite el siguiente enfoque directamente para editores integrados.

@Html.EditorFor(modelItem => item.YourProperty, 
  new { htmlAttributes = new { @class="verificationStatusSelect", style = "Width:50px"  } })

luego en su plantilla (no se requiere para tipos simples en MVC 5.1)

@Html.TextBoxFor(m => m, ViewData["htmlAttributes"])

A partir de MVC 5.1, ahora puede hacer lo siguiente:

@Html.EditorFor(model => model, new { htmlAttributes = new { @class = "form-control" }, })

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

Ahora ASP.Net MVC 5.1 tiene un soporte integrado para ello.

De las notas de la versión

Ahora permitimos pasar atributos HTML en EditorFor como un objeto anónimo.

Por ejemplo:

@Html.EditorFor(model => model, 
              new { htmlAttributes = new { @class = "form-control" }, })

Aquí está la sintaxis del código VB.Net para atributos html en MVC 5.1 EditorFor

@Html.EditorFor(Function(x) x.myStringProp, New With {.htmlAttributes = New With {.class = "myCssClass", .maxlength="30"}}))

¿Por qué no solo usar

@Html.DisplayFor(model => model.Control.PeriodType)

Si no desea usar Metadatos, puede usar un [UIHint("PeriodType")]atributo para decorar la propiedad o si es un tipo complejo, no tiene que decorar nada. EditorFor buscará un archivo PeriodType.aspx o ascx en la carpeta EditorTemplates y lo usará en su lugar.

He estado luchando con el mismo problema hoy por una casilla de verificación que se une a un bool anulable, y como no puedo cambiar mi modelo (no mi código) tuve que encontrar una mejor manera de manejar esto. Es un poco fuerza bruta, pero debería funcionar en el 99% de los casos que pueda encontrar. Obviamente, tendría que hacer una población manual de atributos válidos para cada tipo de entrada, pero creo que los obtuve todos para la casilla de verificación.

En mi plantilla de editor Boolean.cshtml:

@model bool?

@{
    var attribs = new Dictionary<string, object>();
    var validAttribs = new string[] {"style", "class", "checked", "@class",
        "classname","id", "required", "value", "disabled", "readonly", 
        "accesskey", "lang", "tabindex", "title", "onblur", "onfocus", 
        "onclick", "onchange", "ondblclick", "onmousedown", "onmousemove", 
        "onmouseout", "onmouseover", "onmouseup", "onselect"};
    foreach (var item in ViewData) 
    {
        if (item.Key.ToLower().IndexOf("data_") == 0 || item.Key.ToLower().IndexOf("aria_") == 0) 
        {
            attribs.Add(item.Key.Replace('_', '-'), item.Value);
        } 
        else 
        {
            if (validAttribs.Contains(item.Key.ToLower()))
            {
                attribs.Add(item.Key, item.Value);
            }
        }
    }
}

@Html.CheckBox("", Model.GetValueOrDefault(), attribs)

Todavía puedes usar EditorFor. Simplemente pase el estilo / cualquier atributo html como ViewData.

@Html.EditorFor(model => model.YourProperty, new { style = "Width:50px" })

Debido a que EditorFor usa plantillas para renderizar, puede anular la plantilla predeterminada para su propiedad y simplemente pasar el atributo de estilo como ViewData.

Entonces su EditorTemplate desea lo siguiente:

@inherits System.Web.Mvc.WebViewPage<object>

@Html.TextBoxFor(m => m, new { @class = "text ui-widget-content", style=ViewData["style"] })

Html.TextBoxFor(model => model.Control.PeriodType, 
    new { @class="text-box single-line"})

puedes usar así; mismo resultado con Html.EditorFor, y puede agregar sus atributos html

Simplemente cree su propia plantilla para el tipo en Views / Shared / EditorTemplates / MyTypeEditor.vbhtml

@ModelType MyType

@ModelType MyType
@Code
    Dim name As String = ViewData("ControlId")
    If String.IsNullOrEmpty(name) Then
        name = "MyTypeEditor"
    End If
End Code

' Mark-up for MyType Editor
@Html.TextBox(name, Model, New With {.style = "width:65px;background-color:yellow"})

Invoque el editor desde su vista con la propiedad modelo:

@Html.EditorFor(Function(m) m.MyTypeProperty, "MyTypeEditor", New {.ControlId = "uniqueId"})

Perdón por la sintaxis de VB. Así es como rodamos.

En mi caso, estaba tratando de crear una plantilla de editor de entrada de número HTML5 que pudiera recibir atributos adicionales. Un enfoque más ordenado sería escribir su propio HTML Helper, pero como ya tenía mi plantilla .ascx, seguí este enfoque:

<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<input id="<%= Regex.Replace(ViewData.TemplateInfo.GetFullHtmlFieldId(""), @"[\[\]]", "_") %>" name="<%= ViewData.TemplateInfo.HtmlFieldPrefix %>" type="number" value="<%= ViewData.TemplateInfo.FormattedModelValue %>"
<% if (ViewData["attributes"] != null)
   {
       Dictionary<string, string> attributes = (Dictionary<string, string>)ViewData["attributes"];
       foreach (string attributeName in attributes.Keys){%>
        <%= String.Format(" {0}=\"{1}\"", attributeName, attributes[attributeName])%>
       <% }
   } %> />

Este bit feo crea una entrada de tipo de número y busca un Diccionario ViewData con la clave "atributos". Recorrerá iterativamente el diccionario agregando sus pares clave / valor como atributos. La expresión regular en el atributo ID no está relacionada y está allí porque cuando se usa en una colección, GetFullHtmlFieldId()devuelve una identificación que contiene corchetes de la []que normalmente se escaparía como guiones bajos.

Esta plantilla se llama así:

Html.EditorFor(m => m.Quantity, "NumberField", new { attributes = new Dictionary<string, string>() { { "class", "txtQuantity" } } }

Detallado, pero funciona. Probablemente podría usar la reflexión en la plantilla para usar nombres de propiedades como nombres de atributos en lugar de usar un diccionario.

Establezca la condición usando ViewDataen el controlador

ViewData["Modifiable"] = model.recProcessed;

Luego, use estos datos de vista en la plantilla del editor para establecer el atributo html del control

@Html.RadioButton(prefix, li.Value, li.Selected, @ViewData["Modifiable"].ToString().ToLower() == "true" ? (object)new  { @id = li.Value, @disabled = "disabled" } : new { @id = li.Value })

MVC 5.1 y una solución superior (fusionará los atributos HtmlAttributes locales y se definirán en las plantillas del editor):

Shared \ EditorTemplates \ String.cshtml:

@Html.TextBoxFor(model => model, new { @class = "form-control", placeholder = ViewData.ModelMetadata.Watermark }.ToExpando().MergeHtmlAttributes(ViewData["htmlAttributes"].ToExpando()))

Extensiones:

public static IDictionary<string, object> MergeHtmlAttributes(this ExpandoObject source1, dynamic source2)
{
    Condition.Requires(source1, "source1").IsNotNull().IsLongerThan(0);

    IDictionary<string, object> result = source2 == null
        ? new Dictionary<string, object>()
        : (IDictionary<string, object>) source2;

    var dictionary1 = (IDictionary<string, object>) source1;

    string[] commonKeys = result.Keys.Where(dictionary1.ContainsKey).ToArray();
    foreach (var key in commonKeys)
    {
        result[key] = string.Format("{0} {1}", dictionary1[key], result[key]);
    }

    foreach (var item in dictionary1.Where(pair => !result.ContainsKey(pair.Key)))
    {
        result.Add(item);
    }

    return result;
}

public static ExpandoObject ToExpando(this object anonymousObject)
{
    IDictionary<string, object> anonymousDictionary = new RouteValueDictionary(anonymousObject);
    IDictionary<string, object> expando = new ExpandoObject();
    foreach (var item in anonymousDictionary)
        expando.Add(item);
    return (ExpandoObject)expando;
}

public static bool HasProperty(this ExpandoObject expando, string key)
{
    return ((IDictionary<string, object>)expando).ContainsKey(key);
}

Uso:

@Html.EditorFor(m => m.PromotionalCode, new { htmlAttributes = new { ng_model = "roomCtrl.searchRoomModel().promoCode" }})