Ispezione della struttura ad albero delle attività

Le informazioni contenute in questo argomento sono valide per Windows Workflow Foundation 4.

L'ispezione della struttura ad albero delle attività viene utilizzata dagli autori dell'applicazione flusso di lavoro per controllare i flussi di lavoro ospitati dall'applicazione. Tramite l'oggetto WorkflowInspectionServices, nei flussi di lavoro è possibile cercare attività figlio specifiche, enumerare attività singole e le relative proprietà, nonché memorizzare nella cache i metadati di runtime delle attività in un momento specifico. In questo argomento viene fornita una panoramica sull'oggetto WorkflowInspectionServices e viene descritto come utilizzarlo per controllare una struttura ad albero delle attività.

Utilizzo dell'oggetto WorkflowInspectionServices

Il metodo GetActivities viene utilizzato per enumerare tutte le attività nella struttura ad albero specificata e restituisce un oggetto enumerabile che riguarda tutte le attività all'interno della struttura ad albero, inclusi elementi figlio, gestori delegati, valori predefiniti delle variabili ed espressioni passate come argomenti. Nell'esempio seguente viene creata una definizione di flusso di lavoro tramite gli oggetti Sequence, While, ForEach, WriteLine e le espressioni. Una volta creata, la definizione di flusso di lavoro viene richiamata, quindi viene chiamato il metodo InspectActivity.

Variable<List<string>> items = new Variable<List<string>>
{
    Default = new VisualBasicValue<List<string>>("New List(Of String)()")
};

DelegateInArgument<string> item = new DelegateInArgument<string>();

Activity wf = new Sequence
{
    Variables = { items },
    Activities =
    {
        new While((env) => items.Get(env).Count < 5)
        {
            Body = new AddToCollection<string>
            {
                Collection = new InArgument<ICollection<string>>(items),
                Item = new InArgument<string>((env) => "List Item " + (items.Get(env).Count + 1))
            }
        },
        new ForEach<string>
        {
            Values = new InArgument<IEnumerable<string>>(items),
            Body = new ActivityAction<string>
            {
                Argument = item,
                Handler = new WriteLine
                {
                    Text = item
                }
            }
        },
        new Sequence
        {
            Activities = 
            {
                new WriteLine
                {
                    Text = "Items added to collection."
                }
            }
        }
    }
};

WorkflowInvoker.Invoke(wf);

InspectActivity(wf, 0);

Per enumerare le attività, viene chiamato GetActivities nell'attività radice e di nuovo in modo ricorsivo in ogni attività restituita. Nell'esempio seguente la proprietà DisplayName di ogni attività ed espressione della struttura ad albero delle attività viene scritta nella console.

static void InspectActivity(Activity root, int indent)
{
    // Inspect the activity tree using WorkflowInspectionServices.
    IEnumerator<Activity> activities = 
        WorkflowInspectionServices.GetActivities(root).GetEnumerator();

    Console.WriteLine("{0}{1}", new string(' ', indent), root.DisplayName);

    while (activities.MoveNext())
    {
        InspectActivity(activities.Current, indent + 2);
    }
}

Questo codice di esempio fornisce l'output seguente.

List Item 1
List Item 2
List Item 3
List Item 4
List Item 5
Items added to collection. 
Sequence
  Literal<List<String>>
  While
    AddToCollection<String>
      VariableValue<ICollection<String>>
      LambdaValue<String>
        LocationReferenceValue<List<String>>
    LambdaValue<Boolean>
      LocationReferenceValue<List<String>>
  ForEach<String>
    VariableValue<IEnumerable<String>>
    WriteLine
      DelegateArgumentValue<String>
  Sequence
    WriteLine
      Literal<String>

Per recuperare un'attività specifica anziché enumerare tutte le attività, viene utilizzato il metodo Resolve. Entrambi i metodi Resolve e GetActivities eseguono la memorizzazione dei metadati nella cache se non è stato precedentemente chiamato l'oggetto WorkflowInspectionServices.CacheMetadata. Se il metodo CacheMetadata è stato chiamato, il metodo GetActivities si basa sui metadati esistenti. Pertanto, se sono state apportate modifiche alla struttura ad albero dall'ultima chiamata al metodo CacheMetadata, il metodo GetActivities potrebbe fornire risultati imprevisti. Se sono state apportate modifiche al flusso di lavoro dopo avere chiamato GetActivities, è possibile memorizzare di nuovo i metadati nella cache chiamando il metodo ActivityValidationServicesValidate. La memorizzazione dei metadati nella cache è descritta nella prossima sezione.

Memorizzazione dei metadati nella cache

La memorizzazione dei metadati nella cache per un'attività compila e convalida una descrizione degli argomenti dell'attività, delle variabili, delle attività figlio e dei delegati di attività. Per impostazione predefinita, i metadati vengono memorizzati nella cache dal runtime quando un'attività viene preparata per l'esecuzione. Se un autore dell'host del flusso di lavoro desidera memorizzare i metadati nella cache per un'attività o una struttura ad albero delle attività prima di questa fase, ad esempio per accettare in anticipo tutto il costo, è possibile utilizzare il metodo CacheMetadata per memorizzare i metadati nella cache nel momento desiderato.