Html.DropDownList - Deaktiviert / schreibgeschützt

Welche Option muss ich festlegen, damit ein Dropdown-Feld schreibgeschützt ist, wenn MVCs Html.DropDownList verwendet wird?

Ich habe Dinge ausprobiert wie ...

Html.DropDownList("Types", Model.Types, new { _Enabled = "false" })

... und viele verschiedene Dinge in dieser Richtung; leider keine freude!

Ich dachte, das wäre einfach ..... und das ist es wahrscheinlich!

Versuche dies

Html.DropDownList("Types", Model.Types, new { @disabled = "disabled" })

Zum Fang 22:

Wenn wir verwenden @disabled, wird das Feld nicht an die Aktion (Mamoud) gesendet. Wenn wir es verwenden @readonly, können Sie den Wert mit dem Dropdown-Fehler weiterhin ändern

Problemumgehung: Verwenden @disabledSie das nach dem Dropdown- Menü ausgeblendete Feld und fügen Sie es hinzu:

@Html.HiddenFor(model => model.xxxxxxxx)

Dann ist es wirklich deaktiviert und wird auch an die Aktion gesendet.

<script type="text/javascript">
$(function () {
        $(document) .ajaxStart(function () {
                $("#dropdownID").attr("disabled", "disabled");
            })
            .ajaxStop(function () {
                $("#dropdownID").removeAttr("disabled");

            });

});
</script>

Ich musste die Dropdown-Liste deaktivieren und die primäre ID ausblenden

<div class="form-group">
        @Html.LabelFor(model => model.OBJ_ID, "Objs", htmlAttributes: new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.DropDownList("OBJ_ID", null, htmlAttributes: new { @class = "form-control", @disabled = "disabled"})
            @Html.HiddenFor(m => m.OBJ_ID)
            @Html.ValidationMessageFor(model => model.OBJ_ID, "", new { @class = "text-danger" })
        </div>
    </div>

Ein Tipp, der für einige offensichtlich sein kann, für andere jedoch nicht.

Wenn Sie den HTML-Helper basierend auf verwenden, DropDownListForwird Ihre ID in der HiddenForEingabe dupliziert . Daher werden Sie doppelte IDs haben , die in HTML ungültig ist und wenn Sie Javascript verwenden die füllen HiddenForund DropDownListdann werden Sie ein Problem haben.

Die Lösung besteht darin, die ID-Eigenschaft im Array htmlattributes manuell festzulegen ...

@Html.HiddenFor(model => model.Entity)

@Html.EnumDropDownListFor(
  model => model.Entity, 
  new { 
         @class = "form-control sharp", 
         onchange = "", 
         id =` "EntityDD", 
         disabled = "disabled" 
       }
)

Oder Sie können so etwas ausprobieren:

Html.DropDownList("Types", Model.Types, new { @readonly = "true" })

Setzen Sie dies mit Stil

 select[readonly] option, select[readonly] optgroup {
        display: none;
    }

Ich mache das einfach und nenne es einen Tag

Model.Id > -1 ? Html.EnumDropDownListFor(m => m.Property, new { disabled = "disabled" }) : Html.EnumDropDownListFor(m => m.Property)

@Html.DropDownList("Types", Model.Types, new { @disabled = "" })

Funktioniert

Html.DropDownList ("Types", Model.Types, new {@disabled = "disabled"}) @ Html.Hidden (Model.Types) und verwenden Sie zum Speichern und Wiederherstellen der Daten ein verstecktes Steuerelement

Der Vollständigkeit halber finden Sie hier den HTML-Helper für DropDownListFor, der aktivierte Parameter hinzufügt, wenn die falsche Auswahl deaktiviert ist. Es hält HTML-Attribute im Markup definiert oder ermöglicht die Verwendung von HTML-Attributen im Markup, sendet ausgewählte Werte an den Server und die Verwendung ist sehr sauber und einfach.

Hier ist der Code für den Helfer:

public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> html, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, object htmlAttributes, bool enabled)
{
  if (enabled)
  {
    return SelectExtensions.DropDownListFor<TModel, TProperty>(html, expression, selectList, htmlAttributes);
  }

  var htmlAttributesAsDict = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
  htmlAttributesAsDict.Add("disabled", "disabled");
  string selectClientId = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldId(ExpressionHelper.GetExpressionText(expression));
  htmlAttributesAsDict.Add("id", selectClientId + "_disabled");

  var hiddenFieldMarkup = html.HiddenFor<TModel, TProperty>(expression);
  var selectMarkup = SelectExtensions.DropDownListFor<TModel, TProperty>(html, expression, selectList, htmlAttributesAsDict);
  return MvcHtmlString.Create(selectMarkup.ToString() + Environment.NewLine + hiddenFieldMarkup.ToString());
}

Ziel ist es, die Auswahl zu deaktivieren, wenn nur ein Element in den Optionen enthalten ist. Markup:

@Html.DropDownListFor(m => m.SomeValue, Model.SomeList, new { @class = "some-class" }, Model.SomeList > 1)

Und es gibt ein noch eleganteres Beispiel für einen HTML-Helfer, für den es derzeit keine Post-Unterstützung gibt (ziemlich unkomplizierter Job, verwenden Sie einfach HAP und fügen Sie versteckte Eingaben als Geschwister für Stammelemente und Swap-IDs hinzu):

public static MvcHtmlString Disable(this MvcHtmlString previous, bool disabled, bool disableChildren = false)
{
  if (disabled)
  {
    var canBeDisabled = new HashSet<string> { "button", "command", "fieldset", "input", "keygen", "optgroup", "option", "select", "textarea" };
    var doc = new HtmlDocument();
    doc.LoadHtml(previous.ToString());
    var rootElements = doc.DocumentNode.Descendants().Where(
      hn => hn.NodeType == HtmlNodeType.Element && 
      canBeDisabled.Contains(hn.Name.ToLower()) && 
      (disableChildren || hn.ParentNode.NodeType == HtmlNodeType.Document));

    foreach (var element in rootElements)
    {
      element.SetAttributeValue("disabled", "");
    }
    string html = doc.DocumentNode.OuterHtml;
    return MvcHtmlString.Create(html);
  }
  return previous;
}

Zum Beispiel gibt es eine Modelleigenschaft bool AllInputsDisabled, wenn true, sollten alle HTML-Eingaben deaktiviert werden:

@Html.TextBoxFor(m => m.Address, new { placeholder = "Enter address" }).Disable(Model.AllInputsDisabled)

@Html.DropDownListFor(m => m.DoYou, Model.YesNoList).Disable(Model.AllInputsDisabled)

Sie könnten diesen Ansatz verwenden

Deaktivieren aller Optionen außer der ausgewählten:

<select>
    <option disabled>1</option>
    <option disabled>2</option>
    <option selected>3</option>
</select>

Auf diese Weise wird das Dropdown-Menü weiterhin gesendet, der Benutzer kann jedoch keinen anderen Wert auswählen.

Mit jQuery

<script>
    $(document).ready(function () {
        $('#yourSelectId option:not(:selected)').prop("disabled", true);
    });
</script>

Versuchen Sie es mit @disabled und jquery. Auf diese Weise können Sie den Wert auf dem Controller abrufen.

Html.DropDownList("Types", Model.Types, new {@class = "your_class disabled", @disabled= "disabled" })

Fügen Sie eine Klasse mit dem Namen "disabled" hinzu, damit Sie sie aktivieren können, indem Sie diese Klasse durchsuchen (bei mehreren deaktivierten Feldern). Anschließend können Sie ein "setTimeout" verwenden, wenn Sie den Controller nicht über Validierungsattribute eingeben

<script>

  function clickSubmit() {
    $("select.disabled").attr("disabled", false);
    setTimeout(function () {
        $("select.disabled").attr("disabled", true);
    }, 500);
  }
</script>

Senden Sie den Button so.

 <button type="submit" value="Submit" onclick="clickSubmit();">Save</button>

Verwenden Sie bei Eingaben einfach @ readonly = "readonly"

@Html.TextBoxFor("Types",Model.Types, new { @class = "form-control", @readonly= "readonly" })

Ich habe diese Antwort erstellt, nachdem ich vor allem auf Kommentare und Antworten verwiesen habe. Dadurch wird der Dropdown-Populationsfehler behoben, auch wenn er deaktiviert wird.

Schritt 01

Html.DropDownList("Types", Model.Types, new {@readonly="readonly"})

Schritt 02 Dies ist CSS-Zeiger, um Code zu entfernen.

<style type="text/css">
    #Types {
        pointer-events:none;
    }
</style>

Getestet & Bewährt