@ Html.HiddenFor não funciona em listas na ASP.NET MVC

Estou usando um modelo que contém uma lista como propriedade. Estou preenchendo esta lista com itens que peguei do SQL Server. Quero que a lista seja ocultada na visualização e passada para a ação POST. Posteriormente, posso querer adicionar mais itens a esta Lista com jQuery, o que torna um array inadequado para expansão posterior. Normalmente você usaria

@Html.HiddenFor(model => model.MyList)

para realizar essa funcionalidade, mas por algum motivo a Lista no POST é sempre nula.

Pergunta muito simples, alguém sabe por que MVC se comporta assim?

Acabei de encontrar esse problema e resolvi-o simplesmente fazendo o seguinte:

@for(int i = 0; i < Model.ToGroups.Length; i++)
{
    @Html.HiddenFor(model => Model.ToGroups[i])
}

Usando um for em vez de um foreach, a vinculação do modelo funcionará corretamente e coletará todos os seus valores ocultos na lista. Parece a maneira mais simples de resolver esse problema.

HiddenFor não é como DisplayFor ou EditorFor. Não funcionará com coleções, apenas valores únicos.

Você pode usar o auxiliar Serialize HTML disponível no projeto MVC Futures para serializar um objeto para um campo Oculto ou terá que escrever o código você mesmo. Uma solução melhor é simplesmente serializar um ID de algum tipo e recuperar os dados do banco de dados no postback.

É um pouco de um truque, mas se @Html.EditorForou @Html.DisplayFortrabalho para a sua lista, se você quer ter certeza que é enviado na solicitação post, mas não visível, você pode simplesmente estilo para usar display: none;para escondê-lo em vez disso, por exemplo:

<div style="display: none;">@Html.EditorFor(model => model.MyList)</div>

Que tal usar o Newtonsoft para desserializar o objeto em uma string json e, em seguida, inserir isso em seu campo Hidden, por exemplo ( Model.DataResponse.Entity.Commission é uma lista de objetos "CommissionRange" simples como você verá no JSON)

@using (Ajax.BeginForm("Settings", "AffiliateProgram", Model.DataResponse, new AjaxOptions { UpdateTargetId = "result" }))
   {
      string commissionJson = JsonConvert.SerializeObject(Model.DataResponse.Entity.Commission);
      @Html.HiddenFor(data => data.DataResponse.Entity.Guid)
      @Html.Hidden("DataResponse_Entity_Commission", commissionJson)
      [Rest of my form]
   }

Renderiza como:

<input id="DataResponse_Entity_Commission" name="DataResponse_Entity_Commission" type="hidden" value="[{"RangeStart":0,"RangeEnd":0,"CommissionPercent":2.00000},{"RangeStart":1,"RangeEnd":2,"CommissionPercent":3.00000},{"RangeStart":2,"RangeEnd":0,"CommissionPercent":2.00000},{"RangeStart":3,"RangeEnd":2,"CommissionPercent":1.00000},{"RangeStart":15,"RangeEnd":10,"CommissionPercent":5.00000}]">

No meu caso, faço algumas coisas em JS para editar o json no campo oculto antes de postar de volta

Em meu controlador, uso o Newtonsoft novamente para desserializar:

string jsonCommissionRange = Request.Form["DataResponse_Entity_Commission"];
List<CommissionRange> commissionRange = JsonConvert.DeserializeObject<List<CommissionRange>>(jsonCommissionRange);

Html.HiddenForé projetado para apenas um valor. Você precisará serializar sua lista de alguma forma antes de criar o campo oculto.

Por exemplo, se sua lista for do tipo string, você pode juntar a lista em uma lista separada por vírgulas e, em seguida, dividir a lista após postar de volta em seu controlador.

Acabei de descobrir (depois de algumas horas tentando descobrir por que os valores do modelo não estavam voltando para o controlador) que oculto para deve seguir o EditorFor.

A menos que eu esteja fazendo algo errado, foi isso que descobri. Não cometerei o erro de novo.

No contexto de um modelo que contém uma lista de outra classe.

Isso NÃO vai funcionar:

        @{
            for (int i = 0; i < Model.Categories.Count; i++)
            {
                <tr>
                    <td>
                        @Html.HiddenFor(modelItem => Model.Categories[i].Id)
                        @Html.HiddenFor(modelItem => Model.Categories[i].ProductCategoryId)
                        @Html.HiddenFor(modelItem => Model.Categories[i].CategoryName)                            
                        @Html.DisplayFor(modelItem => Model.Categories[i].CategoryName)                            
                    </td>
                    <td>
                        @Html.HiddenFor(modelItem => Model.Categories[i].DailyPurchaseLimit)                                                        
                        @Html.EditorFor(modelItem => Model.Categories[i].DailyPurchaseLimit)
                        @Html.ValidationMessageFor(modelItem => Model.Categories[i].DailyPurchaseLimit)
                    </td>
                    <td style="text-align: center">
                        @Html.HiddenFor(modelItem => Model.Categories[i].IsSelected)                            
                        @Html.EditorFor(modelItem => Model.Categories[i].IsSelected)
                    </td>
                </tr>
            }
        }

Onde assim VAI ......

            for (int i = 0; i < Model.Categories.Count; i++)
            {
                <tr>
                    <td>
                        @Html.HiddenFor(modelItem => Model.Categories[i].Id)
                        @Html.HiddenFor(modelItem => Model.Categories[i].ProductCategoryId)
                        @Html.HiddenFor(modelItem => Model.Categories[i].CategoryName)                            
                        @Html.DisplayFor(modelItem => Model.Categories[i].CategoryName)                            
                    </td>
                    <td>
                        @Html.EditorFor(modelItem => Model.Categories[i].DailyPurchaseLimit)
                        @Html.HiddenFor(modelItem => Model.Categories[i].DailyPurchaseLimit)                            
                        @Html.ValidationMessageFor(modelItem => Model.Categories[i].DailyPurchaseLimit)
                    </td>
                    <td style="text-align: center">
                        @Html.EditorFor(modelItem => Model.Categories[i].IsSelected)
                        @Html.HiddenFor(modelItem => Model.Categories[i].IsSelected)                            
                    </td>
                </tr>
            }

Comecei a vasculhar o código-fonte de HiddenFor, e acho que o obstáculo que você está vendo é que seu objeto complexo MyListnão é implicitamente conversível em tipo string, portanto, a estrutura trata seu Modelvalor como nulle torna o valueatributo vazio.

Você pode dar uma olhada nesta solução .

Coloque apenas HiddenFor dentro do EditorTemplate.

E em sua visão coloque isto: @Html.EditorFor(model => model.MyList)

Deve funcionar.

Enfrentou o mesmo problema. Sem o loop for, ele postou apenas o primeiro elemento da lista. Depois de iterar pelo loop for, ele pode manter a lista completa e postar com sucesso.

 @if (Model.MyList!= null)
    {
    for (int i = 0; i < Model.MyList.Count; i++)
      {
        @Html.HiddenFor(x => x.MyList[i])
      }
    }

Outra opção seria:

<input type="hidden" value=@(string.Join(",", Model.MyList)) />

O foreachloop em vez de um forloop pode ser uma solução ligeiramente mais limpa.

@foreach(var item in Model.ToGroups)
{
    @Html.HiddenFor(model => item)
}

Outra maneira possível de corrigir isso seria dar a cada objeto em sua lista um ID e, em seguida, usar @Html.DropDownListFor(model => model.IDs)e preencher uma matriz que contém os IDs.

talvez tarde, mas criei um método de extensão para campos ocultos da coleção (com itens de tipo de dados simples):

Então aqui está:

/// <summary>
/// Returns an HTML hidden input element for each item in the object's property (collection) that is represented by the specified expression.
/// </summary>
public static IHtmlString HiddenForCollection<TModel, TProperty>(this HtmlHelper<TModel> html, Expression<Func<TModel, TProperty>> expression) where TProperty : ICollection
{
    var model = html.ViewData.Model;
    var property = model != null
                ? expression.Compile().Invoke(model)
                : default(TProperty);

    var result = new StringBuilder();
    if (property != null && property.Count > 0)
    {
        for(int i = 0; i < property.Count; i++)
        {
            var modelExp = expression.Parameters.First();
            var propertyExp = expression.Body;
            var itemExp = Expression.ArrayIndex(propertyExp, Expression.Constant(i));

            var itemExpression = Expression.Lambda<Func<TModel, object>>(itemExp, modelExp);

            result.AppendLine(html.HiddenFor(itemExpression).ToString());
        }
    }

    return new MvcHtmlString(result.ToString());
}

O uso é tão simples quanto:

@Html.HiddenForCollection(m => m.MyList)