@ Html.HiddenFor nie działa na listach w ASP.NET MVC

Używam modelu, który zawiera listę jako właściwość. Zapełniam tę listę elementami pobranymi z SQL Server. Chcę, aby lista była ukryta w widoku i przekazana do akcji POST. Później mogę chcieć dodać więcej elementów do tej listy za pomocą jQuery, co sprawia, że ​​tablica nie nadaje się do późniejszego rozszerzenia. Zwykle używałbyś

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

aby zrealizować tę funkcję, ale z jakiegoś powodu lista w POST jest zawsze pusta.

Bardzo proste pytanie, czy ktoś wie, dlaczego MVC tak się zachowuje?

Właśnie natknąłem się na ten problem i rozwiązałem go, wykonując następujące czynności:

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

Używając for zamiast foreach, powiązanie modelu będzie działać poprawnie i pobierze wszystkie ukryte wartości z listy. Wydaje się, że jest to najprostszy sposób rozwiązania tego problemu.

HiddenFor nie jest jak DisplayFor lub EditorFor. Nie będzie działać z kolekcjami, tylko z pojedynczymi wartościami.

Możesz użyć pomocnika Serialize HTML dostępnego w projekcie MVC Futures do serializacji obiektu do ukrytego pola lub będziesz musiał sam napisać kod. Lepszym rozwiązaniem jest po prostu serializacja jakiegoś identyfikatora i ponowne pobranie danych z bazy danych po ogłoszeniu zwrotnym.

To trochę hack, ale jeśli @Html.EditorForlub @Html.DisplayForpracujesz na twojej liście, jeśli chcesz się upewnić, że jest wysłana w żądaniu postu, ale nie jest widoczna, możesz po prostu zmienić jej styl na użycie, display: none;aby ją ukryć, np .:

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

A co z używaniem Newtonsoft do deserializacji obiektu do łańcucha json, a następnie wstaw go do swojego pola ukrytego, np. ( Model.DataResponse.Entity.Commission to lista prostych obiektów „CommissionRange”, jak zobaczysz w 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]
   }

Renderuje jako:

<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}]">

W moim przypadku robię trochę rzeczy JS, aby edytować json w ukrytym polu przed wysłaniem z powrotem

W moim kontrolerze ponownie używam Newtonsoft do deserializacji:

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

Html.HiddenForjest przeznaczony tylko dla jednej wartości. Będziesz musiał w jakiś sposób serializować swoją listę przed utworzeniem ukrytego pola.

Na przykład, jeśli twoja lista jest typu string, możesz połączyć ją w listę oddzieloną przecinkami, a następnie podzielić listę po wysłaniu z powrotem do kontrolera.

Właśnie dowiedziałem się (po kilku godzinach prób wyjaśnienia, dlaczego wartości modelu nie wracają do kontrolera), że ukryte dla powinny być zgodne z EditorFor.

O ile nie robię czegoś innego źle, to właśnie znalazłem. Nie popełnię ponownie błędu.

W kontekście modelu zawierającego listę innej klasy.

To NIE zadziała:

        @{
            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>
            }
        }

Gdzie to BĘDZIE ......

            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>
            }

Zacząłem przekopywać się w kodzie źródłowym HiddenFori myślę, że przeszkoda, którą widzisz, polega na tym, że twój złożony obiekt MyListnie jest niejawnie konwertowany na typ string, więc struktura traktuje twoją Modelwartość jako nulli renderuje valueatrybut pusty.

Możesz rzucić okiem na to rozwiązanie .

Umieść tylko HiddenFor wewnątrz EditorTemplate.

I w swoim Widoku umieść to: @Html.EditorFor(model => model.MyList)

Powinno działać.

W obliczu tego samego problemu. Bez pętli for wysłał tylko pierwszy element listy. Po wykonaniu iteracji pętli for może zachować pełną listę i pomyślnie wysyłać.

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

Inną opcją byłoby:

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

foreachPętli zamiast forpętli może być nieco roztworu czyszczącego.

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

Innym możliwym sposobem rozwiązania tego problemu byłoby nadanie każdemu obiektowi z listy identyfikatora, a następnie użycie @Html.DropDownListFor(model => model.IDs)i wypełnienie tablicy, która przechowuje identyfikatory.

może późno, ale stworzyłem metodę rozszerzenia dla ukrytych pól z kolekcji (z prostymi elementami typu danych):

Więc oto jest:

/// <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());
}

Użycie jest tak proste, jak:

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