Question

I’m making a Workflow designer similar to Visual Workflow Tracking*.

I would like add a new control to debug wf, but id don’t know how to access to wf context

To Run WF I Use this :

 WFApplication wfApp = new WorkflowApplication(act, inputs);

My idea is when i recive trace event, get context of wfApp, to get vars or arguments values.

It’s posibble?

*You can donwload VisualStudioTracking Code From :
Windows Communication Foundation (WCF) and Windows Workflow Foundation (WF) Samples for .NET Framework 4
and then
:\WF_WCF_Samples\WF\Application\VisualWorkflowTracking*

Answer 1

Finally I solved the problem.

First I get all arguments names, and variables of workflow, from xaml.

    class XamlHelper
    {   

    private string xaml;

    public XamlHelper(string xaml)
    {           
        this.xaml = xaml;

        DynamicActivity act = GetRuntimeExecutionRoot(this.xaml);
        ArgumentNames = GetArgumentsNames(act);

     GetVariables(act);
    }

    private void GetVariables(DynamicActivity act)
    {
        Variables = new List<string>();
        InspectActivity(act);


    }

    private void InspectActivity(Activity root)
    {


        IEnumerator<Activity> activities =
            WorkflowInspectionServices.GetActivities(root).GetEnumerator();


        while (activities.MoveNext())
        {

            PropertyInfo propVars = activities.Current.GetType().GetProperties().FirstOrDefault(p => p.Name == "Variables" && p.PropertyType == typeof(Collection<Variable>));
            if (propVars != null)
            {
                try
                {
                    Collection<Variable> variables = (Collection<Variable>)propVars.GetValue(activities.Current, null);
                    variables.ToList().ForEach(v =>
                    {
                        Variables.Add(v.Name);

                    });
                }
                catch
                {

                }
            }
            InspectActivity(activities.Current);
        }
    }





    public List<string> Variables
    {
        get;
        private set;
    }

    public List<string> ArgumentNames
    {
        get;
        private set;
    }


    private DynamicActivity GetRuntimeExecutionRoot(string xaml)
    {


        Activity root = ActivityXamlServices.Load(new StringReader(xaml));


            WorkflowInspectionServices.CacheMetadata(root);

        return root as DynamicActivity;

    }

    private List<string> GetArgumentsNames(DynamicActivity act)
    {
        List<string> names = new List<string>();
        if (act != null)
        {
            act.Properties.Where(p => typeof(Argument).IsAssignableFrom(p.Type)).ToList().ForEach(dp =>
            {
                names.Add(dp.Name);
            });

        }

        return names;
    }

}

Second I create trace with these arguments and variable names

    private static WFTrace CreateTrace(List<string> argumentNames, List<string> variablesNames)
    {
        WFTrace trace = new WFTrace();
        trace.TrackingProfile = new TrackingProfile()
        {
            ImplementationVisibility = ImplementationVisibility.All,
            Name = "CustomTrackingProfile",
            Queries = 
                {
                    new CustomTrackingQuery() 
                    {
                     Name = all,
                     ActivityName = all
                    },
                    new WorkflowInstanceQuery()
                    {


                         // Limit workflow instance tracking records for started and completed workflow states
                        States = {WorkflowInstanceStates.Started, WorkflowInstanceStates.Completed },
                   }
                }
        };

        trace.TrackingProfile.Queries.Add(GetActivityQueryState(argumentNames, variablesNames));

        return trace;
    }

And then invoke wf and add traceextension.

Adam this is the code

  private TrackingQuery GetActivityQueryState(List<string> argumentNames, List<string> variablesNames)
        {
            ActivityStateQuery query = new ActivityStateQuery()
            {
                ActivityName = "*",
                States = { ActivityStates.Executing, ActivityStates.Closed }
            };
            if (argumentNames != null)
            {
                argumentNames.Distinct().ToList().ForEach(arg =>
                {
                    query.Arguments.Add(arg);
                });
            }
            if (variablesNames != null)
            {
                variablesNames.Distinct().ToList().ForEach(v =>
                {
                    query.Variables.Add(v);
                });
            }
            return query;
        }