Wie kann ich diese ASP.NET MVC SelectList zum Laufen bringen?

Ich erstelle eine Auswahlliste in meinem Controller, um sie in der Ansicht anzuzeigen.

Ich versuche es im laufenden Betrieb zu erstellen, irgendwie ... so ...

myViewData.PageOptionsDropDown = 
   new SelectList(new [] {"10", "15", "25", "50", "100", "1000"}, "15");

Es wird kompiliert, aber die Ausgabe ist schlecht ...

<select id="PageOptionsDropDown" name="PageOptionsDropDown">
    <option>10</option>
    <option>15</option>
    <option>25</option>
    <option>50</option>
    <option>100</option>
    <option>1000</option>
</select>

Beachten Sie, wie kein Artikel ausgewählt ist?

Wie kann ich das beheben?

So mache ich es

IList<Customer> customers = repository.GetAll<Customer>();
IEnumerable<SelectListItem> selectList = 
    from c in customers
    select new SelectListItem
    {
        Selected = (c.CustomerID == invoice.CustomerID),
        Text = c.Name,
        Value = c.CustomerID.ToString()
    };

Auf den zweiten Blick bin ich mir nicht sicher, ob ich weiß, wonach Sie suchen ...

Ich benutze eine Erweiterungsmethode:

Verwendung

var departmentItems = departments.ToSelectList(d => d.Code + 
                                               " - " + d.Description,
                                               d => d.Id.ToString(),
                                               " - ");

var functionItems = customerFunctions.ToSelectList(f => f.Description, 
                                                   f => f.Id.ToString(), 
                                                   " - ");

mit

public static class MCVExtentions
{
    public static List<SelectListItem> ToSelectList<T>(
        this IEnumerable<T> enumerable, 
        Func<T, string> text, 
        Func<T, string> value, 
        string defaultOption)
    {
        var items = enumerable.Select(f => new SelectListItem()
                                     {
                                         Text = text(f), 
                                         Value = value(f) 
                                     }).ToList();
        items.Insert(0, new SelectListItem()
                    {
                        Text = defaultOption, 
                        Value = "-1" 
                    });
        return items;
    }
}

Verwenden des Konstruktors, der items, dataValueField, dataTextField, selectedValueals Parameter akzeptiert :

ViewData["myList"] = 
                new SelectList(new[] { "10", "15", "25", "50", "100", "1000" }
                .Select(x => new {value = x, text = x}), 
                "value", "text", "15");

Dann aus Ihrer Sicht:

<%=Html.DropDownList("myList") %>

Aufbauend auf der Antwort von Thomas Stock habe ich diese überladenen ToSelectListMethoden erstellt:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;

public static partial class Helpers
{
    public static IEnumerable<SelectListItem> ToSelectList<T>(this IEnumerable<T> enumerable, Func<T, object> value, bool selectAll = false)
    {
        return enumerable.ToSelectList(value, value, selectAll);
    }

    public static IEnumerable<SelectListItem> ToSelectList<T>(this IEnumerable<T> enumerable, Func<T, object> value, object selectedValue)
    {
        return enumerable.ToSelectList(value, value, new List<object>() { selectedValue });
    }

    public static IEnumerable<SelectListItem> ToSelectList<T>(this IEnumerable<T> enumerable, Func<T, object> value, IEnumerable<object> selectedValues)
    {
        return enumerable.ToSelectList(value, value, selectedValues);
    }

    public static IEnumerable<SelectListItem> ToSelectList<T>(this IEnumerable<T> enumerable, Func<T, object> value, Func<T, object> text, bool selectAll = false)
    {
        foreach (var f in enumerable.Where(x => x != null))
        {
            yield return new SelectListItem()
            {
                Value = value(f).ToString(),
                Text = text(f).ToString(),
                Selected = selectAll
            };
        }
    }

    public static IEnumerable<SelectListItem> ToSelectList<T>(this IEnumerable<T> enumerable, Func<T, object> value, Func<T, object> text, object selectedValue)
    {
        return enumerable.ToSelectList(value, text, new List<object>() { selectedValue });
    }

    public static IEnumerable<SelectListItem> ToSelectList<T>(this IEnumerable<T> enumerable, Func<T, object> value, Func<T, object> text, IEnumerable<object> selectedValues)
    {
        var sel = selectedValues != null
            ? selectedValues.Where(x => x != null).ToList().ConvertAll<string>(x => x.ToString())
            : new List<string>();

        foreach (var f in enumerable.Where(x => x != null))
        {
            yield return new SelectListItem()
            {
                Value = value(f).ToString(),
                Text = text(f).ToString(),
                Selected = sel.Contains(value(f).ToString())
            };
        }
    }
}

In Ihrem Controller können Sie Folgendes tun:

var pageOptions = new[] { "10", "15", "25", "50", "100", "1000" };
ViewBag.PageOptions = pageOptions.ToSelectList(o => o, "15" /*selectedValue*/);

Und schließlich setzen Sie in Ihrer Ansicht:

@Html.DropDownList("PageOptionsDropDown", ViewBag.PageOptions as IEnumerable<SelectListItem>, "(Select one)")

Dies führt zu der gewünschten Ausgabe. Natürlich können Sie das "(Select one)"obige optionLabel weglassen, wenn Sie das erste leere Element nicht möchten:

<select id="PageOptionsDropDown" name="PageOptionsDropDown">
<option value="">(Select one)</option>
<option value="10">10</option>
<option selected="selected" value="15">15</option>
<option value="25">25</option>
<option value="50">50</option>
<option value="100">100</option>
<option value="1000">1000</option>
</select>

Update: Eine überarbeitete Codeliste mit XML-Kommentaren finden Sie hier .

Das Problem ist, dass SelectList wie geplant funktioniert. Der Fehler liegt im Design. Sie können die Selected-Eigenschaft in SelectedItem festlegen, dies wird jedoch vollständig ignoriert, wenn Sie die Liste mit dem GetEnumerator () durchlaufen (oder wenn Mvc dies für Sie erledigt). Mvc erstellt stattdessen neue SelectListItems.

Sie müssen den SelectList-Code mit dem SelectListItem [], dem Textnamen, dem Wertnamen und dem SelectedValue verwenden. Achten Sie darauf, den Wert von SelectListItem, den Sie auswählen möchten, als SelectedValue zu übergeben, nicht das SelectListItem selbst! Beispiel:

SelectList sl = new SelectList( new[]{
  new SelectListItem{ Text="one", Value="1"},
  new SelectListItem{ Text="two", Value="2"},
  new SelectListItem{ Text="three", Value="3"}
}, "Text", "Value", "2" );

(nicht getestet, aber ich hatte das gleiche Problem)

dann erhält die 2. Option das Attribut selected = "selected". Das sieht nach guten alten DataSets aus ;-)

Dies ist eine Option:

myViewData.PageOptionsDropDown = new[] 
{
 new SelectListItem { Text = "10", Value = "10" },
 new SelectListItem { Text = "15", Value = "15", Selected = true }
 new SelectListItem { Text = "25", Value = "25" },
 new SelectListItem { Text = "50", Value = "50" },
 new SelectListItem { Text = "100", Value = "100" },
 new SelectListItem { Text = "1000", Value = "1000" },
}

Wenn das buchstäblich alles ist, was Sie tun möchten, behebt das Deklarieren des Arrays als Zeichenfolge das Problem mit dem ausgewählten Element:

myViewData.PageOptionsDropDown = 
   new SelectList(new string[] {"10", "15", "25", "50", "100", "1000"}, "15");

Es ist sehr einfach, SelectList und SelectedValue zusammenzubringen, selbst wenn Ihre Eigenschaft kein einfaches Objekt wie ein Int-, String- oder Double-Wert ist.

Beispiel:

Angenommen, unser Region-Objekt sieht ungefähr so ​​aus:

public class Region {
     public Guid ID { get; set; }
     public Guid Name { get; set; }
}

Und Ihr Ansichtsmodell ist so etwas wie:

public class ContactViewModel {
     public DateTime Date { get; set; }
     public Region Region { get; set; }
     public List<Region> Regions { get; set; }
}

Sie können den folgenden Code haben:

@Html.DropDownListFor(x => x.Region, new SelectList(Model.Regions, "ID", "Name")) 

Nur wenn Sie die ToString-Methode des Region-Objekts auf Folgendes überschreiben:

public class Region {
     public Guid ID { get; set; }
     public Guid Name { get; set; }

     public override string ToString()
     {
         return ID.ToString();
     }
}

Diese haben 100% Garantie zu arbeiten.

Aber ich glaube wirklich, dass der beste Weg, um SelectList zu 100% in allen Situationen zum Laufen zu bringen, darin besteht, die Equals-Methode zu verwenden, um den DropDownList- oder ListBox-Eigenschaftswert für jedes Element in der Elementauflistung zu testen.

Wenn Sie eine stark typisierte Ansicht haben, müssen Sie anscheinend die ID der Dropdown-Liste so ändern, dass sie NICHT der Name einer Eigenschaft in der geerbten Klasse ist. Anschließend müssen Sie Ihrer POST-Methode (Edit) eine Logik hinzufügen, um den ausgewählten Wert aus der FORMCollection abzurufen und in Ihre Instanz einzufügen, bevor Sie Ihre Änderungen übernehmen.

Das ist sicherlich ein bisschen seltsam, aber ich habe es versucht und es funktioniert.

Wenn Ihre Klasse also ein Feld mit dem Namen "CountryId" hat und Sie eine Liste mit Ländernamen anzeigen, lassen Sie die Dropdown-Liste die ID "CountryName" anstelle von "CountryId" haben. In diesem Beitrag können Sie mit "Collection [" CountryName "] etwas tun. .

Ich hatte genau das gleiche Problem. Die Lösung ist einfach. Ändern Sie einfach den an den DropDownList-Helfer übergebenen Parameter "name" in einen Parameter, der keiner der in Ihrem ViewModel vorhandenen Eigenschaften entspricht. Lesen Sie hier mehr: http://www.dotnetguy.co.uk/post/2009/06/25/net-mvc-selectlists-selected-value-does-not-get-set-in-the-view

Ich zitiere den Dan Watson:

Wenn in MVC die Ansicht stark typisiert ist, wird die ausgewählte Option der Auswahlliste überschrieben und die im Konstruktor festgelegte Eigenschaft der ausgewählten Option erreicht die Ansicht nie. Stattdessen wird die erste Option in der Dropdown-Liste ausgewählt (warum ist dies immer noch ein Rätsel). .

Prost!

Alle diese Antworten sehen gut aus, aber es scheint, dass der Controller Daten für eine Ansicht in einem bekannten strukturierten Format vorbereitet, anstatt die Ansicht einfach eine über das Modell gelieferte IEnumerable <> iterieren zu lassen und eine Standardauswahlliste zu erstellen und dann DefaultModelBinder zu lassen Liefern Sie den ausgewählten Artikel über einen Aktionsparameter an Sie zurück. Ja, nein, warum nicht? Trennung von Bedenken, ja? Scheint seltsam, wenn der Controller etwas so UI- und View-spezifisch erstellt.

Einfach:

string[] someName = new string[] {"10", "15", "25", "50", "100", "1000"};
myViewData.PageOptionsDropDown = new SelectList(someName, "15");

Ich habe es einfach so gemacht und hatte keine Probleme,

public class myViewDataObj
    {
        public SelectList PageOptionsDropDown { get; set; }
    }

public ActionResult About()
        {
            myViewDataObj myViewData = new myViewDataObj();
            myViewData.PageOptionsDropDown =
                  new SelectList(new[] { "10", "15", "25", "50", "100", "1000" }, "15");

            ViewData["myList"] = myViewData.PageOptionsDropDown;
            return View();
        }

und

<%=Html.DropDownList("myList") %>

es hat auch funktioniert, wenn Sie dies tun,

public ActionResult About()
        {
            myViewDataObj myViewData = new myViewDataObj();
            myViewData.PageOptionsDropDown =
                  new SelectList(new[] { "10", "15", "25", "50", "100", "1000" });

            ViewData["myListValues"] = myViewData.PageOptionsDropDown;
            ViewData["myList"] = "15";
            return View();
        }

und

<%=Html.DropDownList("myList",(IEnumerable<SelectListItem>)ViewData["myListValues"]) %>

Anhand Ihres Beispiels hat dies bei mir funktioniert:

Regler:

ViewData["PageOptionsDropDown"] = new SelectList(new[] { "10", "15", "25", "50", "100", "1000" }, "15");

Aussicht:

<%= Html.DropDownList("PageOptionsDropDown")%>

MonthRepository monthRepository = new MonthRepository();
IQueryable<MonthEntity> entities = monthRepository.GetAllMonth();
List<MonthEntity> monthEntities = new List<MonthEntity>();

foreach(var r in entities)
{
    monthEntities.Add(r);
}

ViewData["Month"] = new SelectList(monthEntities, "MonthID", "Month", "Mars");

So mach ich es:

List<SelectListItem> list = new List<SelectListItem>{
new SelectListItem {Selected = true, Text = "Select", Value = "0"},
new SelectListItem {Selected = true, Text = "1", Value = "1"},
new SelectListItem {Selected = true, Text = "2", Value = "2"}
};
return list.ToArray();

Das ToArray () kümmert sich um die Probleme.

Wenn Sie zufälligen Text an Ihre DropDownList übergeben möchten, z. B. --Select-- , können Sie dies einfach mit folgendem Code tun:

@Html.DropDownListFor(x => x.CategoryId, new SelectList(Model.Categories, "Id", "Name"), "--Select--", new { @class = "form-control" })

Es kann vorkommen, dass Ihre ViewData mehrdeutig sind:

Schauen Sie hier

Der im Modell ausgewählte Wert wird anstelle des Standardelements verwendet. (Ich bin damit einverstanden, dass ich nicht alle Beiträge gelesen habe)

Ich kann mich nicht erinnern, wie mvc 1 eingerichtet wurde, aber es scheint, dass die Auswahlliste den gleichen Namen haben soll wie das Feld, zu dem sie gehörte ...

Wie oben erwähnt, stellte ich fest, dass meine Auswahllisten in mvc2 nicht funktionierten, als die ViewData, unter denen sie gesendet wurden, den gleichen Namen wie das Feld hatten.

Beispielsweise:

<%= Html.DropDownListFor((model => model.ForID), (SelectList)ViewData["ForName"]) %>

funktioniert wenn

<%= Html.DropDownListFor((model => model.ForID), (SelectList)ViewData["ForID"]) %>

funktioniert nicht, da der ViewData-Name "ForID" den gleichen Namen hat wie das Feld, für das er arbeitet

Eine mögliche Erklärung ist, dass der Auswahllistenwert, an den Sie binden, keine Zeichenfolge ist.

Ist der Parameter 'PageOptionsDropDown' in diesem Beispiel eine Zeichenfolge in Ihrem Modell? Wenn dies nicht der Fall ist, wird der ausgewählte Wert in der Liste nicht angezeigt.

Wenn Sie im Quellcode für MVC 2 nach der Erweiterungsmethode Html.DropDownList suchen, wird die SelectedValue-Eigenschaft der SelectList-Klasse niemals überprüft. Es wird immer nur versucht, mit Ihrem Modell übereinzustimmen.

Alle oben genannten sind Variationen eines Themas, dh wie senden Sie eine Reihe von Daten an die Ansicht, um eine Dropdown-Liste zu erhalten, und sie sind alle so gut wie einander (mehr oder weniger).

Das Problem liegt in der Ansicht. Erstellen Sie entweder Ihre eigene DropDownList-Erweiterungsmethode, die den von Ihnen festgelegten Auswahlwert berücksichtigt, oder iterieren Sie manuell. Was für Sie am besten funktioniert.

Wenn Sie eine Sammlung in Ihrem Modell haben und Ihre Ansicht stark typisiert ist, funktioniert eine Variation davon:

@Html.DropDownListFor(x => x.RegionID, 
    new SelectList(Model.Regions,"RegionID", "RegionName", Model.RegionID))

-oder-

@Html.DropDownList("RegionID", 
    new SelectList(Model.Regions, "RegionID", "RegionName", Model.RegionID))