asp.net-mvc - tools - microsoft asp.net mvc 4

Establecer el atributo de deshabilitar basado en una condición para Html.TextBoxFor

Question

Quiero establecer el atributo de deshabilitar en función de una condición para Html.TextBoxFor en asp.net MVC como a continuación

@Html.TextBoxFor(model => model.ExpireDate, new { style = "width: 70px;", maxlength = "10", id = "expire-date" disabled = (Model.ExpireDate == null ? "disable" : "") })

Este ayudante tiene dos salidas deshabilitadas = "deshabilitada" o deshabilitada = "". ambos temas hacen que el cuadro de texto se deshabilite.

Quiero deshabilitar el cuadro de texto si Model.ExpireDate == null else Quiero habilitarlo

Answer 1

En realidad, el comportamiento interno es traducir el objeto anónimo a un diccionario. Entonces, lo que hago en estos escenarios es buscar un diccionario:

@{
  var htmlAttributes = new Dictionary<string, object>
  {
    { "class" , "form-control"},
    { "placeholder", "Why?" }        
  };
  if (Model.IsDisabled)
  {
    htmlAttributes.Add("disabled", "disabled");
  }
}
@Html.EditorFor(m => m.Description, new { htmlAttributes = htmlAttributes })

O, como Stephen comentó here :

@Html.EditorFor(m => m.Description,
    Model.IsDisabled ? (object)new { disabled = "disabled" } : (object)new { })

Answer 2

Esto es tarde, pero puede ser útil para algunas personas.

He extendido la respuesta de @ DarinDimitrov para permitir pasar un segundo objeto que toma cualquier número de atributos html booleanos como disabled="disabled" checked="checked", selected="selected" etc.

Rendirá el atributo solo si el valor de la propiedad es verdadero, cualquier otra cosa y el atributo no se representará en absoluto.

El HtmlHelper reutilizable personalizado:

public static class HtmlExtensions
{
    public static IHtmlString MyTextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper,
                                                                Expression<Func<TModel, TProperty>> expression,
                                                                object htmlAttributes,
                                                                object booleanHtmlAttributes)
    {
        var attributes = new RouteValueDictionary(htmlAttributes);

        //Reflect over the properties of the newly added booleanHtmlAttributes object
        foreach (var prop in booleanHtmlAttributes.GetType().GetProperties())
        {
            //Find only the properties that are true and inject into the main attributes.
            //and discard the rest.
            if (ValueIsTrue(prop.GetValue(booleanHtmlAttributes, null)))
            {
                attributes[prop.Name] = prop.Name;
            }                
        }                                

        return htmlHelper.TextBoxFor(expression, attributes);
    }

    private static bool ValueIsTrue(object obj)
    {
        bool res = false;
        try
        {
            res = Convert.ToBoolean(obj);
        }
        catch (FormatException)
        {
            res = false;
        }
        catch(InvalidCastException)
        {
            res = false;
        }
        return res;
    }

}

Que puedes usar así:

@Html.MyTextBoxFor(m => Model.Employee.Name
                   , new { @class = "x-large" , placeholder = "Type something…" }
                   , new { disabled = true})

Answer 3

La forma válida es:

disabled="disabled"

Los navegadores también pueden aceptar disabled="" pero les recomendaría el primer acercamiento.

Ahora dicho esto, recomendaría que escribieras un asistente de HTML personalizado para encapsular esta funcionalidad de deshabilitación en una pieza de código reutilizable:

using System;
using System.Linq.Expressions;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Web.Routing;

public static class HtmlExtensions
{
    public static IHtmlString MyTextBoxFor<TModel, TProperty>(
        this HtmlHelper<TModel> htmlHelper, 
        Expression<Func<TModel, TProperty>> expression, 
        object htmlAttributes, 
        bool disabled
    )
    {
        var attributes = new RouteValueDictionary(htmlAttributes);
        if (disabled)
        {
            attributes["disabled"] = "disabled";
        }
        return htmlHelper.TextBoxFor(expression, attributes);
    }
}

que puedes usar así:

@Html.MyTextBoxFor(
    model => model.ExpireDate, 
    new { 
        style = "width: 70px;", 
        maxlength = "10", 
        id = "expire-date" 
    }, 
    Model.ExpireDate == null
)

y podrías aportar aún más inteligencia a este ayudante:

public static class HtmlExtensions
{
    public static IHtmlString MyTextBoxFor<TModel, TProperty>(
        this HtmlHelper<TModel> htmlHelper,
        Expression<Func<TModel, TProperty>> expression,
        object htmlAttributes
    )
    {
        var attributes = new RouteValueDictionary(htmlAttributes);
        var metaData = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
        if (metaData.Model == null)
        {
            attributes["disabled"] = "disabled";
        }
        return htmlHelper.TextBoxFor(expression, attributes);
    }
}

de modo que ahora ya no es necesario especificar la condición deshabilitada:

@Html.MyTextBoxFor(
    model => model.ExpireDate, 
    new { 
        style = "width: 70px;", 
        maxlength = "10", 
        id = "expire-date" 
    }
)

Answer 4

Lo logré usando algunos métodos de extensión

public static MvcHtmlString IsDisabled(this MvcHtmlString htmlString, bool disabled)
{
    string rawstring = htmlString.ToString();
    if (disabled)
    {
        rawstring = rawstring.Insert(rawstring.Length - 2, "disabled=/"disabled/"");
    }
    return new MvcHtmlString(rawstring);
}

public static MvcHtmlString IsReadonly(this MvcHtmlString htmlString, bool @readonly)
{
    string rawstring = htmlString.ToString();
    if (@readonly)
    {
        rawstring = rawstring.Insert(rawstring.Length - 2, "readonly=/"readonly/"");
    }
    return new MvcHtmlString(rawstring);
}

y entonces....

@Html.TextBoxFor(model => model.Name, new { @class= "someclass"}).IsDisabled(Model.ExpireDate == null)

Answer 5

Me gusta el método Darin. Pero una manera rápida de resolver esto,

Html.TextBox("Expiry", null, new { style = "width: 70px;", maxlength = "10", id = "expire-date", disabled = "disabled" }).ToString().Replace("disabled=/"disabled/"", (1 == 2 ? "" : "disabled=/"disabled/""))

Answer 6

Otra solución más sería crear un Dictionary<string, object> antes de llamar a TextBoxFor y pasar ese diccionario. En el diccionario, agregue la tecla "disabled" solo si el cuadro de texto debe ser diableado. No es la solución más sencilla, sino simple y directa.

Answer 7

Otro enfoque es desactivar el cuadro de texto en el lado del cliente.

En su caso, solo tiene un cuadro de texto que debe desactivar, pero considere el caso en el que tiene múltiples campos de entrada, selección y área de texto que debe deshabilitar.

Es mucho más fácil hacerlo a través de jquery + (ya que no podemos confiar en los datos que provienen del cliente) agregue algo de lógica al controlador para evitar que estos campos se guarden.

Aquí hay un ejemplo:

<input id="document_Status" name="document.Status" type="hidden" value="2" />

$(document).ready(function () {

    disableAll();
}

function disableAll() {
  var status = $(''#document_Status'').val();

  if (status != 0) {
      $("input").attr(''disabled'', true);
      $("textarea").attr(''disabled'', true);
      $("select").attr(''disabled'', true);
  }
}

Answer 8

Se resuelve esto usando RouteValueDictionary (funciona bien como htmlAttributes ya que está basado en IDictionary) y un método de extensión:

public static RouteValueDictionary AddIf(this RouteValueDictionary dict, bool condition, string name, object value)
{
    if (condition) dict.Add(name, value);
    return dict;
}

Uso:

@Html.TextBoxFor(m => m.GovId, new RouteValueDictionary(new { @class = "form-control" })
.AddIf(Model.IsEntityFieldsLocked, "disabled", "disabled"))

El crédito va a https://.com/a/3481969/40939

Answer 9

Si no usas helpers html, puedes usar una expresión ternaria simple como esta:

<input name="Field"
       value="@Model.Field" tabindex="0"
       @(Model.IsDisabledField ? "disabled=/"disabled/"" : "")>

Answer 10

Un enfoque simple que he usado es la representación condicional:

@(Model.ExpireDate == null ? 
  @Html.TextBoxFor(m => m.ExpireDate, new { @disabled = "disabled" }) : 
  @Html.TextBoxFor(m => m.ExpireDate)
)

Answer 11

si no quieres usar Html Helpers mira mi solución

disabled="@(your Expression that returns true or false")"

que

@{
    bool isManager = (Session["User"] as User).IsManager;
}
<textarea rows="4" name="LetterManagerNotes" disabled="@(!isManager)"></textarea>

y creo que la mejor manera de hacerlo es hacer esa comprobación en el controlador y guardarla dentro de una variable a la que se puede acceder desde la vista (motor Razor) para the view free from business logic