C# NativeActivityContext.ScheduleFunc方法代码示例

 protected override void Execute(NativeActivityContext context)
 {
     StateMachineEventManager argument = this.eventManager.Get(context);
     argument.OnTransition = true;
     int childStateIndex = StateMachineIdHelper.GetChildStateIndex("0", this.InitialState.StateId);
     context.ScheduleFunc<StateMachineEventManager, string>(this.internalStateFuncs[childStateIndex], argument, this.onStateComplete, null);
 }

 private void OnStateComplete(NativeActivityContext context, System.Activities.ActivityInstance completedInstance, string result)
 {
     if (StateMachineIdHelper.IsAncestor("0", result))
     {
         int childStateIndex = StateMachineIdHelper.GetChildStateIndex("0", result);
         context.ScheduleFunc<StateMachineEventManager, string>(this.internalStateFuncs[childStateIndex], this.eventManager.Get(context), this.onStateComplete, null);
     }
 }

        private void ScheduleGetNextVectors(NativeActivityContext context)
        {
            var vars = ComputationContext.GetVariables(context, this);

            var strategy = vars.Get<BatchingStrategy>(StrategyVarName);

            if (LastResult != null && !strategyHasJustInited.Get(context))
            {
                var obs = strategy as OptimizationBatchingStrategy;
                if (obs != null)
                {
                    var last = LastResult.Get(context);
                    if (!last.IsEmpty)
                    {
                        obs.SetLastResult(last);
                    }
                }
            }

            var indexSet = new IndexSet(strategy.GetNextIndexes());

            if (IsCached(context))
            {
                // Get From Cache:
                var cache = vars.Get<SerializableCache>(CacheVarName).Cache;
                // Create variable:
                var vectorsFromCache = new LinkedList<NeuralVectors>();
                cachedVectors.Set(context, vectorsFromCache);

                var newIndexSet = new IndexSet(indexSet);

                foreach (var index in indexSet)
                {
                    string key = index.ToString();
                    var cached = cache[key] as NeuralVectors;
                    if (cached != null)
                    {
                        // Cached, add to variable, and remove from indexes:
                        vectorsFromCache.AddLast(cached);
                        newIndexSet.Remove(index);
                    }
                }

                indexSet = newIndexSet;
            }

            if (indexSet.Count > 0)
            {
                // Are there any non-cached item requests? Get it!
                context.ScheduleFunc(GetNextVectors, indexSet, OnGetNextVectorsCompleted);
            }
            else
            {
                // All items was in cache, proccess'em!
                ProcessNextVectors(context, null);
            }
        }

        private void Begin(NativeActivityContext context)
        {
            var vars = ComputationContext.GetVariables(context, this);

            if (!vars.Exists(IterationsVarName))
            {
                vars.Set(IterationsVarName, 0);
            }

            if (!vars.Exists(ItemCountVarName))
            {
                // ItemCount is not yet determined.
                ScheduleGetItemCount(context);
                return;
            }

            EnsureCache(context);

            if (!vars.Exists(StrategyVarName))
            {
                context.ScheduleFunc(GetBatchingStrategyFactory, OnGetBatchingStrategyFactoryCompleted);
            }
            else
            {
                strategyHasJustInited.Set(context, false);
                ScheduleGetNextVectors(context);
            }
        }

 /// <summary>
 /// Respond to the completion callback for the Delay activity.
 /// </summary>
 /// <param name="context">The activity context.</param>
 /// <param name="instance">The current instance of the activity.</param>
 private void OnDelayCompleted(NativeActivityContext context, ActivityInstance instance)
 {
     // Poll again
     context.ScheduleFunc(
         this.PollingBody,
         this.OperationId.Get(context),
         this.SubscriptionId.Get(context),
         this.CertificateThumbprintId.Get(context),
         this.OnGetStatusCompleted,
         this.OnOperationFault);
 }

 private void ScheduleGetNextVectors(NativeActivityContext context)
 {
     context.ScheduleFunc(GetNextVectors, OnGetNextVectorsCompleted);
 }

        /// <summary>
        /// Respond to the completion callback for the Operation activity.
        /// </summary>
        /// <param name="context">The activity context.</param>
        /// <param name="instance">The current instance of the activity.</param>
        /// <param name="result">The result returned by the activity at completion.</param>
        private void OnOperationCompleted(NativeActivityContext context, ActivityInstance instance, string result)
        {
            // Check to see if the operation faulted
            if (this.AzureActivityExceptionCaught.Get(context))
            {
                context.ScheduleActivity(this.Failure);
                return;
            }

            // Store the results of the activity for later
            context.SetValue(this.PollingEndTime, DateTime.UtcNow.AddSeconds(this.TimeoutSeconds));
            context.SetValue(this.OperationId, result);

            // Start the process of polling for status - kind of like a do/while
            context.ScheduleFunc(
                this.PollingBody,
                this.OperationId.Get(context),
                this.SubscriptionId.Get(context),
                this.CertificateThumbprintId.Get(context),
                this.OnGetStatusCompleted,
                this.OnOperationFault);
        }

        /// <summary>
        /// The receive callback.
        /// </summary>
        /// <param name="context">
        /// The context.
        /// </param>
        /// <param name="bookmark">
        /// The bookmark.
        /// </param>
        /// <param name="value">
        /// The value.
        /// </param>
        private void ReceiveCallback(NativeActivityContext context, Bookmark bookmark, object value)
        {
            context.RemoveAllBookmarks();
            this.receiveContext = (IHttpWorkflowReceiveContext)value;
            this.hostContext = context.GetExtension<IHttpWorkflowHostContext>();

            // bind the parameters using the UriTemplate
            var match = this.hostContext.MatchSingle(this.receiveContext.Request);

            this.noPersistHandle.Get(context).Enter(context);

            // TODO: Consider fault handling - do we need to do anything special?
            context.ScheduleFunc(
                this.Body,
                this.receiveContext.Request,
                match.BoundVariables.AllKeys.ToDictionary(s => s, key => match.BoundVariables[key]),
                this.OnBodyCompleted);
        }

        private void ScheduleGetNextVectors(NativeActivityContext context)
        {
            var vars = ComputationContext.GetVariables(context, this);

            var strategy = vars.Get<BatchingStrategy>(StrategyVarName);

            if (LastResult != null)
            {
                var obs = strategy as OptimizationBatchingStrategy;
                if (obs != null)
                {
                    var last = LastResult.Get(context);
                    if (!last.IsEmpty)
                    {
                        obs.SetLastResult(last);
                    }
                }
            }

            var indexSet = new IndexSet(strategy.GetNextIndexes());



            context.ScheduleFunc(GetNextVectors, indexSet, OnGetNextVectorsCompleted);
        }

 void OnStateComplete(NativeActivityContext context, ActivityInstance completedInstance, string result)
 {
     if (StateMachineHelper.IsAncestor(rootId, result))
     {
         int index = StateMachineHelper.GetChildStateIndex(rootId, result);
         context.ScheduleFunc<string, StateMachineEventManager, string>(this.internalStateFuncs[index], result,
         this.eventManager.Get(context), onStateComplete);
     }
 }

 protected override void Execute(NativeActivityContext context)
 {
     //We view the duration before moving to initial state is on transition.
     StateMachineEventManager localEventManager = this.eventManager.Get(context);
     localEventManager.OnTransition = true;
     int index = StateMachineHelper.GetChildStateIndex(rootId, this.InitialState.StateId);
     context.ScheduleFunc<string, StateMachineEventManager, string>(this.internalStateFuncs[index], this.InitialState.StateId,
         localEventManager, onStateComplete);
 }