Html.DropDownList - Deaktiviert / schreibgeschützt

68

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!

ETFairfax
quelle
6
Beachten Sie die Antwort von @Thomas unten. Durch Markieren der Datei Html.DropDownList als deaktiviert wird verhindert, dass das Formular den darin enthaltenen Wert veröffentlicht. Wie kann das Steuerelement deaktiviert oder schreibgeschützt sein und dennoch den Formularwert per Post senden?
YeahStu
Wie wird das dynamische Einstellungsattribut mit einem Bool-Wert deaktiviert?
Superman

Antworten:

145

Versuche dies

Html.DropDownList("Types", Model.Types, new { @disabled = "disabled" })
Tadas Šukys
quelle
49
Auf diese Weise wird der Bindungswert der Dropdown-Liste jedoch nicht auf dem Controller angezeigt.
Vishnu Vikraman
Der Versuch, dies zu verwenden, funktioniert jedoch nicht, unabhängig von der Variation @ Html.DropDownList ("Tug_ID", model => model.Tug_ID, new {@disabled = "disabled"})
New2This
8
Dies verhindert jedoch, dass der DDL-Wert mit dem Formular gesendet wird.
Mahmoud
1
@Jamie R , Wie wird das dynamische Einstellungsattribut mit einem Bool-Wert deaktiviert?
Superman
2
@ VishnuVikraman, Dies könnte die perfekte Antwort für Sie sein,
Smit Patel
91

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.

BGStack
quelle
14
Das ist die nützlichste Lösung, die ich gefunden habe. Ich weiß nicht, warum es so wenig Stimmen bekommen hat.
Mikhail
Wirklich guter Tipp. Ich folgte nur die Antwort , ohne darunter im Kommentar zu suchen, und es dauerte 2 Stunden , um herauszufinden , warum ein Nullwert seinen Satz in der Post zurück ist
tete
1
Bei dieser Lösung müssen Sie vorsichtig sein: MVC druckt zwei Elemente mit Attributen. Dies id="MyModelField"kann schwierig sein, wenn Sie bereit sind, mit JS mit den ausgewählten / ausgeblendeten Elementen zu interagieren.
Quentin S.
1
Dies ist jedoch kein gültiger HTML-Code. Sie haben zwei Elemente mit der gleichen ID
Cătălin Rădoi
Um das von @ CătălinRădoi angesprochene Problem zu umgehen, erstellen Sie das Versteckte einfach mit einer benutzerdefinierten ID unter Verwendung vonnew {id = "SomeId"}
Alex
6
<script type="text/javascript">
$(function () {
        $(document) .ajaxStart(function () {
                $("#dropdownID").attr("disabled", "disabled");
            })
            .ajaxStop(function () {
                $("#dropdownID").removeAttr("disabled");

            });

});
</script>
Muhammad Mubashir
quelle
Dieser hat bei mir nicht funktioniert, können Sie das Beispiel erweitern?
TheBigSot
3

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>
Käfigwal
quelle
3

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" 
       }
)
Michael
quelle
2

Oder Sie können so etwas ausprobieren:

Html.DropDownList("Types", Model.Types, new { @readonly = "true" })
Bruce
quelle
5
Das funktioniert nicht. Das Dropdown-Menü ist ausgegraut, aber weiterhin aktiviert und verwendbar.
Kye
Hallo, ich möchte das Dropdown für bestimmte Seiten nur basierend auf dem Wert deaktivieren / aktivieren. Ich übergebe es durch das Modell. Ich habe versucht, wahr / falsch an die Behinderten zu übergeben, aber es funktioniert nicht. Können Sie dabei helfen
Ravithejag
2

Setzen Sie dies mit Stil

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

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)
lollmbaowtfidgafgtfoohwtbs
quelle
1
@Html.DropDownList("Types", Model.Types, new { @disabled = "" })

Funktioniert

Andrew Day
quelle
0

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

Roger Tello
quelle
0

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)
Antonio Bakula
quelle
0

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>
Pablo García Alves
quelle
Das OP fragte speziell nach der Verwendung von Html.DropDownList in MVC.
Jim Speaker
0

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" })
Alfrodop
quelle
-1

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>
Dann können Sie erwartete Ergebnisse haben

Getestet & Bewährt

Tharanga
quelle