Liste déroulantePour valeur par défaut

Question

Existe-t-il un moyen simple d'ajouter une option par défaut "--Please select--" à un DropDownListFor dans MVC 3 ?

Answer 1

J'ai donc procédé de la manière suivante :

@Html.DropDownListFor(model => model.Dessert, 
                      new SelectList(Model.AvailableDesserts, "DessertID", "DessertName"),
                      "---Select A Dessert ---")

Il semble fonctionner assez bien. Dessert dans mon modèle de vue est celui sélectionné par l'utilisateur. AvailableDesserts est une collection de choix. J'espère que cela vous aidera.

Answer 2

J'ai quelques méthodes d'extension sur SelectList

    public static SelectList PreAppend(this SelectList list, string dataTextField, string selectedValue, bool selected=false)
    {
        var items = new List<SelectListItem>();
        items.Add(new SelectListItem() { Selected = selected, Text = dataTextField, Value = selectedValue });
        items.AddRange(list.Items.Cast<SelectListItem>().ToList());
        return new SelectList(items, "Value", "Text");
    }
    public static SelectList Append(this SelectList list, string dataTextField, string selectedValue, bool selected=false)
    {
        var items = list.Items.Cast<SelectListItem>().ToList();
        items.Add(new SelectListItem() { Selected = selected, Text = dataTextField, Value = selectedValue });
        return new SelectList(items, "Value", "Text");
    }
    public static SelectList Default(this SelectList list,string DataTextField,string SelectedValue)
    {
        return list.PreAppend(DataTextField, SelectedValue, true);
    }

Mon rasoir ressemble alors à.. :

@Html.DropDownListFor(m=>m.SelectedState, 
    Model.StateList().Default("Select One",""))

Answer 3

Bonjour, et si vous essayiez ceci (dans le cas où vous utilisez la méthode DisplayFor)

private IEnumerable<SelectListItem> AddDefaultOption(IEnumerable<SelectListItem> list, string dataTextField, string selectedValue)
    {
        var items = new List<SelectListItem>();
        items.Add(new SelectListItem() { Text = dataTextField, Value = selectedValue});
        items.AddRange(list);
        return items;
    }

Il suffit ensuite d'ajouter le code suivant à votre contrôleur

//lambda expression binding
ViewBag.YourList = db.YourTable.Select(x => x).ToList().Select(x => new SelectListItem
        {
            Value = x.Id.ToString(),
            Text = x.DisplayName.ToString()
        });

        ViewBag.YourList = AddDefaultOption(ViewBag.YourList, "Select One...", "null", true);

Enfin, au niveau de la vue, vous pouvez afficher une liste déroulante ou une boîte combinée, comme suit

    <div class="editor-label">
        Your Label
    </div>
    <div class="editor-field">
        @Html.DropDownListFor(model => model.ForeignKey, (IEnumerable<SelectListItem>)ViewBag.YourList)
    </div>

Answer 4

Je voulais que la valeur par défaut soit celle du paramètre Url appelé SiteType :

    <div class="form-group">
        @Html.LabelFor(model => model.Type, new { @class = "control-label col-md-2" })
        <div class="col-md-10">
            @Html.DropDownListFor(model => model.Type, ChangeOrderSite.SiteTypeNames.Select(s => new SelectListItem { Text = s.Value, Value = s.Key.ToString(), Selected = s.Key.ToString() == Request["SiteType"] }), new { @class = "control-label col-md-2" })
            @Html.ValidationMessageFor(model => model.Type)
        </div>
    </div>

Mon menu déroulant est une liste de types de sites.

Answer 5

J'aime la méthode suivante :

@Html.DropDownListFor(m => m.SelectedId, new SelectList(Model.Items, "Id", "Name"), new SelectListItem() { Text = "None", Value = "", Selected = true }.Text, new { @class = "form-control search-select-input btn btn-block btn-outline-secondary dropdown-toggle p-1" })

Où Items est un IEnumerable du type que vous souhaitez afficher dans la liste déroulante. Et vous pouvez changer les classes bootstrap que vous voulez dans le dernier paramètre.

Cette méthode vous permet de définir une étiquette par défaut et de spécifier la valeur de l'étiquette si nécessaire.