c# - mvc - selectlist select

MVC-Establecer el valor seleccionado de SelectList

Question

¿Cómo puedo configurar la propiedad de valor seleccionado de una Lista de selección después de que se haya creado una instancia sin un valor seleccionado;

SelectList selectList = new SelectList(items, "ID", "Name");

Necesito establecer el valor seleccionado después de esta etapa

Answer 1

¿Por qué intenta establecer el valor después de crear la lista? Supongo que está creando la lista en su modelo en lugar de en su vista. Recomiendo crear el enumerable subyacente en su modelo y luego usar esto para construir el SelectList real:

<%= Html.DropDownListFor(m => m.SomeValue, new SelectList(Model.ListOfValues, "Value", "Text", Model.SomeValue)) %>

De esa manera, su valor seleccionado siempre se establece tal como se representa la vista y no antes. Además, no es necesario que coloque ninguna clase de UI innecesaria (es decir, SelectList) en su modelo y puede permanecer inconsciente de la UI.

Answer 2

Además de la respuesta de @Womp, vale la pena señalar que el "Dónde" se puede eliminar y el predicado se puede colocar directamente en la "Primera" llamada, de esta manera:

list.First(x => x.Value == "selectedValue").Selected = true;

Answer 3

Doug respondió a mi pregunta ... Pero le explicaré cuál fue exactamente mi problema y cómo Doug me ayudó a resolver el problema que podría encontrar.

Llamo a jquery $.post y estoy reemplazando mi div con mi vista parcial, como tal.

function AddNewAddress (paramvalue) {
    $.post(url, { param: paramvalue}, function(d) {
        $(''#myDiv'').replaceWith(d);
    });
}

Al hacerlo, por alguna razón, cuando ingresé a mi modelo, mi propiedad afiliada con el valor seleccionado nunca se estableció, solo hasta que entré en la vista que estaba dentro del alcance.

Así que, lo que tenía antes

@Html.DropDownListUnobtrusiveFor(model => model.CustomerAddresses[i].YearsAtAddress, Model.CustomerAddresses[i].YearsAtAddressSelectList, new {onchange = "return Address.AddNewAddress(this,''" + @Url.Action("AddNewAddress", "Address") + "''," + i + ")"})

sin embargo, a pesar de que Model.CustomerAddresses [i] .YearsAtAddressSelectList, se estableció ... no estableció el valor seleccionado.

Así que después....

 @Html.DropDownListUnobtrusiveFor(model => model.CustomerAddresses[i].YearsAtAddress, new SelectList(Model.CustomerAddresses[i].YearsAtAddressSelectList, "Value", "Text", Model.CustomerAddresses[i].YearsAtAddress), new { onchange = "return Address.AddNewAddress(this,''" + @Url.Action("AddNewAddress", "Address") + "''," + i + ")" })

y funciono!

Decidí no usar DropDownListFor ya que tiene problemas al usar la validación discreta, razón por la cual me refiero a lo siguiente si tiene curiosidad en una clase clasificada

HtmlExtensions.cs




[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]

public static MvcHtmlString DropDownListUnobtrusiveFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList)
{
    return DropDownListUnobtrusiveFor(htmlHelper, expression, selectList, null /* optionLabel */, null /* htmlAttributes */);

}


[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]

public static MvcHtmlString DropDownListUnobtrusiveFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, object htmlAttributes)
{
    return DropDownListUnobtrusiveFor(htmlHelper, expression, selectList, null /* optionLabel */, new RouteValueDictionary(htmlAttributes));

}


[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]

public static MvcHtmlString DropDownListUnobtrusiveFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
{
    return DropDownListUnobtrusiveFor(htmlHelper, expression, selectList, null /* optionLabel */, htmlAttributes);

}


[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]

public static MvcHtmlString DropDownListUnobtrusiveFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string optionLabel)
{
    return DropDownListUnobtrusiveFor(htmlHelper, expression, selectList, optionLabel, null /* htmlAttributes */);

}


[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]

public static MvcHtmlString DropDownListUnobtrusiveFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string optionLabel, object htmlAttributes)
{
    return DropDownListUnobtrusiveFor(htmlHelper, expression, selectList, optionLabel, new RouteValueDictionary(htmlAttributes));

}


[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]

[SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]

public static MvcHtmlString DropDownListUnobtrusiveFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string optionLabel, IDictionary<string, object> htmlAttributes)
{
    if (expression == null)
    {
        throw new ArgumentNullException("expression");
    }


    ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);



    IDictionary<string, object> validationAttributes = htmlHelper
        .GetUnobtrusiveValidationAttributes(ExpressionHelper.GetExpressionText(expression), metadata);



    if (htmlAttributes == null)
        htmlAttributes = validationAttributes;
    else
        htmlAttributes = htmlAttributes.Concat(validationAttributes).ToDictionary(k => k.Key, v => v.Value);



    return SelectExtensions.DropDownListFor(htmlHelper, expression, selectList, optionLabel, htmlAttributes);

}

Answer 4

Puede utilizar el método de abajo, que es bastante simple.

new SelectList(items, "ID", "Name",items.Select(x=> x.Id).FirstOrDefault());

Esto seleccionará automáticamente el primer elemento de su lista. Puede modificar la consulta anterior agregando una cláusula where.

Answer 5

Quería que el menú desplegable seleccione el valor coincidente de la ID en el método de acción. El truco es establecer la propiedad seleccionada al crear la colección SelectListItem. No funcionaría de otra manera, tal vez me perdí algo, pero al final, es más elegante en mi opción.

Puede escribir cualquier método que devuelva un valor booleano para establecer el valor seleccionado según sus requisitos, en mi caso, utilicé el método Equal existente.

public ActionResult History(long id)
        {
            var app = new AppLogic();
            var historyVM = new ActivityHistoryViewModel();

            historyVM.ProcessHistory = app.GetActivity(id);
            historyVM.Process = app.GetProcess(id);
            var processlist = app.GetProcessList();

            historyVM.ProcessList = from process in processlist
                                    select new SelectListItem
                                    {
                                        Text = process.ProcessName,
                                        Value = process.ID.ToString(),
                                        Selected = long.Equals(process.ID, id)                                    

                                    };

            var listitems = new List<SelectListItem>();

            return View(historyVM);
        }

Answer 6

Si tiene su objeto SelectList, solo itere a través de los elementos en él y establezca la propiedad "Seleccionado" del elemento que desea.

foreach (var item in selectList.Items)
{
  if (item.Value == selectedValue)
  {
    item.Selected = true;
    break;
  }
}

O con Linq:

var selected = list.Where(x => x.Value == "selectedValue").First();
selected.Selected = true;

Answer 7

Simplemente use el tercer parámetro para el valor seleccionado en mvc4

@Html.DropDownList("CountryList", new SelectList(ViewBag.Countries, "Value", "Text","974"))

Aquí se selecciona "974" Valor Especificado

En mi resultado, el país seleccionado ahora es qatar.in C # como abajo

    foreach (CountryModel item in CountryModel.GetCountryList())
        {
            if (item.CountryPhoneCode.Trim() != "974")
            {
                countries.Add(new SelectListItem { Text = item.CountryName + " +(" + item.CountryPhoneCode + ")", Value = item.CountryPhoneCode });

            }
            else {


                countries.Add(new SelectListItem { Text = item.CountryName + " +(" + item.CountryPhoneCode + ")", Value = item.CountryPhoneCode,Selected=true });

            }
        }

Answer 8

Un poco tarde para la fiesta aquí, pero aquí está lo simple que es esto:

ViewBag.Countries = new SelectList(countries.GetCountries(), "id", "countryName", "82");

este utiliza mi método getcountries para poblar un modelo llamado países, obviamente, lo reemplazaría con lo que sea su fuente de datos, un modelo, etc., luego establece el ID como el valor en la lista de selección. luego simplemente agregue el último parámetro, en este caso "82" para seleccionar el elemento seleccionado predeterminado.

[editar] Aquí está cómo usar esto en Razor:

@Html.DropDownListFor(model => model.CountryId, (IEnumerable<SelectListItem>)ViewBag.Countries, new { @class = "form-control" })

Espero que esto le salve a alguien algún tiempo.

Answer 9

Usualmente uso este método

        public static SelectList SetSelectedValue(SelectList list, string value)
    {
        if (value != null)
        {
            var selected = list.Where(x => x.Value == value).First();
            selected.Selected = true;
            return list;
        }
        return list;
    }

Answer 10

Yo necesitaba un menú desplegable en una cuadrícula editable con valores desplegables preseleccionados. Afaik, los datos de la lista de selección los proporciona el controlador a la vista, por lo que se crean antes de que la vista los consuma. Una vez que la vista consume la Lista de selección, se la entrego a un ayudante personalizado que usa la ayuda de DropDownList estándar. Por lo tanto, una solución bastante ligera imo. Supongo que encaja en el espíritu de ASP.Net MVC en el momento de la escritura; cuando no estés feliz, enrolla tu propio ...

public static string DropDownListEx(this HtmlHelper helper, string name, SelectList selectList, object selectedValue) { return helper.DropDownList(name, new SelectList(selectList.Items, selectList.DataValueField, selectList.DataTextField, selectedValue)); }