Suspender enlaces en knockout.js 1.2.1

Question

¿Hay alguna opción para suspender y reanudar enlaces en knockout?

Versión: 1.2.1 knockout.js

Nuestra necesidad de suspender las consolidaciones se deriva de lo siguiente. Durante algunas operaciones tenemos que cargar una gran cantidad de datos del servidor, por ejemplo, múltiples selecciones tienen sus datos completos modificados, hay tablas cuyas filas se agregan dinámicamente, etc.

Ahora en este escenario actual, el formulario está completamente vinculado con el modelo de vista. Cuando borramos los combos y agregamos cada elemento, la vista se actualiza, por lo tanto, hay un retraso significativo. Si tuviera los medios para suspender el enlace, podría suspender, luego cargar todos los datos en el modelo de vista y luego reanudar el enlace nuevamente.

Answer 1

No creo que haya una forma de suspender el enlace en knockout.js. Sin ver el código es difícil de decir, pero la lentitud probablemente se deba al hecho de que usted actualiza sus Arreglos observables al borrarlos y agregar nuevos elementos uno por uno. En su lugar se puede refrescar toda la matriz a la vez:

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

Answer 2

suspender y reanudar es posible: echar un vistazo a this demo elaborado por Ryan Niemeyer. Consulte this entry en su blog para obtener más información.

Answer 3

Si realmente necesita pausar las suscripciones, encontré una forma de pausarlas en observables calculados con una función pauseable (idea tomada de this site). Lo modifiqué un poco para agregar la capacidad de pauseableComputed de tener funciones de lectura y escritura.

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

Para hacer una pausa, se llama a myComputedObservable.pause();, hacer todas sus modificaciones y luego llamar myComputedObservable.resume(); para esas modificaciones para activar las suscripciones en el observables computarizada.

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