ASP.Net MVC Html.HiddenFor con valore errato

Sto usando MVC 3 nel mio progetto e sto riscontrando un comportamento molto strano.

Sto cercando di creare un campo nascosto per un determinato valore sul mio modello, il problema è che per qualche motivo il valore impostato sul campo non corrisponde al valore nel modello.

per esempio

Ho questo codice, proprio come un test:

<%:Html.Hidden("Step2", Model.Step) %>
<%:Html.HiddenFor(m => m.Step) %>

Penserei che entrambi i campi nascosti avrebbero lo stesso valore. Quello che faccio è impostare il valore su 1 la prima volta che visualizzo la vista, quindi dopo l'invio aumento il valore del campo Modello di 1.

Quindi, la prima volta che eseguo il rendering della pagina entrambi i controlli hanno il valore 1, ma la seconda volta i valori renderizzati sono questi:

<input id="Step2" name="Step2" type="hidden" value="2" />
<input id="Step" name="Step" type="hidden" value="1" />

Come puoi vedere, il primo valore è corretto, ma il secondo valore sembra essere lo stesso della prima volta che visualizzo la vista.

Cosa mi sto perdendo? Gli helper * For Html memorizzano nella cache i valori in qualche modo? In tal caso, come posso disabilitare questa memorizzazione nella cache ?.

Grazie per l'aiuto.

È normale ed è così che funzionano gli helper HTML. Utilizzano innanzitutto il valore della richiesta POST e successivamente il valore nel modello. Ciò significa che anche se si modifica il valore del modello nell'azione del controller se è presente la stessa variabile nella richiesta POST, la modifica verrà ignorata e verrà utilizzato il valore POST.

Una possibile soluzione alternativa è rimuovere questo valore dallo stato del modello nell'azione del controller che sta tentando di modificare il valore:

// remove the Step variable from the model state 
// if you want the changes in the model to be
// taken into account
ModelState.Remove("Step");
model.Step = 2;

Un'altra possibilità è quella di scrivere un helper HTML personalizzato che utilizzerà sempre il valore del modello e ignorerà i valori POST.

E ancora un'altra possibilità:

<input type="hidden" name="Step" value="<%: Model.Step %>" />

Ho riscontrato lo stesso problema durante la scrittura di una procedura guidata che mostra parti diverse di un modello più grande ad ogni passaggio.
I dati e / o gli errori del "Passaggio 1" sarebbero confusi con il "Passaggio 2", ecc., Fino a quando non mi sarei finalmente reso conto che ModelState era da biasimare.

Questa era la mia soluzione semplice:

if (oldPageIndex != newPageIndex)
{
    ModelState.Clear(); // <-- solution
}

return View(model[newPageIndex]);

Questo codice non funzionerà

// remove the Step variable from the model state
// if you want the changes in the model to be
// taken into account
ModelState.Remove("Step");
model.Step = 2;

... perché HiddenFor legge sempre (!) da ModelState non il modello stesso. E se non trova il tasto "Step" produrrà il valore predefinito per quel tipo di variabile che sarà 0 in questo caso

Ecco la soluzione L'ho scritto per me stesso ma non dispiace condividerlo perché vedo che molte persone stanno lottando con questo giocherellona aiutante nascosto.

public static class CustomExtensions
{
    public static MvcHtmlString HiddenFor2<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
    {
        ReplacePropertyState(htmlHelper, expression);
        return htmlHelper.HiddenFor(expression);
    }

    public static MvcHtmlString HiddenFor2<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes)
    {
        ReplacePropertyState(htmlHelper, expression);
        return htmlHelper.HiddenFor(expression, htmlAttributes);
    }

    public static MvcHtmlString HiddenFor2<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
    {
        ReplacePropertyState(htmlHelper, expression);
        return htmlHelper.HiddenFor(expression, htmlAttributes);
    }

    private static void ReplacePropertyState<TModel, TProperty>(HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
    {
        string text = ExpressionHelper.GetExpressionText(expression);
        string fullName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(text);
        ModelStateDictionary modelState = htmlHelper.ViewContext.ViewData.ModelState;
        ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

        if (modelState.ContainsKey(fullName))
        {                
            ValueProviderResult currentValue = modelState[fullName].Value;
            modelState[fullName].Value = new ValueProviderResult(metadata.Model, Convert.ToString(metadata.Model), currentValue.Culture);
        }
        else
        {
            modelState[fullName] = new ModelState
            {
                Value = new ValueProviderResult(metadata.Model, Convert.ToString(metadata.Model), CultureInfo.CurrentUICulture)
            };
        }
    }
}

Quindi lo usi come al solito dalla tua vista:

@Html.HiddenFor2(m => m.Id)

Vale la pena ricordare che funziona anche con le collezioni.

Sono troppo alle prese con la stessa situazione che penso, in cui utilizzo lo stesso stato del modello tra le chiamate e quando modifico una proprietà del modello nel backend. Tuttavia, per me non importa se uso textboxfor o hiddenfor.

Ho semplicemente aggirato la situazione usando gli script di pagina per memorizzare il valore del modello come variabile js, perché all'inizio ho bisogno del campo nascosto per quello scopo.

Non sono sicuro se questo aiuta, ma considera solo ..