Come mantenere un oggetto complesso nella vista durante l'aggiornamento di una piccola porzione

Question

Ho la sensazione che questa potrebbe essere una domanda di base!

Ho un oggetto complesso, ovvero un oggetto documento che contiene proprietà che sono elenchi di altri oggetti. È stato creato deserializzando alcuni XML.

vorrei passare l'intero modello alla vista

Return ViewResult(MyDoc) 

Nella visualizzazione alcune proprietà vengono modificati. Il controllo viene quindi restituito al Post Controller:

 [AcceptVerbs(HttpVerbs.Post)] 
    public ActionResult Index(Document myDoc) 

"myDoc" rappresenta solo i campi del mio modulo. Sospetto che questo sia ModelBinding al lavoro. Quindi suppongo di dover mantenere il mio oggetto complesso in un campo nascosto (ad esempio sarebbe fantastico) o come oggetto di sessione. Tuttavia, sono un po 'confuso su come il mio campo aggiornato viene ricollegato all'oggetto persistente (nascosto o sessione).

Answer 1

Hai ragione, questo è il modello vincolante al lavoro.

Il legame avviene quasi automaticamente quando si utilizza HtmlHelpers quali:

@Html.TextboxFor(model => model.PropertyName) 

Questa linea crea effettivamente qualcosa di un po 'come questo:

<input type="textbox" id="Modelobject_PropertyName" name="ModelObject.PropertyName" /> 

Poi, quando si invia il modulo, il DefaultModelBinder è in grado di deserializzare il valore POST e creare e oggetto del tipo specificato (almeno ci proverà), se non riesce a trovare una voce corrispondente, la proprietà sarà nullo e se una voce non ha alcuna proprietà corrispondente, sarà ignorato (a meno che tu non lo sia hai altri parametri).

È possibile leggere questo article è un po 'vecchio, ma è ancora abbastanza preciso.

Come un exemple:

Diciamo si dispone di un semplice oggetto:

public class IndexModel 
{ 
    public string MyProperty { get; set; } 
    public bool MyCheckbox { get; set; } 
} 

Un semplice controler:

public class TestingController : Controller 
{ 
    [OutputCache(Duration=0, NoStore = true)] 
    public ActionResult Index() 
    { 
     return View(new IndexModel { MyProperty = "hi" }); 
    } 

    [HttpPost] 
    [OutputCache(Duration=0, NoStore = true)] 
    public ActionResult Index(IndexModel model) 
    { 
     model.MyProperty += "!"; 
     ModelState.Clear(); 
     return View(model); 
    } 
} 

E una semplice visione:

@model MvcApp.Models.IndexModel 

@using (Html.BeginForm()) 
{ 
    <div> 
     @Html.LabelFor(model => model.MyProperty)<p /> 
     @Html.TextBoxFor(model => model.MyProperty) 
    </div> 
    <div> 
     @Html.LabelFor(model => model.MyCheckbox)<p /> 
     @Html.CheckBoxFor(model => model.MyCheckbox) 
    </div> 

    <input type="submit" /> 
} 

Vedrai, quando y Invia il modulo, che il modello è ricreato completamente.

Se non si desidera visualizzare il valore effettivo di una proprietà, ma ancora bisogno persistito:

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

Questo genererà un campo nascosto che verrà pubblicato indietro e, per questo, persisteva.

Felice codifica!

Answer 2

È necessario memorizzare l'oggetto di grandi dimensioni nella vista?

Il View sembra non avere alcun controllo su quel contenuto, quindi probabilmente non si desidera inviare tutti i dati allo View. Sembra che tu stia applicando una mentalità basata su ViewState, che non si adatta molto bene a MVC, IMHO.

La comunicazione tra lo View e lo Controller avviene tramite ViewModels e di solito non è necessario memorizzare alcun grande numero di dati serializzati e spostarsi avanti e indietro quando si interagisce con il server.

Non riesci a creare un ViewModel che rappresenta solo i dati utili per la vista (i campi), e ottenere che i dati indietro nella vostra Action ricevendo il ViewModel durante il POST, e poi sincronizzare le informazioni si è ottenuto dalla vista con cosa carichi dal tuo XML solo in quel momento?