internal override void CacheMetadata(ActivityMetadata metadata, Activity owner, string operationName)
 {
     this.ShredParameters();
     int index = 0;
     foreach (Type type in this.argumentTypes)
     {
         if ((type == null) || (type == TypeHelper.VoidType))
         {
             metadata.AddValidationError(System.ServiceModel.Activities.SR.ArgumentCannotHaveNullOrVoidType(owner.DisplayName, this.argumentNames[index]));
         }
         if ((type == MessageDescription.TypeOfUntypedMessage) || MessageBuilder.IsMessageContract(type))
         {
             metadata.AddValidationError(System.ServiceModel.Activities.SR.ReceiveParametersContentDoesNotSupportMessage(owner.DisplayName, this.argumentNames[index]));
         }
         index++;
     }
     if (!metadata.HasViolations)
     {
         foreach (KeyValuePair<string, OutArgument> pair in this.Parameters)
         {
             RuntimeArgument argument = new RuntimeArgument(pair.Key, pair.Value.ArgumentType, ArgumentDirection.Out);
             metadata.Bind(pair.Value, argument);
             metadata.AddArgument(argument);
         }
     }
 }

 /// <summary>
 /// The get transitions.
 /// </summary>
 /// <param name="record">
 /// The record. 
 /// </param>
 /// <param name="rootActivity">
 /// The root activity. 
 /// </param>
 /// <returns>
 /// A collection of possible transitions 
 /// </returns>
 public static List<string> GetTransitionNames(this StateMachineStateRecord record, Activity rootActivity)
 {
     var transitions = GetTransitions(record, rootActivity);
     return transitions != null
                ? transitions.Select(transition => transition.DisplayName).ToList()
                : new List<string>();
 }

        public static Activity Resolve(Activity root, string id)
        {
            if (root == null)
            {
                throw FxTrace.Exception.ArgumentNull("root");
            }

            if (string.IsNullOrEmpty(id))
            {
                throw FxTrace.Exception.ArgumentNullOrEmpty("id");
            }

            if (!root.IsMetadataCached)
            {
                IList<ValidationError> validationErrors = null;

                ActivityUtilities.CacheRootMetadata(root, new ActivityLocationReferenceEnvironment(), ProcessActivityTreeOptions.FullCachingOptions, null, ref validationErrors);

                ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
            }

            QualifiedId parsedId = QualifiedId.Parse(id);

            Activity result;
            if (!QualifiedId.TryGetElementFromRoot(root, parsedId, out result))
            {
                throw FxTrace.Exception.Argument("id", SR.IdNotFoundInWorkflow(id));
            }

            return result;
        }

 internal static string GenerateValidationErrorPrefix(Activity toValidate, ActivityUtilities.ActivityCallStack parentChain, out Activity source)
 {
     bool flag = true;
     string str = "";
     source = toValidate;
     for (int i = 0; i < parentChain.Count; i++)
     {
         ActivityUtilities.ChildActivity activity = parentChain[i];
         if (activity.Activity.MemberOf.Parent != null)
         {
             flag = false;
             break;
         }
     }
     while (source.MemberOf.Parent != null)
     {
         source = source.Parent;
     }
     if (toValidate.MemberOf.Parent != null)
     {
         return System.Activities.SR.ValidationErrorPrefixForHiddenActivity(source);
     }
     if (!flag)
     {
         str = System.Activities.SR.ValidationErrorPrefixForPublicActivityWithHiddenParent(source.Parent, source);
     }
     return str;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="NinjectWorkflowApplicationUnhandledExceptionEventArgs"/> class.
 /// </summary>
 /// <param name="instanceId">The instance id.</param>
 /// <param name="unhandledException">The unhandled exception.</param>
 /// <param name="exceptionSource">The exception source.</param>
 /// <param name="exceptionSourceInstanceId">The exception source instance id.</param>
 public NinjectWorkflowApplicationUnhandledExceptionEventArgs(Guid instanceId, Exception unhandledException, Activity exceptionSource, string exceptionSourceInstanceId)
     : base(instanceId)
 {
     this.UnhandledException = unhandledException;
     this.ExceptionSource = exceptionSource;
     this.ExceptionSourceInstanceId = exceptionSourceInstanceId;
 }

 /// <summary>
 /// Creates a bookmark name for the given activity.
 /// </summary>
 /// <param name="context"></param>
 /// <param name="callback"></param>
 /// <returns></returns>
 public static string CreateTwilioBookmarkName(this NativeActivityContext context, Activity activity)
 {
     return string.Format("{0}_{1}_{2}",
         activity.Id,
         activity.DisplayName,
         Math.Abs(Guid.NewGuid().GetHashCode()));
 }

        public static void printActivityTreeA(Activity activity)
        {
            if (tag == null)
            {
                tag = new activityStruct();
                tag.parent = null;
                tag.currentActivity = activity;
                tag.displayName = activity.DisplayName;

            }


            System.Collections.Generic.IEnumerator<Activity> list = WorkflowInspectionServices.GetActivities(activity).GetEnumerator();

            while (list.MoveNext())
            {
                activityStruct temp = new activityStruct();

                temp.parent = tag;
                temp.currentActivity = list.Current;
                temp.displayName = list.Current.DisplayName;
                printActivityTreeA(list.Current);

            }

        }

 public static bool GatherAndValidateOverloads(Activity activity, out Dictionary<string, List<RuntimeArgument>> overloadGroups, out List<RuntimeArgument> requiredArgumentsNotInOverloadGroups, out OverloadGroupEquivalenceInfo equivalenceInfo, ref IList<ValidationError> validationErrors)
 {
     overloadGroups = null;
     requiredArgumentsNotInOverloadGroups = null;
     foreach (RuntimeArgument argument in activity.RuntimeArguments)
     {
         if (!argument.OverloadGroupNames.IsNullOrEmpty())
         {
             foreach (string str in argument.OverloadGroupNames)
             {
                 if (overloadGroups == null)
                 {
                     overloadGroups = new Dictionary<string, List<RuntimeArgument>>();
                 }
                 List<RuntimeArgument> list = null;
                 if (!overloadGroups.TryGetValue(str, out list))
                 {
                     list = new List<RuntimeArgument>();
                     overloadGroups.Add(str, list);
                 }
                 list.Add(argument);
             }
         }
         else if (argument.IsRequired)
         {
             if (requiredArgumentsNotInOverloadGroups == null)
             {
                 requiredArgumentsNotInOverloadGroups = new List<RuntimeArgument>();
             }
             requiredArgumentsNotInOverloadGroups.Add(argument);
         }
     }
     equivalenceInfo = GetOverloadGroupEquivalence(overloadGroups);
     return ValidateOverloadGroupDefinitions(activity, equivalenceInfo, overloadGroups, ref validationErrors);
 }

 void ActivityInstanceMap.IActivityReference.Load(Activity activity, ActivityInstanceMap instanceMap)
 {
     if (this.activityInstance.Activity == null)
     {
         ((ActivityInstanceMap.IActivityReference) this.activityInstance).Load(activity, instanceMap);
     }
 }

 internal void SetupWorkflowCompensationBehavior(NativeActivityContext context, BookmarkCallback callback, Activity workflowCompensationBehavior)
 {
     this.WorkflowCompensationScheduled = context.CreateBookmark(callback);
     context.ScheduleSecondaryRoot(workflowCompensationBehavior, null);
     this.Add(0L, new CompensationTokenData(0L, 0L));
     this.IsWorkflowCompensationBehaviorScheduled = true;
 }

 public MappableLocation(LocationReference locationOwner, Activity activity, System.Activities.ActivityInstance activityInstance, System.Activities.Location location)
 {
     this.Name = locationOwner.Name;
     this.OwnerDisplayName = activity.DisplayName;
     this.Location = location;
     this.MappingKeyName = string.Format(CultureInfo.InvariantCulture, "activity.{0}-{1}_{2}", new object[] { activity.Id, locationOwner.Id, activityInstance.Id });
 }

 private int CreateLogicalThread(Activity activity, System.Activities.ActivityInstance instance, bool primeCurrentInstance)
 {
     Stack<System.Activities.ActivityInstance> ancestors = null;
     if (!this.DebugStartedAtRoot)
     {
         ancestors = new Stack<System.Activities.ActivityInstance>();
         if (((activity != instance.Activity) || primeCurrentInstance) && (primeCurrentInstance || !IsParallelActivity(instance.Activity)))
         {
             ancestors.Push(instance);
         }
         System.Activities.ActivityInstance parent = instance.Parent;
         while ((parent != null) && !IsParallelActivity(parent.Activity))
         {
             ancestors.Push(parent);
             parent = parent.Parent;
         }
         if (((parent != null) && IsParallelActivity(parent.Activity)) && (this.GetExecutingThreadId(parent.Activity, false) < 0))
         {
             int num = this.CreateLogicalThread(parent.Activity, parent, true);
         }
     }
     string threadName = string.Empty;
     if (activity.Parent != null)
     {
         threadName = "DebuggerThread:" + activity.Parent.DisplayName;
     }
     int key = this.stateManager.CreateLogicalThread(threadName);
     Stack<Activity> stack2 = new Stack<Activity>();
     this.runningThreads.Add(key, stack2);
     if (!this.DebugStartedAtRoot && (ancestors != null))
     {
         this.PrimeCallStack(key, ancestors);
     }
     return key;
 }

 public void Declare(LocationReference locationReference, Activity owner, ref IList<ValidationError> validationErrors)
 {
     if (locationReference.Name == null)
     {
         if (this.unnamedDeclarations == null)
         {
             this.unnamedDeclarations = new List<LocationReference>();
         }
         this.unnamedDeclarations.Add(locationReference);
     }
     else if (this.Declarations.ContainsKey(locationReference.Name))
     {
         string id = null;
         if (owner != null)
         {
             id = owner.Id;
         }
         ValidationError data = new ValidationError(System.Activities.SR.SymbolNamesMustBeUnique(locationReference.Name)) {
             Source = owner,
             Id = id
         };
         ActivityUtilities.Add<ValidationError>(ref validationErrors, data);
     }
     else
     {
         this.Declarations.Add(locationReference.Name, locationReference);
     }
 }

 public object InvokeExpression(int expressionId, System.Collections.Generic.IList<System.Activities.LocationReference> locations, System.Activities.ActivityContext activityContext) {
     if ((this.rootActivity == null)) {
         this.rootActivity = this;
     }
     if ((this.dataContextActivities == null)) {
         this.dataContextActivities = paper_use1_TypedDataContext2_ForReadOnly.GetDataContextActivitiesHelper(this.rootActivity, this.forImplementation);
     }
     if ((expressionId == 0)) {
         System.Activities.XamlIntegration.CompiledDataContext[] cachedCompiledDataContext = paper_use1_TypedDataContext2_ForReadOnly.GetCompiledDataContextCacheHelper(this.dataContextActivities, activityContext, this.rootActivity, this.forImplementation, 1);
         if ((cachedCompiledDataContext[0] == null)) {
             cachedCompiledDataContext[0] = new paper_use1_TypedDataContext2_ForReadOnly(locations, activityContext, true);
         }
         paper_use1_TypedDataContext2_ForReadOnly valDataContext0 = ((paper_use1_TypedDataContext2_ForReadOnly)(cachedCompiledDataContext[0]));
         return valDataContext0.ValueType___Expr0Get();
     }
     if ((expressionId == 1)) {
         System.Activities.XamlIntegration.CompiledDataContext[] cachedCompiledDataContext = paper_use1_TypedDataContext2_ForReadOnly.GetCompiledDataContextCacheHelper(this.dataContextActivities, activityContext, this.rootActivity, this.forImplementation, 1);
         if ((cachedCompiledDataContext[0] == null)) {
             cachedCompiledDataContext[0] = new paper_use1_TypedDataContext2_ForReadOnly(locations, activityContext, true);
         }
         paper_use1_TypedDataContext2_ForReadOnly valDataContext1 = ((paper_use1_TypedDataContext2_ForReadOnly)(cachedCompiledDataContext[0]));
         return valDataContext1.ValueType___Expr1Get();
     }
     return null;
 }

        public static GenericVariableCollection GetVariables(NativeActivityContext context, Activity activity)
        {
            Contract.Requires(context != null);
            Contract.Requires(activity != null);

            return GetVariables(context, activity.Id);
        }

        public void Visit(Activity activity, bool forImplementation)
        {
            this.ForImplementation = forImplementation;
            bool exit;

            VisitRoot(activity, out exit);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="WorkflowInvokerTest"/> class.
 /// </summary>
 /// <param name="activity">
 /// The activity.
 /// </param>
 public WorkflowInvokerTest(Activity activity)
 {
     this.activity = activity;
     this.Writer = new StringWriter();
     this.Invoker.Extensions.Add(this.Writer);
     this.InArguments = new WorkflowArguments();
 }

        void VisitCore(Activity activity, out bool exit)
        {
            if (activity is ITextExpression)
            {
                VisitITextExpression(activity, out exit);
                return;
            }
            // Look for variable scopes
            if (activity.RuntimeVariables != null && activity.RuntimeVariables.Count > 0)
            {
                VisitVariableScope(activity, out exit);
                if (exit)
                {
                    return;
                }
            }
            else
            {
                Visit(activity, out exit);
                if (exit)
                {
                    return;
                }
            }

            return;
        }

 internal bool InitializeRelationship(Activity parent, bool isPublic, ref IList<ValidationError> validationErrors)
 {
     if ((this.cacheId == parent.CacheId) && (this.Owner != null))
     {
         ValidationError data = new ValidationError(System.Activities.SR.VariableAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), false, this.Name, parent);
         ActivityUtilities.Add<ValidationError>(ref validationErrors, data);
         return false;
     }
     this.Owner = parent;
     this.cacheId = parent.CacheId;
     this.IsPublic = isPublic;
     if (this.Default == null)
     {
         return true;
     }
     ActivityWithResult innerExpression = this.Default;
     if (innerExpression is Argument.IExpressionWrapper)
     {
         innerExpression = ((Argument.IExpressionWrapper) innerExpression).InnerExpression;
     }
     if (innerExpression.ResultType != base.Type)
     {
         ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.VariableExpressionTypeMismatch(this.Name, base.Type, innerExpression.ResultType), false, this.Name, parent));
     }
     return this.Default.InitializeRelationship(this, isPublic, ref validationErrors);
 }

 /// <summary>
 /// The get transitions.
 /// </summary>
 /// <param name="record">
 /// The record. 
 /// </param>
 /// <param name="rootActivity">
 /// The root activity. 
 /// </param>
 /// <returns>
 /// A collection of possible transitions 
 /// </returns>
 public static IList<Transition> GetTransitions(this StateMachineStateRecord record, Activity rootActivity)
 {
     var activity = WorkflowInspectionServices.Resolve(rootActivity, record.Activity.Id);
     dynamic internalState = new ReflectionObject(activity);
     dynamic transitions = new ReflectionObject(internalState.Transitions);
     return ((ReflectionObject)transitions).Inner as IList<Transition>;
 }