protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     metadata.AddChild(this.Body);
     metadata.AddChild(this.CancellationHandler);
     metadata.SetVariablesCollection(this.Variables);
     metadata.AddImplementationVariable(this.suppressCancel);
 }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     this.internalStateFuncs.Clear();
     this.internalStates.Clear();
     this.PassNumber++;
     this.TraverseViaTransitions(new Action<System.Activities.Statements.State>(StateMachine.ClearState), new Action<Transition>(StateMachine.ClearTransition));
     this.PassNumber++;
     bool checkReached = false;
     this.TraverseStates((m, states) => ClearStates(states), (m, state) => ClearTransitions(state), metadata, checkReached);
     this.PassNumber++;
     bool flag2 = false;
     this.TraverseStates(new Action<NativeActivityMetadata, Collection<System.Activities.Statements.State>>(this.MarkStatesViaChildren), (m, state) => MarkTransitionsInState(state), metadata, flag2);
     this.PassNumber++;
     this.TraverseViaTransitions(state => MarkStateViaTransition(state), null);
     this.PassNumber++;
     Action<Transition> actionForTransition = null;
     this.TraverseViaTransitions(state => ValidateTransitions(metadata, state), actionForTransition);
     this.PassNumber++;
     NativeActivityMetadata metadata2 = metadata;
     bool flag3 = true;
     this.TraverseStates(new Action<NativeActivityMetadata, Collection<System.Activities.Statements.State>>(StateMachine.ValidateStates), delegate (NativeActivityMetadata m, System.Activities.Statements.State state) {
         if (!state.Reachable)
         {
             ValidateTransitions(m, state);
         }
     }, metadata2, flag3);
     this.ValidateStateMachine(metadata);
     this.ProcessStates(metadata);
     metadata.AddImplementationVariable(this.eventManager);
     foreach (Variable variable in this.Variables)
     {
         metadata.AddVariable(variable);
     }
     metadata.AddDefaultExtensionProvider<StateMachineExtension>(getDefaultExtension);
 }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     base.CacheMetadata(metadata);
     metadata.AddImplementationVariable(playUrl);
     metadata.AddImplementationVariable(loop);
     metadata.AddImplementationChild(play);
 }

        /// <summary>
        /// The cache metadata.
        /// </summary>
        /// <param name="metadata">
        /// The metadata.
        /// </param>
        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            metadata.RequireExtension<IMessagingStub>();

            var parametersContent = this.Content as ReceiveParametersContent;

            if (parametersContent != null)
            {
                foreach (var pair in parametersContent.Parameters)
                {
                    var argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out);
                    metadata.Bind(pair.Value, argument);
                    metadata.AddArgument(argument);
                }
            }

            var messageContent = this.Content as ReceiveMessageContent;
            if (messageContent != null)
            {
                var runtimeArgumentType = (messageContent.Message == null) ? typeof(object) : messageContent.Message.ArgumentType;
                var argument = new RuntimeArgument("Message", runtimeArgumentType, ArgumentDirection.Out);
                metadata.Bind(messageContent.Message, argument);
                metadata.AddArgument(argument);
            }

            // Note: Not adding other properties here as arguments
        }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     base.CacheMetadata(metadata);
     metadata.AddImplementationVariable(notificationIds);
     metadata.AddImplementationVariable(nodeIds);
     metadata.AddImplementationVariable(counter);
 }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     if (this.branchBodies == null)
     {
         this.branchBodies = new Collection<Activity>();
     }
     else
     {
         this.branchBodies.Clear();
     }
     foreach (PickBranch branch in this.Branches)
     {
         if (branch.Trigger == null)
         {
             metadata.AddValidationError(System.Activities.SR.PickBranchRequiresTrigger(branch.DisplayName));
         }
         PickBranchBody item = new PickBranchBody {
             Action = branch.Action,
             DisplayName = branch.DisplayName,
             Trigger = branch.Trigger,
             Variables = branch.Variables
         };
         this.branchBodies.Add(item);
     }
     metadata.SetChildrenCollection(this.branchBodies);
     metadata.AddImplementationVariable(this.pickStateVariable);
 }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     if (this.Result != null)
     {
         RuntimeArgument argument = new RuntimeArgument("Result", this.Result.ArgumentType, ArgumentDirection.In);
         metadata.Bind(this.Result, argument);
         metadata.AddArgument(argument);
     }
     if (this.parameters != null)
     {
         int num = 0;
         foreach (InArgument argument2 in this.parameters)
         {
             RuntimeArgument argument3 = new RuntimeArgument("Parameter" + num++, argument2.ArgumentType, ArgumentDirection.In);
             metadata.Bind(argument2, argument3);
             metadata.AddArgument(argument3);
         }
     }
     RuntimeArgument argument4 = new RuntimeArgument("Message", System.ServiceModel.Activities.Constants.MessageType, ArgumentDirection.Out, true);
     metadata.Bind(this.Message, argument4);
     metadata.AddArgument(argument4);
     RuntimeArgument argument5 = new RuntimeArgument("CorrelatesWith", System.ServiceModel.Activities.Constants.CorrelationHandleType, ArgumentDirection.In);
     metadata.Bind(this.CorrelatesWith, argument5);
     metadata.AddArgument(argument5);
 }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            RuntimeArgument subInstanceArgument = new RuntimeArgument("Scope", typeof(BookmarkScope), ArgumentDirection.In);
            metadata.Bind(this.Scope, subInstanceArgument);

            metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { subInstanceArgument });
        }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            // The Body introduces another layer of scope. Method metadata.AddImplementationChild
            // (instead of metadata.AddChild) enable access to LoopVariable from the inner
            // block scope of Body.
            if (this.Body != null && this.Body.Handler != null)
            {
                this.invokeBody.Action = this.Body;
                metadata.AddImplementationChild(this.invokeBody);
            }

            // Need to bind the arguments to the custom activity variables explicitly
            // and then add them to the metadata.
            RuntimeArgument startArg = new RuntimeArgument("Start", typeof(int), ArgumentDirection.In, true);
            metadata.Bind(this.Start, startArg);
            metadata.AddArgument(startArg);
            RuntimeArgument stopArg = new RuntimeArgument("Stop", typeof(int), ArgumentDirection.In, true);
            metadata.Bind(this.Stop, stopArg);
            metadata.AddArgument(stopArg);
            RuntimeArgument stepArg = new RuntimeArgument("Step", typeof(int), ArgumentDirection.In, true);
            metadata.Bind(this.Step, stepArg);
            metadata.AddArgument(stepArg);

            // Register variables used in the custom activity.
            metadata.AddImplementationVariable(this.loopVariable);
        }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            RuntimeArgument targetArgument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In);
            metadata.Bind(this.Target, targetArgument);

            metadata.SetArgumentsCollection(
                new Collection<RuntimeArgument>
                {
                    targetArgument
                });

            metadata.SetImplementationVariablesCollection(
                new Collection<Variable>
                {
                    this.currentCompensationToken
                });

            Fx.Assert(DefaultConfirmation != null, "DefaultConfirmation must be valid");
            Fx.Assert(InternalConfirm != null, "InternalConfirm must be valid");
            metadata.SetImplementationChildrenCollection(
                new Collection<Activity>
                {
                    DefaultConfirmation, 
                    InternalConfirm
                });
        }

        // Returns true if this is the first time we've visited this node during this pass
        internal bool Open(Flowchart owner, NativeActivityMetadata metadata)
        {
            if (this.cacheId == owner.CacheId)
            {
                // We've already visited this node during this pass
                if (!object.ReferenceEquals(this.owner, owner))
                {
                    metadata.AddValidationError(SR.FlowNodeCannotBeShared(this.owner.DisplayName, owner.DisplayName));
                }

                // Whether we found an issue or not we don't want to change
                // the metadata during this pass.
                return false;
            }

            // if owner.ValidateUnconnectedNodes - Flowchart will be responsible for calling OnOpen for all the Nodes (connected and unconnected)
            if (!owner.ValidateUnconnectedNodes)
            {
                OnOpen(owner, metadata);
            }
            this.owner = owner;
            this.cacheId = owner.CacheId;
            this.Index = -1;

            return true;
        }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            if (GetBatchingStrategyFactory.IsNull()) metadata.AddValidationError("GetBatchingStrategyFactory function is expected.");
            if (GetNextVectors.IsNull()) metadata.AddValidationError("GetNextVectors function is expected.");
            if (ItemCount == null) metadata.AddValidationError("ItemCount expression expected.");

            metadata.AddDelegate(GetBatchingStrategyFactory);
            metadata.AddDelegate(GetNextVectors);
            metadata.AddDelegate(ReinitializeVectorProvider);

            RuntimeArgument arg;

            metadata.AddArgument(arg = new RuntimeArgument("LastResult", typeof(BatchExecutionResult), ArgumentDirection.In));
            metadata.Bind(LastResult, arg);

            metadata.AddArgument(arg = new RuntimeArgument("ReinitializationFrequency", typeof(int), ArgumentDirection.In));
            metadata.Bind(ReinitializationFrequency, arg);

            metadata.AddArgument(arg = new RuntimeArgument("UseCache", typeof(bool), ArgumentDirection.In));
            metadata.Bind(UseCache, arg);

            metadata.AddChild(ItemCount);

            metadata.AddImplementationVariable(cachedVectors);
            metadata.AddImplementationVariable(strategyHasJustInited);

            base.CacheMetadata(metadata);
        }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     metadata.AddImplementationVariable(outputText);
     this.output = new WriteLine { Text = new InArgument<string>(outputText) };
     metadata.AddImplementationChild(this.output);
     metadata.SetArgumentsCollection(metadata.GetArgumentsWithReflection());
 }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            RuntimeArgument valuesArgument = new RuntimeArgument("Values", typeof(IEnumerable), ArgumentDirection.In, true);
            metadata.Bind(this.Values, valuesArgument);
            metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { valuesArgument });

            // declare the CompletionCondition as a child
            if (this.CompletionCondition != null)
            {
                metadata.SetChildrenCollection(new Collection<Activity> { this.CompletionCondition });
            }

            // declare the hasCompleted variable
            if (this.CompletionCondition != null)
            {
                if (this.hasCompleted == null)
                {
                    this.hasCompleted = new Variable<bool>();
                }

                metadata.AddImplementationVariable(this.hasCompleted);
            }

            metadata.AddDelegate(this.Body);
        }

 internal override void OnOpen(Flowchart owner, NativeActivityMetadata metadata)
 {
     if (this.Condition == null)
     {
         metadata.AddValidationError(SR.FlowDecisionRequiresCondition(owner.DisplayName));
     }
 }

        protected override void CacheMetadata(NativeActivityMetadata metadata)
        {
            RuntimeArgument argument;

            argument = new RuntimeArgument("JobGuid", typeof(Guid), ArgumentDirection.In);
            metadata.Bind(this.JobGuid, argument);
            metadata.AddArgument(argument);

            argument = new RuntimeArgument("UserGuid", typeof(Guid), ArgumentDirection.In);
            metadata.Bind(this.UserGuid, argument);
            metadata.AddArgument(argument);

            if (this.Try != null)
            {
                metadata.AddChild(this.Try);
            }
            if (this.Finally != null)
            {
                metadata.AddChild(this.Finally);
            }

            argument = new RuntimeArgument("MaxRetries", typeof(int), ArgumentDirection.In);
            metadata.Bind(this.MaxRetries, argument);
            metadata.AddArgument(argument);

            metadata.AddImplementationVariable(this.retries);
        }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     //call base.CacheMetadata to add the Activities and Variables to this activity's metadata
     base.CacheMetadata(metadata);
     //add the private implementation variable: currentIndex 
     metadata.AddImplementationVariable(this.currentIndex);
 }

 /// <summary>
 /// Create internal states
 /// </summary>
 public static void ProcessChildStates(NativeActivityMetadata metadata, Collection<State> childStates,
     Collection<InternalState> internalStates, Collection<ActivityFunc<string, StateMachineEventManager, string>> internalStateFuncs)
 {
     foreach (State state in childStates)
     {
         InternalState internalState = state.InternalState;
         internalStates.Add(internalState);
         DelegateInArgument<string> toStateId = new DelegateInArgument<string>();
         DelegateInArgument<StateMachineEventManager> eventManager = new DelegateInArgument<StateMachineEventManager>();
         internalState.ToState = toStateId;
         internalState.EventManager = eventManager;
         ActivityFunc<string, StateMachineEventManager, string> activityFunc = new ActivityFunc<string, StateMachineEventManager, string>
         {
             Argument1 = toStateId,
             Argument2 = eventManager,
             Handler = internalState,
         };
         if (state.Reachable)
         {
             //If this state is not reached, we should not add it as child because it's even not well validated.
             metadata.AddDelegate(activityFunc);
         }
         internalStateFuncs.Add(activityFunc);
     }
 }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     RuntimeArgument argument = new RuntimeArgument("Target", typeof(CompensationToken), ArgumentDirection.In);
     metadata.Bind(this.Target, argument);
     metadata.SetArgumentsCollection(new Collection<RuntimeArgument> { argument });
     metadata.SetImplementationVariablesCollection(new Collection<Variable> { this.toConfirmToken });
     metadata.SetImplementationChildrenCollection(new Collection<Activity> { this.Body });
 }

 protected override void CacheMetadata(NativeActivityMetadata metadata)
 {
     metadata.RequireExtension<ICountModel>();
     var currentCountArg = new RuntimeArgument(
         "CurrentCount", typeof(Int32), ArgumentDirection.In);
     metadata.AddArgument(currentCountArg);
     metadata.Bind(this.CurrentCount, currentCountArg);
 }