protected override void Execute(NativeActivityContext context)
        {
            var ext          = ActivityHelpers.GetTraceExtension(context);
            var workflowXaml = GetWorkflowXaml(context);
            var bpContext    = InnerBpContext.Get(context);

            var parentWwfinstanceId = ext == null
                ? null
                : ext.Get <Guid?>(TraceExtension.ParentWfInstanceIdPropertyName);

            if (parentWwfinstanceId.HasValue && bpContext != null)
            {
                _parentWwfinstanceId = parentWwfinstanceId;
                _canInduceIdle       = true;
                _bookmark            = context.CreateBookmark("ExecuteWorkflowActivityBookmark_" + Guid.NewGuid(), OnBookmarkResume);

                var executionContext = new ExecutionContext(string.Empty,
                                                            new Dictionary <string, object>
                {
                    { BpContext.BpContextArgumentName, bpContext }
                });
                var engine = IoC.Instance.Resolve <IProcessExecutorEngine>(WorkflowProcessExecutorConstants.Workflow);
                engine.Run(workflowXaml: workflowXaml, context: executionContext, completedHandler: ctx =>
                {
                    ctx.ParentInstanceId     = _parentWwfinstanceId;
                    ctx.ShouldResumeBookmark = _bookmark.Name;
                });
            }
            else
            {
                DynamicActivity activity;
                using (var reader = new StringReader(workflowXaml))
                    activity = (DynamicActivity)ActivityXamlServices.Load(reader);

                if (bpContext == null)
                {
                    WorkflowInvoker.Invoke(activity);
                }
                else
                {
                    var inputs = new Dictionary <string, object> {
                        { BpContext.BpContextArgumentName, bpContext }
                    };
                    WorkflowInvoker.Invoke(activity, inputs);
                    InnerBpContext.Set(context, bpContext);
                }
            }
        }
        private string GetActivitiesStack(ActivityContext context)
        {
            if (!IsActivitiesStackIncluded.Get(context))
            {
                return(null);
            }

            var ext = ActivityHelpers.GetTraceExtension(context);

            if (ext == null || ext.NotUseActivityStackTrace)
            {
                return(null);
            }

            var activityStackTrace = ext.Get <ActivityStackTrace>(TraceExtension.ActivityTrackingSourcePropertyName);

            if (activityStackTrace == null)
            {
                return(null);
            }

            const string format   = "   {0} {1}";
            const string instr    = "in";
            const string errorstr = "error " + instr;
            var          ast      = new StringBuilder();

            var isFaultSource  = activityStackTrace.FaultSource == null;
            var isFaultHandler = activityStackTrace.FaultHandler == null;

            //Добавляем в stack текущую activity
            var carrentActivityInfo = new InfoOfActivity(name: DisplayName, id: Id,
                                                         instanceId: context.ActivityInstanceId,
                                                         typeName: GetType().FullName);

            if (activityStackTrace.Activities.All(a => a.CompareTo(carrentActivityInfo) != 0))
            {
                ast.AppendLine(string.Format(format, instr, carrentActivityInfo));
            }

            var count = activityStackTrace.Activities.Count;

            for (var i = count - 1; i >= 0; i--)
            {
                var a = activityStackTrace.Activities[i];
                if (!isFaultSource && activityStackTrace.FaultSource.CompareTo(a) == 0)
                {
                    isFaultSource = true;
                    ast.AppendLine(string.Format(format, errorstr, a));
                    continue;
                }

                if (!isFaultHandler && activityStackTrace.FaultHandler.CompareTo(a) == 0)
                {
                    isFaultHandler = true;
                }

                ast.AppendLine(string.Format(format, instr, a));
            }

            if (!isFaultSource)
            {
                ast.AppendLine(string.Format(format, "? -> " + errorstr, activityStackTrace.FaultSource));
            }

            if (!isFaultHandler)
            {
                if (count > 0)
                {
                    ast.AppendLine(string.Format(format, "...", null));
                }
                ast.AppendLine(string.Format(format, instr, activityStackTrace.FaultHandler));
            }

            if (ast.Length > 0)
            {
                ast.Append("--- End of stack trace activities ---");
            }
            var result = ast.ToString();

            //Чистим ошибку
            activityStackTrace.ClearFault();
            return(result);
        }