protected AsyncCallback PrepareAsyncCompletion(AsyncCompletion callback) { if (_beforePrepareAsyncCompletionAction != null) { _beforePrepareAsyncCompletionAction(); } _nextAsyncCompletion = callback; if (AsyncResult.s_asyncCompletionWrapperCallback == null) { AsyncResult.s_asyncCompletionWrapperCallback = Fx.ThunkCallback(new AsyncCallback(AsyncCompletionWrapperCallback)); } return(AsyncResult.s_asyncCompletionWrapperCallback); }
public bool FlushBookmarkScopeKeys(ActivityExecutor executor) { Fx.Assert(executor.BookmarkScopeManager.HasKeysToUpdate, "We should not have been called if we don't have pending keys."); try { // disassociation is local-only so we don't need to yield ICollection <InstanceKey> keysToDisassociate = executor.BookmarkScopeManager.GetKeysToDisassociate(); if (keysToDisassociate != null && keysToDisassociate.Count > 0) { executor.DisassociateKeys(keysToDisassociate); } // if we have keys to associate, provide them for an asynchronous association ICollection <InstanceKey> keysToAssociate = executor.BookmarkScopeManager.GetKeysToAssociate(); // It could be that we only had keys to Disassociate. We should only do BeginAssociateKeys // if we have keysToAssociate. if (keysToAssociate != null && keysToAssociate.Count > 0) { if (s_associateCallback == null) { s_associateCallback = Fx.ThunkCallback(new AsyncCallback(OnAssociateComplete)); } IAsyncResult result = executor.BeginAssociateKeys(keysToAssociate, s_associateCallback, new CallbackData(executor, this)); if (result.CompletedSynchronously) { executor.EndAssociateKeys(result); } else { return(false); } } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } this.workflowAbortException = e; } return(true); }
public bool FlushTracking(ActivityExecutor executor) { Fx.Assert(executor.HasPendingTrackingRecords, "We should not have been called if we don't have pending tracking records"); try { if (s_trackingCallback == null) { s_trackingCallback = Fx.ThunkCallback(new AsyncCallback(OnTrackingComplete)); } IAsyncResult result = executor.BeginTrackPendingRecords( s_trackingCallback, new CallbackData(executor, this)); if (result.CompletedSynchronously) { executor.EndTrackPendingRecords(result); } else { // Completed async so we'll return false return(false); } } catch (Exception e) { if (Fx.IsFatal(e)) { throw; } this.workflowAbortException = e; } return(true); }
public IOAsyncResult(PersistencePipeline pipeline, bool isLoad, TimeSpan timeout, AsyncCallback callback, object state) : base(callback, state) { _pipeline = pipeline; _isLoad = isLoad; _pendingModules = _pipeline._modules.Where(value => value.IsIOParticipant).ToArray(); _remainingModules = _pendingModules.Length; bool completeSelf = false; if (_pendingModules.Length == 0) { completeSelf = true; } else { for (int i = 0; i < _pendingModules.Length; i++) { Fx.Assert(!completeSelf, "Shouldn't have been completed yet."); IPersistencePipelineModule module = _pendingModules[i]; IAsyncResult result = null; try { if (_isLoad) { result = module.BeginOnLoad(_pipeline._readWriteView, timeout, Fx.ThunkCallback(new AsyncCallback(OnIOComplete)), i); } else { result = module.BeginOnSave(_pipeline._readWriteView, _pipeline._writeOnlyView, timeout, Fx.ThunkCallback(new AsyncCallback(OnIOComplete)), i); } } catch (Exception exception) { if (Fx.IsFatal(exception)) { throw; } _pendingModules[i] = null; ProcessException(exception); } if (result == null) { if (CompleteOne()) { completeSelf = true; } } else if (result.CompletedSynchronously) { _pendingModules[i] = null; if (IOComplete(result, module)) { completeSelf = true; } } } } if (completeSelf) { Complete(true, _exception); } }