establecer dinámicamente el atributo HTML para discapacitados TextBoxFor HtmlHelper

Question

Estoy tratando de establecer dinámicamente el atributo disabled para la TextBoxFor HtmlHelper

@Html.TextBoxFor(model => model.Street, 
       new 
       { 
        @class = "", 
        disabled = (Model.StageID==(int)MyEnum.Sth) ? "disabled" : "" 
       }) 

pero incluso si hay disabled="" Es lo mismo que disabled="disabled". ¿Cómo evitar esto?

Answer 1

tengo el mismo problema sobre el mes y he terminado con este método de extensión para que

public static class AttributesExtensions 
{ 
    public static RouteValueDictionary DisabledIf(
     this object htmlAttributes, 
     bool disabled 
    ) 
    { 
     var attributes = new RouteValueDictionary(htmlAttributes); 
     if (disabled) 
     { 
      attributes["disabled"] = "disabled"; 
     } 
     return attributes; 
    } 
} 

Y después de que se puede utilizar de esta manera

@Html.TextBoxFor(
    model => model.Street, 
    new { @class = "" }.DisabledIf(Model.StageID==(int)MyEnum.Sth) 
) 

EDITAR (después de Paul 's comment):

El uso de data-xxx atributos html puede extraerse utilizando el constructor de la clase System.Web.Routing.RouteValueDictionary, ya que los guiones bajos no se convertirán automáticamente a signo menos. En su lugar, el método System.Web.Mvc.HtmlHelper.AnonymousObjectToHtmlAttributes resolverá este problema.

código actualizado (sólo cuerpo método de extensión)

var attributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes); 
if (disabled) 
{ 
    attributes["disabled"] = "disabled"; 
} 
return attributes; 

Answer 2

Usando el método de extensión por debajo produce resultados similares, pero esto es tal vez más frágil:

@Html.TextBoxFor(
    model => model.Street, 
    new { @class = "form-control" } 
).DisabledIf(Model.IsReadOnly) 

Extensión:

using System.Text.RegularExpressions; 
using System.Web.Mvc; 

namespace xxx.HtmlHelpers 
{ 
    public static class MvcHtmlStringExtensions 
    { 

     private static readonly Regex OpeningTagPattern; 

     static MvcHtmlStringExtensions() 
     { 
      OpeningTagPattern = new Regex("<[a-zA-Z]*"); 
     } 

     public static MvcHtmlString DisabledIf(this MvcHtmlString controlHtml, bool isDisabled) 
     { 
      if (!isDisabled) return controlHtml; 
      return 
       new MvcHtmlString(OpeningTagPattern.Replace(controlHtml.ToString(), 
        x => string.Format("{0} disabled=\"disabled\"", x.Groups[0]))); 
     } 

    } 
} 

Answer 3

Probablemente su Id de etapa no se está quedando t

@{ 
    if(Model.StageID != null && Model.StageID > 0) 
    { 
     @Html.TextBoxFor(model => model.Street, 
      new 
      { 
       @class = "", 
       disabled = (Model.StageID==(int)MyEnum.Sth) ? "disabled" : "" 
      }) 
    }else{ 

     @Html.TextBoxFor(model => model.Street, 
      new 
      { 
       @class = "" 
      }) 
    } 
} 

Answer 4

En realidad, nos encontramos con el mismo problema. Terminamos implementando un método de extensión con parámetros sobrecargados, que toma un booleano que indica si queremos o no que el control esté deshabilitado. Simplemente agregamos el atributo "deshabilitado" cuando es apropiado, y dejamos que el HtmlHelper incorporado maneje el trabajo pesado.

clase Extensión y método:

using System; 
using System.Collections.Generic; 
using System.Linq.Expressions; 
using System.Web.Mvc; 
using System.Web.Mvc.Html; 
using System.Web.Routing; 
public static class OurHtmlHelpers 
{ 
    public const string DisabledAttribute = "disabled"; 

    public static MvcHtmlString TextBoxFor<TModel, TProp>(this HtmlHelper<TModel> htmlHelper, 
                  Expression<Func<TModel, TProp>> expression, 
                  object htmlAttributes, 
                  bool canEdit) 
    { 
     var htmlAttributeDictionary = SetDisabledAttribute(htmlAttributes, canEdit); 

     return htmlHelper.TextBoxFor(expression, htmlAttributeDictionary); 
    }   

    private static RouteValueDictionary SetDisabledAttribute(object htmlAttributes, bool canEdit) 
    { 
     var htmlAttributeDictionary = new RouteValueDictionary(htmlAttributes); 

     if (!canEdit) 
     { 
      htmlAttributeDictionary.Add(DisabledAttribute, DisabledAttribute); 
     } 

     return htmlAttributeDictionary; 
    } 
} 

A continuación, sólo tiene que hacer referencia a su nueva clase y llamar @Html.TextBoxFor(m => m.SomeValue, new { @class = "someClass" }, <Your bool value>)

Vale la pena señalar que habría que definir estas extensiones para cualquiera de las sobrecargas TextBoxFor te gustaría usar, pero parece una compensación razonable. También puede utilizar la mayoría del mismo código para otros HtmlHelpers a los que le gustaría agregar la funcionalidad.