ASP.NET MVC DropDownListFor with Nested Properties in Model

Question

I have two classes an Entry and Paradigm. The Entry class has a ParadigmId and a Paradigm property. So in my view I have @Model.Entry.Paradigm. How do I build a DropDownListFor using the newer syntax for the Paradigm model?

   // Entry Model
    [Bind(Exclude = "EntryId")]
    public class Entry
    {
        [ScaffoldColumn(false)] 
        public int EntryId { get; set; }
 .
        [Display(Name = "Type")]
        public int ParadigmId { get; set; }

        public virtual Paradigm Paradigm { get; set; }
    }

// Paradigm Model
public class Paradigm
{
    [ScaffoldColumn(false)]
    public int ParadigmId { get; set; }

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

    public List<Entry> Entries { get; set; } 
}

In my view I have @Html.DropDownListFor(model => model.Entry.ParadigmId, model.Entry.Paradigm). But the model is of type Paradigm not IEnumerable. Since Paradigm is part of my class (for Entity Framework Code First) I do not need to use a separate ViewData/ViewBag that is listed in most examples.

I Googled a bit and saw individuals using Helper/Extension methods to convert a model into a SelectList. What is the best way to use DropDownListFor in my model?

    @* Create View *@
    <div class="editor-label">
        @Html.LabelFor(model => model.Entry.ParadigmId)
    </div>
    <div class="editor-field">   
        @Html.DropDownListFor(model => model.Entry.ParadigmId, model.Entry.Paradigm)
        @Html.ValidationMessageFor(model => model.Entry.ParadigmId)
    </div>

Answer 1

I've been using:

public abstract class DropdownVm
{
    /// <summary>
    /// Set up a dropdown with the indicated values
    /// </summary>
    /// <param name="value">the current value, for determining selection</param>
    /// <param name="options">list of options to display</param>
    /// <param name="prependLabelAndValues">list of alternating label/value entries to insert to the beginning of the list</param>
    public List<SelectListItem> SetDropdown<T>(T value, IEnumerable<KeyValuePair<T, string>> options, params object[] prependLabelAndValues)
    {
        var dropdown = options.Select(o => new SelectListItem { Selected = Equals(o.Key, value), Value = o.Key.ToString(), Text = o.Value }).ToList();

        // insert prepend objects
        for (int i = 0; i < prependLabelAndValues.Length; i += 2)
        {
            dropdown.Insert(0, new SelectListItem { Text = prependLabelAndValues[i].ToString(), Value = prependLabelAndValues[i + 1].ToString() });
        }

        return dropdown;
    }
}

/// <summary>
/// ViewModel with a single dropdown representing a "single" value
/// </summary>
/// <typeparam name="T">the represented value type</typeparam>
public class DropdownVm<T> : DropdownVm
{
    /// <summary>
    /// Flag to set when this instance is a nested property, so you can determine in the view if `!ModelState.IsValid()`
    /// </summary>
    public virtual bool HasModelErrors { get; set; }

    /// <summary>
    /// The user input
    /// </summary>
    public virtual T Input { get; set; }

    /// <summary>
    /// Dropdown values to select <see cref="Input"/>
    /// </summary>
    public virtual List<SelectListItem> Dropdown { get; set; }

    /// <summary>
    /// Set up <see cref="Dropdown"/> with the indicated values
    /// </summary>
    /// <param name="availableOptions">list of options to display</param>
    /// <param name="prependLabelAndValues">list of alternating label/value entries to insert to the beginning of the list</param>
    public virtual void SetDropdown(IEnumerable<KeyValuePair<T, string>> availableOptions, params object[] prependLabelAndValues)
    {
        this.Dropdown = SetDropdown(this.Input, availableOptions, prependLabelAndValues);
    }

    public override string ToString()
    {
        return Equals(Input, default(T)) ? string.Empty : Input.ToString();
    }
}

Which you create with:

var vm = new DropdownVm<string>();
vm.SetDropdown(new Dictionary<string, string> {
    { "option1", "Label 1" },
    { "option2", "Label 2" },
}, "(Choose a Value)", string.Empty);

or, more specifically in your case:

var models = yourDataProvider.GetParadigms(); // list of Paradigm
var vm = new DropdownVm<int>();
vm.SetDropdown(
    models.ToDictionary(m => m.ParadigmId, m => m.Name),
     "(Choose a Value)", string.Empty
);

And render in the view with:

<div class="field">
    @Html.LabelFor(m => m.Input, "Choose")
    @Html.DropDownListFor(m => m.Input, Model.Dropdown)
    @Html.ValidationMessageFor(m => m.Input)
</div>

Answer 2

Your link Entry.Paradigm lazy loads a single Paradigm, the one referenced by the foreign key. It does not load all the Paradigm's in the database.

If you want to have a dropdown list of all the paradigms, bound to the selected one. Then you will need a separate ViewBag or Model property that contains a list of the them all.