Atributos HTML para EditorFor () no ASP.NET MVC

Por que não posso transmitir atributos html para EditorFor()? por exemplo;

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

Não quero usar metadados

Atualização : a solução foi chamar isso da exibição:

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

e uso ViewData["Modifiable"]em meu EditorTemplates / String.ascx personalizado, onde tenho alguma lógica de exibição que determina se deve adicionar atributos somente leitura e / ou desativados à entrada. O objeto anônimo passado EditorFor()é um parâmetro chamado additionalViewDatae suas propriedades são passadas para o modelo de editor no diretório ViewDatacoleção.

EditorForfunciona com metadados; portanto, se você quiser adicionar atributos html, sempre poderá fazê-lo . Outra opção é simplesmente escrever um modelo personalizado e usar TextBoxFor:

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

A atualização MVC 5.1 agora suporta diretamente a abordagem abaixo, portanto também funciona para o editor incorporado. http://www.asp.net/mvc/overview/releases/mvc51-release-notes#new-features (Ou é um caso de uma grande mente pensando da mesma forma ou eles leem minha resposta :)

Finalizar atualização

Se você estiver usando seu próprio modelo de editor ou com o MVC 5.1, que agora suporta a abordagem abaixo diretamente para editores internos.

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

depois no seu modelo (não é necessário para tipos simples no MVC 5.1)

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

A partir do MVC 5.1, agora você pode fazer o seguinte:

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

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

Agora, o ASP.Net MVC 5.1 recebeu um suporte integrado.

Das notas de versão

Agora, permitimos a passagem de atributos HTML no EditorFor como um objeto anônimo.

Por exemplo:

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

Aqui está a sintaxe do código VB.Net para atributos html no MVC 5.1 Editor

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

Por que não usar apenas

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

Se você não quiser usar os metadados, poderá usar um [UIHint("PeriodType")]atributo para decorar a propriedade ou, se for um tipo complexo, não precisará decorar nada. O EditorFor procurará um arquivo PeriodType.aspx ou ascx na pasta EditorTemplates e o utilizará.

Hoje estou lutando com o mesmo problema em uma caixa de seleção que se liga a um bool anulável e, como não consigo alterar meu modelo (não meu código), tive que criar uma maneira melhor de lidar com isso. É um pouco de força bruta, mas deve funcionar em 99% dos casos que eu possa encontrar. Você obviamente teria que fazer uma população manual de atributos válidos para cada tipo de entrada, mas acho que consegui todos eles para a caixa de seleção.

No meu modelo 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)

Você ainda pode usar o EditorFor. Basta passar o estilo / qualquer atributo html como ViewData.

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

Como o EditorFor usa modelos para renderizar, você pode substituir o modelo padrão para sua propriedade e simplesmente passar o atributo de estilo como ViewData.

Portanto, seu EditorTemplate gostaria do seguinte:

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

você pode usar assim; mesma saída com Html.EditorFor, e você pode adicionar seus atributos html

Basta criar seu próprio modelo para o tipo em 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"})

Chame o editor da sua visualização com a propriedade model:

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

Perdoe a sintaxe do VB. É assim que rolamos.

No meu caso, eu estava tentando criar um modelo de editor de entrada de número HTML5 que pudesse receber atributos adicionais. Uma abordagem mais organizada seria escrever seu próprio HTML Helper, mas como eu já tinha meu modelo .ascx, segui essa abordagem:

<%@ 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 feio cria uma entrada de tipo numérico e procura um dicionário ViewData com a chave "attribute". Ele irá percorrer o dicionário adicionando seus pares chave / valor como atributos. O Regex no atributo ID não está relacionado e existe porque, quando usado em uma coleção, GetFullHtmlFieldId()retorna um ID contendo colchetes[] quais normalmente ele poderia escapar como sublinhados.

Este modelo é chamado assim:

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

Detalhado, mas funciona. Você provavelmente poderia usar a reflexão no modelo para usar nomes de propriedades como nomes de atributos, em vez de usar um dicionário.

Defina a condição usando ViewDatano controlador

ViewData["Modifiable"] = model.recProcessed;

Em seguida, use esses dados de visualização no modelo do editor para definir o atributo html do controle

@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 e uma solução superior (mesclará HtmlAttributes locais e definidos no EditorTemplates):

Shared \ EditorTemplates \ String.cshtml:

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

Extensões:

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