Come usare knockout.js con ASP.NET MVC ViewModels?


129

generosità

È passato un po 'di tempo e ho ancora un paio di domande in sospeso. Spero che aggiungendo una taglia forse queste domande avranno una risposta.

  1. Come si utilizzano gli helper HTML con knockout.js
  2. Perché era pronto il documento necessario per farlo funzionare (vedere la prima modifica per ulteriori informazioni)

  3. Come posso fare una cosa del genere se utilizzo la mappatura ad eliminazione diretta con i miei modelli di visualizzazione? Come non ho una funzione a causa della mappatura.

    function AppViewModel() {
    
        // ... leave firstName, lastName, and fullName unchanged here ...
    
        this.capitalizeLastName = function() {
    
        var currentVal = this.lastName();        // Read the current value
    
        this.lastName(currentVal.toUpperCase()); // Write back a modified value
    
    };
    
  4. Voglio usare i plugin, ad esempio, voglio essere in grado di eseguire il rollback di osservabili come se un utente annulla una richiesta, voglio poter tornare all'ultimo valore. Dalla mia ricerca questo sembra essere realizzato da persone che creano plugin come modificabili

    Come posso usare qualcosa del genere se sto usando la mappatura? Non voglio davvero andare a un metodo in cui ho nella mia vista la mappatura manuale dove mappo ogni campo MVC viewMode su un campo del modello KO perché voglio il minor javascript in linea possibile e che sembra solo il doppio del lavoro e questo è perché mi piace quella mappatura.

  5. Sono preoccupato che per semplificare questo lavoro (usando la mappatura) perderò molta potenza KO ma d'altra parte sono preoccupato che la mappatura manuale sarà solo molto lavoro e renderà le mie opinioni contenere troppe informazioni e potrebbe diventare più difficile da mantenere in futuro (ad esempio, se rimuovo una proprietà nel modello MVC, devo spostarla anche nel modello KO)


Posta originale

Sto usando asp.net mvc 3 e sto osservando il knockout perché sembra piuttosto bello, ma sto facendo fatica a capire come funziona con asp.net mvc in particolare per visualizzare i modelli.

Per me adesso faccio qualcosa del genere

 public class CourseVM
    {
        public int CourseId { get; set; }
        [Required(ErrorMessage = "Course name is required")]
        [StringLength(40, ErrorMessage = "Course name cannot be this long.")]
        public string CourseName{ get; set; }


        public List<StudentVm> StudentViewModels { get; set; }

}

Avrei un Vm che ha alcune proprietà di base come CourseName e avrà anche una semplice convalida. Il modello Vm potrebbe contenere anche altri modelli di vista, se necessario.

Vorrei quindi passare questo Vm alla vista dove userei gli helper HTML per aiutarmi a mostrarlo all'utente.

@Html.TextBoxFor(x => x.CourseName)

Potrei avere alcuni loop foreach o qualcosa per estrarre i dati dalla raccolta di Student View Models.

Quindi, quando avrei serialize arrayinviato il modulo, avrei usato jquery e lo avrei inviato a un metodo di azione del controller che lo avrebbe ricollegato al viewmodel.

Con knockout.js è tutto diverso dato che ora hai viewmodels per questo e da tutti gli esempi che ho visto non usano gli helper HTML.

Come utilizzate queste 2 funzionalità di MVC con knockout.js?

Ho trovato questo video e brevemente (ultimi minuti del video @ 18:48) entra in un modo per usare i viewmodels fondamentalmente avendo uno script inline che ha il viewmodel knockout.js a cui vengono assegnati i valori nel ViewModel.

È questo l'unico modo per farlo? Che ne dici nel mio esempio di avere una raccolta di modelli di visualizzazione? Devo avere un ciclo foreach o qualcosa per estrarre tutti i valori e assegnarlo in knockout?

Per quanto riguarda gli helper HTML, il video non dice nulla su di loro.

Queste sono le 2 aree che mi confondono poiché non molte persone sembrano parlarne e mi lascia confuso su come i valori iniziali e tutto ciò che viene alla vista quando ogni esempio è solo un esempio di valore codificato.


modificare

Sto provando ciò che Darin Dimitrov ha suggerito e questo sembra funzionare (ho dovuto apportare alcune modifiche al suo codice). Non sono sicuro del motivo per cui ho dovuto usare il documento pronto, ma in qualche modo tutto non era pronto senza di esso.

@model MvcApplication1.Models.Test

@{
    Layout = null;
}

<!DOCTYPE html>

<html>
<head>
    <title>Index</title>
    <script src="../../Scripts/jquery-1.5.1.js" type="text/javascript"></script>
    <script src="../../Scripts/knockout-2.1.0.js" type="text/javascript"></script>
    <script src="../../Scripts/knockout.mapping-latest.js" type="text/javascript"></script>
   <script type="text/javascript">

   $(function()
   {
      var model = @Html.Raw(Json.Encode(Model));


// Activates knockout.js
ko.applyBindings(model);
   });

</script>

</head>
<body>
    <div>
        <p>First name: <strong data-bind="text: FirstName"></strong></p>
        <p>Last name: <strong data-bind="text: LastName"></strong></p>
        @Model.FirstName , @Model.LastName
    </div>
</body>
</html>

Ho dovuto avvolgerlo attorno a un documento jquery pronto per farlo funzionare.

Ricevo anche questo avviso. Non sono sicuro di cosa si tratti.

Warning 1   Conditional compilation is turned off   -> @Html.Raw

Quindi ho un punto di partenza, immagino che aggiornerò quando avrò fatto un po 'di più giocando e come funzionerà.

Sto provando a seguire i tutorial interattivi, ma uso invece un ViewModel.

Non sono ancora sicuro di come affrontare queste parti

function AppViewModel() {
    this.firstName = ko.observable("Bert");
    this.lastName = ko.observable("Bertington");
}

o

function AppViewModel() {
    // ... leave firstName, lastName, and fullName unchanged here ...

    this.capitalizeLastName = function() {
        var currentVal = this.lastName();        // Read the current value
        this.lastName(currentVal.toUpperCase()); // Write back a modified value
    };


Modifica 2

Sono stato in grado di capire il primo problema. Nessun indizio sul secondo problema. Eppure però. Qualcuno ha qualche idea?

 @model MvcApplication1.Models.Test

    @{
        Layout = null;
    }

    <!DOCTYPE html>

    <html>
    <head>
        <title>Index</title>
        <script src="../../Scripts/jquery-1.5.1.js" type="text/javascript"></script>
        <script src="../../Scripts/knockout-2.1.0.js" type="text/javascript"></script>
        <script src="../../Scripts/knockout.mapping-latest.js" type="text/javascript"></script>
       <script type="text/javascript">

       $(function()
       {
        var model = @Html.Raw(Json.Encode(Model));
        var viewModel = ko.mapping.fromJS(model);
        ko.applyBindings(viewModel);

       });

    </script>

    </head>
    <body>
        <div>
            @*grab values from the view model directly*@
            <p>First name: <strong data-bind="text: FirstName"></strong></p>
            <p>Last name: <strong data-bind="text: LastName"></strong></p>

            @*grab values from my second view model that I made*@
            <p>SomeOtherValue <strong data-bind="text: Test2.SomeOtherValue"></strong></p>
            <p>Another <strong data-bind="text: Test2.Another"></strong></p>

            @*allow changes to all the values that should be then sync the above values.*@
            <p>First name: <input data-bind="value: FirstName" /></p>
            <p>Last name: <input data-bind="value: LastName" /></p>
            <p>SomeOtherValue <input data-bind="value: Test2.SomeOtherValue" /></p>
            <p>Another <input data-bind="value: Test2.Another" /></p>

           @* seeing if I can do it with p tags and see if they all update.*@
            <p data-bind="foreach: Test3">
                <strong data-bind="text: Test3Value"></strong> 
            </p>

     @*took my 3rd view model that is in a collection and output all values as a textbox*@       
    <table>
        <thead><tr>
            <th>Test3</th>
        </tr></thead>
          <tbody data-bind="foreach: Test3">
            <tr>
                <td>    
                    <strong data-bind="text: Test3Value"></strong> 
<input type="text" data-bind="value: Test3Value"/>
                </td>
            </tr>    
        </tbody>
    </table>

controllore

  public ActionResult Index()
    {
              Test2 test2 = new Test2
        {
            Another = "test",
            SomeOtherValue = "test2"
        };

        Test vm = new Test
        {
            FirstName = "Bob",
            LastName = "N/A",
             Test2 = test2,

        };
        for (int i = 0; i < 10; i++)
        {
            Test3 test3 = new Test3
            {
                Test3Value = i.ToString()
            };

             vm.Test3.Add(test3);
        }

        return View(vm);
    }

2
Ho appena scritto un post sul blog per rispondere a un'altra domanda simile: roysvork.wordpress.com/2012/12/09/… Potrebbe non rispondere completamente alla tua domanda, ma ti dà una buona idea di come potrebbero funzionare le cose. Spero di poterlo seguire con un altro post in un futuro non troppo lontano. Sentiti libero di farmi qualsiasi domanda nei commenti sul post o qui se hai bisogno di maggiori informazioni.
oltre il codice

Risposte:


180

Penso di aver riassunto tutte le tue domande, se ho perso qualcosa per favore fammi sapere ( Se potessi riassumere tutte le tue domande in un posto sarebbe bello =))

Nota. Compatibilità con il ko.editableplug-in aggiunto

Scarica il codice completo

Come si utilizzano gli helper HTML con knockout.js

Questo è facile:

@Html.TextBoxFor(model => model.CourseId, new { data_bind = "value: CourseId" })

Dove:

  • value: CourseIdindica che si sta vincolando la valueproprietà del inputcontrollo con la CourseIdproprietà del modello e del modello di script

Il risultato è:

<input data-bind="value: CourseId" data-val="true" data-val-number="The field CourseId must be a number." data-val-required="The CourseId field is required." id="CourseId" name="CourseId" type="text" value="12" />

Perché era pronto il documento necessario per farlo funzionare (vedere la prima modifica per ulteriori informazioni)

Non capisco ancora perché è necessario utilizzare l' readyevento per serializzare il modello, ma sembra che sia semplicemente necessario (non preoccuparsene però)

Come posso fare una cosa del genere se utilizzo la mappatura ad eliminazione diretta con i miei modelli di visualizzazione? Come non ho una funzione a causa della mappatura.

Se ho capito bene, devi aggiungere un nuovo metodo al modello KO, è facile unire i modelli

Per maggiori informazioni, nella sezione -Mapping da fonti diverse-

function viewModel() {
    this.addStudent = function () {
        alert("de");
    };
};

$(function () {
    var jsonModel = '@Html.Raw(JsonConvert.SerializeObject(this.Model))';
    var mvcModel = ko.mapping.fromJSON(jsonModel);

    var myViewModel = new viewModel();
    var g = ko.mapping.fromJS(myViewModel, mvcModel);

    ko.applyBindings(g);
});

A proposito dell'avviso che stavi ricevendo

Avviso 1 La compilazione condizionale è disattivata -> @ Html.Raw

Devi usare le virgolette

Compatibilità con il plug-in ko.editable

Ho pensato che sarebbe stato più complesso, ma risulta che l'integrazione è davvero semplice, per rendere modificabile il tuo modello basta aggiungere la seguente riga: (ricorda che in questo caso sto usando un modello misto, dal server e l'aggiunta di estensione nel client e il modificabile funziona semplicemente ... è fantastico):

    ko.editable(g);
    ko.applyBindings(g);

Da qui devi solo giocare con i tuoi binding usando le estensioni aggiunte dal plug-in, ad esempio, ho un pulsante per iniziare a modificare i miei campi in questo modo e in questo pulsante inizio il processo di modifica:

    this.editMode = function () {
        this.isInEditMode(!this.isInEditMode());
        this.beginEdit();
    };

Quindi ho i pulsanti di commit e di annullamento con il seguente codice:

    this.executeCommit = function () {
        this.commit();
        this.isInEditMode(false);
    };
    this.executeRollback = function () {
        if (this.hasChanges()) {
            if (confirm("Are you sure you want to discard the changes?")) {
                this.rollback();
                this.isInEditMode(false);
            }
        }
        else {
            this.rollback();
            this.isInEditMode(false);
        }
    };

E infine, ho un campo per indicare se i campi sono in modalità di modifica o meno, questo è solo per associare la proprietà enable.

this.isInEditMode = ko.observable(false);

Informazioni sulla tua domanda di matrice

Potrei avere alcuni loop foreach o qualcosa per estrarre i dati dalla raccolta di Student View Models.

Quindi, quando avrei inviato il modulo, avrei usato jquery e serializzato l'array e lo avrei inviato a un metodo di azione del controller che lo avrebbe ricollegato al viewmodel.

Puoi fare lo stesso con KO, nel seguente esempio, creerò il seguente output:

inserisci qui la descrizione dell'immagine

Fondamentalmente qui, hai due elenchi, creati utilizzando Helperse associati a KO, hanno un dblClickevento associato che quando viene attivato, rimuove l'elemento selezionato dall'elenco corrente e lo aggiunge all'altro elenco, quando pubblichi su Controller, il contenuto di ciascuno l'elenco viene inviato come dati JSON e ricollegato al modello di server

Nuggets:

Script esterni .

Codice del controller

    [HttpGet]
    public ActionResult Index()
    {
        var m = new CourseVM { CourseId = 12, CourseName = ".Net" };

        m.StudentViewModels.Add(new StudentVm { ID = 545, Name = "Name from server", Lastname = "last name from server" });

        return View(m);
    }

    [HttpPost]
    public ActionResult Index(CourseVM model)
    {
        if (!string.IsNullOrWhiteSpace(model.StudentsSerialized))
        {
            model.StudentViewModels = JsonConvert.DeserializeObject<List<StudentVm>>(model.StudentsSerialized);
            model.StudentsSerialized = string.Empty;
        }

        if (!string.IsNullOrWhiteSpace(model.SelectedStudentsSerialized))
        {
            model.SelectedStudents = JsonConvert.DeserializeObject<List<StudentVm>>(model.SelectedStudentsSerialized);
            model.SelectedStudentsSerialized = string.Empty;
        }

        return View(model);
    }

Modello

public class CourseVM
{
    public CourseVM()
    {
        this.StudentViewModels = new List<StudentVm>();
        this.SelectedStudents = new List<StudentVm>();
    }

    public int CourseId { get; set; }

    [Required(ErrorMessage = "Course name is required")]
    [StringLength(100, ErrorMessage = "Course name cannot be this long.")]
    public string CourseName { get; set; }

    public List<StudentVm> StudentViewModels { get; set; }
    public List<StudentVm> SelectedStudents { get; set; }

    public string StudentsSerialized { get; set; }
    public string SelectedStudentsSerialized { get; set; }
}

public class StudentVm
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string Lastname { get; set; }
}

Pagina CSHTML

@using (Html.BeginForm())
{
    @Html.ValidationSummary(true)
    <fieldset>
        <legend>CourseVM</legend>

        <div>
            <div class="editor-label">
                @Html.LabelFor(model => model.CourseId)
            </div>
            <div class="editor-field">
                @Html.TextBoxFor(model => model.CourseId, new { data_bind = "enable: isInEditMode, value: CourseId" })
                @Html.ValidationMessageFor(model => model.CourseId)
            </div>

            <div class="editor-label">
                @Html.LabelFor(model => model.CourseName)
            </div>
            <div class="editor-field">
                @Html.TextBoxFor(model => model.CourseName, new { data_bind = "enable: isInEditMode, value: CourseName" })
                @Html.ValidationMessageFor(model => model.CourseName)
            </div>
            <div class="editor-label">
                @Html.LabelFor(model => model.StudentViewModels);
            </div>
            <div class="editor-field">

                @Html.ListBoxFor(
                    model => model.StudentViewModels,
                    new SelectList(this.Model.StudentViewModels, "ID", "Name"),
                    new
                    {
                        style = "width: 37%;",
                        data_bind = "enable: isInEditMode, options: StudentViewModels, optionsText: 'Name', value: leftStudentSelected, event: { dblclick: moveFromLeftToRight }"
                    }
                )
                @Html.ListBoxFor(
                    model => model.SelectedStudents,
                    new SelectList(this.Model.SelectedStudents, "ID", "Name"),
                    new
                    {
                        style = "width: 37%;",
                        data_bind = "enable: isInEditMode, options: SelectedStudents, optionsText: 'Name', value: rightStudentSelected, event: { dblclick: moveFromRightToLeft }"
                    }
                )
            </div>

            @Html.HiddenFor(model => model.CourseId, new { data_bind="value: CourseId" })
            @Html.HiddenFor(model => model.CourseName, new { data_bind="value: CourseName" })
            @Html.HiddenFor(model => model.StudentsSerialized, new { data_bind = "value: StudentsSerialized" })
            @Html.HiddenFor(model => model.SelectedStudentsSerialized, new { data_bind = "value: SelectedStudentsSerialized" })
        </div>

        <p>
            <input type="submit" value="Save" data-bind="enable: !isInEditMode()" /> 
            <button data-bind="enable: !isInEditMode(), click: editMode">Edit mode</button><br />
            <div>
                <button data-bind="enable: isInEditMode, click: addStudent">Add Student</button>
                <button data-bind="enable: hasChanges, click: executeCommit">Commit</button>
                <button data-bind="enable: isInEditMode, click: executeRollback">Cancel</button>
            </div>
        </p>
    </fieldset>
}

Script

<script src="@Url.Content("~/Scripts/jquery-1.7.2.min.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/knockout-2.1.0.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/knockout.mapping-latest.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/ko.editables.js")" type="text/javascript"></script>

<script type="text/javascript">
    var g = null;
    function ViewModel() {
        this.addStudent = function () {
            this.StudentViewModels.push(new Student(25, "my name" + new Date(), "my last name"));
            this.serializeLists();
        };
        this.serializeLists = function () {
            this.StudentsSerialized(ko.toJSON(this.StudentViewModels));
            this.SelectedStudentsSerialized(ko.toJSON(this.SelectedStudents));
        };
        this.leftStudentSelected = ko.observable();
        this.rightStudentSelected = ko.observable();
        this.moveFromLeftToRight = function () {
            this.SelectedStudents.push(this.leftStudentSelected());
            this.StudentViewModels.remove(this.leftStudentSelected());
            this.serializeLists();
        };
        this.moveFromRightToLeft = function () {
            this.StudentViewModels.push(this.rightStudentSelected());
            this.SelectedStudents.remove(this.rightStudentSelected());
            this.serializeLists();
        };
        this.isInEditMode = ko.observable(false);
        this.executeCommit = function () {
            this.commit();
            this.isInEditMode(false);
        };
        this.executeRollback = function () {
            if (this.hasChanges()) {
                if (confirm("Are you sure you want to discard the changes?")) {
                    this.rollback();
                    this.isInEditMode(false);
                }
            }
            else {
                this.rollback();
                this.isInEditMode(false);
            }
        };
        this.editMode = function () {
            this.isInEditMode(!this.isInEditMode());
            this.beginEdit();
        };
    }

    function Student(id, name, lastName) {
        this.ID = id;
        this.Name = name;
        this.LastName = lastName;
    }

    $(function () {
        var jsonModel = '@Html.Raw(JsonConvert.SerializeObject(this.Model))';
        var mvcModel = ko.mapping.fromJSON(jsonModel);

        var myViewModel = new ViewModel();
        g = ko.mapping.fromJS(myViewModel, mvcModel);

        g.StudentsSerialized(ko.toJSON(g.StudentViewModels));
        g.SelectedStudentsSerialized(ko.toJSON(g.SelectedStudents));

        ko.editable(g);
        ko.applyBindings(g);
    });
</script>

Nota: ho appena aggiunto queste righe:

        @Html.HiddenFor(model => model.CourseId, new { data_bind="value: CourseId" })
        @Html.HiddenFor(model => model.CourseName, new { data_bind="value: CourseName" })

Perché quando invio il modulo i miei campi sono disabilitati, quindi i valori non sono stati trasmessi al server, ecco perché ho aggiunto un paio di campi nascosti per fare il trucco


Hmm molto istruttivo. Dalla tua risposta e dalla risposta di Pual penso di aver quasi risposto a tutte le mie domande, tranne come usare plugin come modificabili. Spero che qualcuno sappia come posso usarlo.
chobo2,

1
Ho appena aggiunto la compatibilità con il ko.editablesplug-in, puoi controllare la risposta aggiornata o, se vuoi, puoi scaricare l'intero progetto per eseguirlo localmente
Jupaol

Lo controllerò quando posso. Sono cambiate molte cose per farlo funzionare? Mi chiedo se per ogni plugin trovo se dovrò modificarlo e quindi mantenere la mia versione.
chobo2,

No.
Rimarrai

1
Grazie a un gruppo, ho imparato diverse nuove strategie dalla tua risposta. Complimenti!
sky-dev

23

È possibile serializzare il modello di visualizzazione ASP.NET MVC in una variabile javascript:

@model CourseVM
<script type="text/javascript">
    var model = @Html.Raw(Json.Encode(Model));
    // go ahead and use the model javascript variable to bind with ko
</script>

Ci sono molti esempi nella documentazione a eliminazione diretta che potresti consultare.


1
Sì, ho seguito il tutorial interattivo che hanno sul sito, ma in realtà non vedo mai nulla a che fare con asp.net mvc. Vedo che hanno anche alcuni plugin di mappatura ma non sono sicuro di come si adatta. Nel tuo esempio come lo legheresti al modello knockout (in un altro script). Voglio davvero avere il minor javascript in linea possibile (non è preferibile ma immagino non sia possibile)
chobo2

2
Quale problema stai cercando di risolvere? Se vuoi viste MVC e sei soddisfatto di come usarle, puoi restare lì. Se desideri l'associazione e la manipolazione dei dati lato client, KO è un'ottima scelta. Potresti generare il tuo modello di visualizzazione KO dal tuo codice MVC come mostra questa risposta. Prende il VM e lo serializza su JSON. Quindi sul client è possibile mappare i risultati su un modello di visualizzazione javascript. Quindi associa il modello di visualizzazione alla vista e sei pronto. La chiave è che MVC e KO non devono essere accoppiati in alcun modo, a meno che tu non voglia che siano. Dipende tutto dal problema che stai cercando di risolvere.
John Papa,

1
È normale che non vedi nulla a che fare con asp.net mvc. Knockout è un framework lato client. Non sa né importa quale lingua lato server stai utilizzando. Quei 2 quadri dovrebbero essere assolutamente disaccoppiati.
Darin Dimitrov,

@JohnPapa - Mi piace il modo in cui faccio le cose ora, ma mi piace anche imparare cose nuove (vedo che KO può essere molto utile in alcune situazioni). So che KO è uno script lato client, ma per me li vedo lavorare insieme. Attualmente generi le mie visualizzazioni utilizzando i modelli di visualizzazione e gli helper HTML. Quindi nella mia mente KO ha bisogno di collaborare con questo. Ad esempio, supponi di avere una finestra di modifica. Come progettare e popolare i valori da un db in quei campi. Se stavo usando la mia strada sarebbe una vista di helper HTML che ha un viewModel. Popolerebbe il modello di visualizzazione e lo invierebbe tramite il metodo di azione e lo userebbe.
chobo2,

1
@ chobo2, knockout è un framework lato client. Utilizza i modelli di visualizzazione sul client per implementare il modello MVC sul client. Il server è disaccoppiato. Puoi anche usare i modelli di visualizzazione su di esso. Sono solo 2 posti diversi. Se hai una logica complessa che vuoi implementare sul client usando JavaScript, knockout potrebbe semplificarlo. Altrimenti, onestamente, non ne hai bisogno.
Darin Dimitrov,

2

Per ottenere le proprietà calcolate aggiuntive dopo il mapping del server, sarà necessario migliorare ulteriormente i modelli di visualizzazione sul lato client.

Per esempio:

var viewModel = ko.mapping.fromJS(model);

viewModel.capitalizedName = ko.computed(function() {...}, viewModel);

Quindi ogni volta che esegui il mapping da JSON non elaborato, dovrai riapplicare le proprietà calcolate.

Inoltre, il plug-in di mappatura offre la possibilità di aggiornare in modo incrementale un modello di visualizzazione anziché ricrearlo ogni volta che si va avanti e indietro (utilizzare un parametro aggiuntivo in fromJS):

// Every time data is received from the server:
ko.mapping.fromJS(data, viewModel);

E questo esegue un aggiornamento incrementale dei dati sul tuo modello di sole proprietà che sono mappate. Puoi leggere di più al riguardo nella documentazione sulla mappatura

Nei commenti sulla risposta di Darin hai menzionato il pacchetto FluentJSON . Sono l'autore di questo, ma il suo caso d'uso è più specifico di ko.mapping. Generalmente lo userei solo se i tuoi modelli di visualizzazione sono a senso unico (es. Server -> client) e quindi i dati vengono postati in un formato diverso (o per niente). O se il tuo modello di visualizzazione javascript deve essere in un formato sostanzialmente diverso dal tuo modello di server.


Quindi immagino che forse FluentJSON non sia adatto a me poiché i miei modelli di visualizzazione vanno per lo più in entrambi i modi (di solito lo rimando tramite json e quindi lo associo al modello di visualizzazione nel parametro del metodo di azione). Sai come potrei usare quei plugin che ho citato come modificabili? Infine, sto perdendo qualsiasi tipo di funzionalità utilizzando la mappatura e cercando di utilizzare il mio modello di visualizzazione anziché non utilizzarlo?
chobo2,

Non ho usato nessuno dei plugin, quindi non ne sono sicuro. Quello che ho fatto in passato è stato solo abbonarmi ad ogni modifica e mantenere una serie di viewmodel serializzati che avrei spinto a cambiare e fare clic su Annulla ( vedi questa domanda ).
Paul Tyng,

la mappatura non ti impedisce di alcuna funzionalità, devi solo assicurarti e osservare le sue convenzioni su come gestisce la mappatura da e verso JS per far sì che tutto funzioni bene insieme.
Paul Tyng,

Bene, la risposta accettata alla domanda che hai postato è sostanzialmente quale sarebbe il plugin. Questo è ciò che mi confonde come puoi vedere che creano un modello di visualizzazione e quindi usano la loro funzione che hanno creato (ko.observableArrayWithUndo ([])). Se sto facendo il mapping non so come farlo. L'unica cosa che mi viene in mente è scrivere la mia mappatura (quello che dubito di poter fare in questo momento) che ha annullato osservabile o mappato ogni proprietà ma poi ho fondamentalmente modelli duplicati uno per il lato server e uno per il client e lo sono paura che diventerà non
mantenibile

Ah sì scusa stavo parlando della mia risposta a quella domanda, mi spiace avrebbe dovuto collegarmi direttamente.
Paul Tyng,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.