web-dev-qa-db-de.com

Auffüllen einer Rasierer-Dropdown-Liste aus einer Liste <Objekt> in MVC

Ich habe ein Modell:

public class DbUserRole
    {
        public int UserRoleId { get; set; }
        public string UserRole { get; set; }
    }

public class DbUserRoles
    {
        public List<DbUserRole> GetRoles()
        {
            BugnetReports RoleDropDown = new BugnetReports();
            List<DbUserRole> Roles = new List<DbUserRole>();
            DataSet table = RoleDropDown.userRoleDropDown();
            foreach (DataRow item in table.Tables[0].Rows)
            {
                DbUserRole ur = new DbUserRole();
                ur.UserRole = Convert.ToString(item["UserRoleName"]);
                ur.UserRoleId = Convert.ToInt32(item["UserRoleID"]);
                Roles.Add(ur);
            }
            return Roles;
        }
    }

Und hier ist der Controller, der die Ansicht lädt:

        //
        // GET: /Admin/AddNewUser

        public ActionResult AddNewUser()
        {
            DbUserRoles Roles = new DbUserRoles();
            return View(Roles.GetRoles());
        }

Ich kann die Elemente in der Liste mithilfe einer @foreach-Schleife anzeigen lassen, wie unten gezeigt:

@foreach (var item in Model)
       {
           <tr>
               <td>
                   @item.UserRoleId
               </td>
               <td>
                   @item.UserRole
               </td>
           </tr>
       }

Aber wie fülle ich eine Dropdown-Liste mit dem Modell auf, das ich durchlaufen habe?

@Html.DropDownListFor(x => x.UserRole)

aber ich habe kein glück.

114
Win

Sie können Ihre Geschäftslogik in ein Ansichtsmodell aufteilen, sodass Ihre Ansicht sauberer ist.

Erstellen Sie zuerst ein Ansichtsmodell, um die ID zu speichern, die der Benutzer zusammen mit einer Liste von Elementen auswählen wird, die in der DropDown angezeigt wird.

ViewModel:

public class UserRoleViewModel
{
    // Display Attribute will appear in the Html.LabelFor
    [Display(Name = "User Role")]
    public int SelectedUserRoleId { get; set; }
    public IEnumerable<SelectListItem> UserRoles { get; set; }
}

Verweise:

Erstellen Sie im Controller eine Methode, um Ihre UserRole-Liste abzurufen und in das Formular umzuwandeln, das in der Ansicht angezeigt wird.

Regler:

private IEnumerable<SelectListItem> GetRoles()
{
    var dbUserRoles = new DbUserRoles();
    var roles = dbUserRoles
                .GetRoles()
                .Select(x =>
                        new SelectListItem
                            {
                                Value = x.UserRoleId.ToString(),
                                Text = x.UserRole
                            });

    return new SelectList(roles, "Value", "Text");
}

public ActionResult AddNewUser()
{
    var model = new UserRoleViewModel
                    {
                        UserRoles = GetRoles()
                    };
    return View(model);
}

Verweise:

Nachdem das Ansichtsmodell erstellt wurde, wird die Präsentationslogik vereinfacht

Aussicht:

@model UserRoleViewModel

@Html.LabelFor(m => m.SelectedUserRoleId)
@Html.DropDownListFor(m => m.SelectedUserRoleId, Model.UserRoles)

Verweise:

Dies wird produzieren:

<label for="SelectedUserRoleId">User Role</label>
<select id="SelectedUserRoleId" name="SelectedUserRoleId">
    <option value="1">First Role</option>
    <option value="2">Second Role</option>
    <option value="3">Etc...</option>
</select>
228
Romoku
  @Html.DropDownList("ddl",Model.Select(item => new SelectListItem
{
    Value = item.RecordID.ToString(),
    Text = item.Name.ToString(),
     Selected = "select" == item.RecordID.ToString()
}))
27
Ankita Singh

Ein Weg könnte sein;

    <select name="listbox" id="listbox">
    @foreach (var item in Model)
           {

                   <option value="@item.UserRoleId">
                      @item.UserRole 
                   </option>                  
           }
    </select>
23
neildt

Etwas in der Nähe von:

@Html.DropDownListFor(m => m.UserRole, 
   new SelectList(Model.Roles, "UserRoleId", "UserRole", Model.Roles.First().UserRoleId), 
   new { /* any html  attributes here */ }) 

Sie benötigen eine SelectList, um die DropDownListFor aufzufüllen. Für beliebige HTML-Attribute können Sie Folgendes hinzufügen:

new { @class = "DropDown", @id = "dropdownUserRole" }
10
Jonesopolis

Anstelle eines List<UserRole> können Sie Ihr Modell einen SelectList<UserRole> enthalten lassen. Fügen Sie außerdem eine Eigenschaft SelectedUserRoleId hinzu, um den ID-Wert der ausgewählten UserRole zu speichern.

Füllen Sie die SelectList auf und verwenden Sie in Ihrer View:

@Html.DropDownListFor(x => x.SelectedUserRoleId, x.UserRole)

und es sollte dir gut gehen.

Siehe auch http://msdn.Microsoft.com/de-de/library/system.web.mvc.selectlist(v=vs.108).aspx .

7
Roy Dictus

Ihr Aufruf an DropDownListFor benötigt einige weitere Parameter, um ihn genauer zu definieren. Sie benötigen eine SelectList wie in der folgenden SO - Frage:

MVC3 DropDownListFor - ein einfaches Beispiel?

Mit dem, was Sie dort haben, haben Sie nur gesagt, wo die Daten gespeichert werden sollen und nicht, wo die Liste geladen werden soll.

2
MisterJames
   @{
        List<CategoryModel> CategoryList = CategoryModel.GetCategoryList(UserID);
        IEnumerable<SelectListItem> CategorySelectList = CategoryList.Select(x => new SelectListItem() { Text = x.CategoryName.Trim(), Value = x.CategoryID.Trim() });
    }
    <tr>
        <td>
            <B>Assigned Category:</B>
        </td>
        <td>
            @Html.DropDownList("CategoryList", CategorySelectList, "Select a Category (Optional)")
        </td>
    </tr>
1
Deathstalker

Ich gehe so vor, als ob Sie ein Benutzermodell haben:

Users.cs

public class Users
{
    [Key]
    public int UserId { get; set; }

    [Required]
    public string UserName { get; set; }

    public int RoleId { get; set; }

    [ForeignKey("RoleId")]
    public virtual DbUserRoles DbUserRoles { get; set; }
}

und ein DbUserRoles-Modell, das eine Tabelle mit diesem Namen in der Datenbank repräsentiert:

DbUserRoles.cs

public partial class DbUserRoles
{
    [Key]
    public int UserRoleId { get; set; }

    [Required]
    [StringLength(30)]
    public string UserRole { get; set; }
}

Sobald Sie das bereinigt haben, sollten Sie einfach in der Lage sein, eine Sammlung von UserRoles in Ihrem Controller zu erstellen und zu füllen:

var userRoleList = GetUserRolesList();
ViewData["userRoles"] = userRolesList;

und haben diese unterstützenden Funktionen:

private static SelectListItem[] _UserRolesList;

/// <summary>
/// Returns a static category list that is cached
/// </summary>
/// <returns></returns>
public SelectListItem[] GetUserRolesList()
{
    if (_UserRolesList == null)
    {
        var userRoles = repository.GetAllUserRoles().Select(a => new SelectListItem()
         {
             Text = a.UserRole,
             Value = a.UserRoleId.ToString()
         }).ToList();
         userRoles.Insert(0, new SelectListItem() { Value = "0", Text = "-- Please select your user role --" });

        _UserRolesList = userRoles.ToArray();
    }

    // Have to create new instances via projection
    // to avoid ModelBinding updates to affect this
    // globally
    return _UserRolesList
        .Select(d => new SelectListItem()
    {
         Value = d.Value,
         Text = d.Text
    })
     .ToArray();
}

Repository.cs

Meine Repository-Funktion GetAllUserRoles() für die Funktion oben:

public class Repository
{
    Model1 db = new Model1(); // Entity Framework context

    // User Roles
    public IList<DbUserRoles> GetAllUserRoles()
    {
        return db.DbUserRoles.OrderBy(e => e.UserRoleId).ToList();
    }
}

AddNewUser.cshtml

Dann mach das in deiner Ansicht:

<table>
    <tr>
        <td>
            @Html.EditorFor(model => model.UserName,
                  htmlAttributes: new { @class = "form-control" }
                  )
        </td>
        <td>
            @Html.DropDownListFor(model => model.RoleId,
                  new SelectList( (IEnumerable<SelectListItem>)ViewData["userRoles"], "Value", "Text", model.RoleId),
                  htmlAttributes: new { @class = "form-control" }
                  )
         </td>
     </tr>
 </table>
0
vapcguy