Sospendi i binding in knockout.js 1.2.1

Question

C'è qualche opzione per sospendere e riprendere i binding in knockout?

Versione: 1.2.1 knockout.js

Il nostro bisogno di sospensione attacchi deriva dai seguenti. Durante alcune operazioni dobbiamo caricare molti dati dal server, ad esempio selezioni multiple hanno cambiato i loro dati interi, ci sono tabelle le cui righe sono aggiunte dinamicamente ecc.

Ora in questo scenario attuale, il modulo è completamente vincolato con il modello di vista. Quando cancelliamo le combo e aggiungiamo ogni elemento, la vista viene aggiornata, quindi c'è un ritardo significativo. Se avessi i mezzi per sospendere l'associazione, potrei sospendere, quindi caricare tutti i dati nel viewmodel e quindi riprendere di nuovo il binding.

Answer 1

Non penso che ci sia un modo per sospendere l'associazione in knockout.js. Senza vedere il codice è difficile dirlo, ma la lentezza è probabilmente causata dal fatto che si aggiornano gli array osservabili cancellandoli e aggiungendo nuovi elementi uno per uno. Invece è possibile aggiornare l'intero array in una volta:

... 
self.manyItems = ko.observableArray(); 
... 
function refreshItems(newItems){ 
    self.manyItems(newItems); 
} 

Answer 2

sospensione e la ripresa è possibile: uno sguardo ad this demo messo insieme da Ryan Niemeyer. Fare riferimento a this entry sul suo blog per ulteriori informazioni di base.

Answer 3

Se hai davvero bisogno di mettere in pausa gli abbonamenti, ho trovato un modo per metterli in pausa in osservabili calcolati con un oggetto PauseableComputato (idea presa da this site). L'ho modificato un po 'per aggiungere il pauseableComputed la capacità di avere funzioni di lettura e scrittura.

viewModel.myComputedObservable = ko.pauseableComputed(function() { 
    return myResult; 
}, viewModel); 

Per la pausa, si chiama myComputedObservable.pause();, fare tutte le modifiche e quindi chiamare myComputedObservable.resume(); per tali modifiche per attivare le sottoscrizioni nel osservabile calcolato.

//wrapper for a computed observable that can pause its subscriptions 
     ko.pauseableComputed = function (evaluatorFunction, evaluatorFunctionTarget) { 
      var _cachedValue = ""; 
      var _isPaused = ko.observable(false); 

      //the computed observable that we will return 
      var result; 
      if (evaluatorFunction.read) { 
       result = ko.computed({ 
        read: function() { 
         if (!_isPaused()) { 
          //call the actual function that was passed in 
          return evaluatorFunction.read.call(evaluatorFunctionTarget); 
         } 
         return _cachedValue; 
        }, 
        write: function(value) { 
         if (!_isPaused()) { 
          //call the actual function that was passed in 
          return evaluatorFunction.write.call(evaluatorFunctionTarget, value); 
         } 
         return _cachedValue; 
        } 
       }, evaluatorFunctionTarget); 
      } else { 
       result = ko.computed(function() { 
        if (!_isPaused()) { 
         //call the actual function that was passed in 
         return evaluatorFunction.call(evaluatorFunctionTarget); 
        } 
        return _cachedValue; 
       }, evaluatorFunctionTarget); 
      }