Ispezione dell'albero delle attività

L'ispezione dell'albero delle attività viene utilizzata dagli autori di applicazioni di workflow per verificare i workflow 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 usarlo per controllare un albero delle attività.

Utilizzo di WorkflowInspectionServices

Il metodo GetActivities viene usato per enumerare tutte le attività nell'albero delle attività specificato. GetActivities restituisce un enumerabile che tocca tutte le attività all'interno dell'albero, inclusi gli elementi figlio, i gestori dei delegate, i valori predefiniti delle variabili e le espressioni degli argomenti. Nell'esempio seguente viene creata una definizione di flusso di lavoro tramite gli oggetti Sequence, While, ForEach<T>, 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 dell'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($"{new string(' ', indent)}{root.DisplayName}");

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

Questo codice di esempio fornisce l'output seguente.

Elemento della lista 1
List Item 2List Item 3List Item 4List Item 5Elementi aggiunti alla collezione.SequenzaElenco<Letterale<Stringa>>
Mentre
AggiungiAllaCollezione<Stringa>
VariableValue<ICollection<Stringa>>
LambdaValue<String>
Valore di riferimento della posizione<Elenco di stringhe<>>
LambdaValue<Boolean>
Valore di riferimento della posizione<Elenco di stringhe<>>
ForEach<String>
VariableValue<IEnumerable<String>>
WriteLine
DelegateArgumentValue<String>
Sequenza
WriteLine
Literal<String> Per recuperare un'attività specifica anziché enumerare tutte le attività, viene usato 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 all'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 nella cache dei metadati di un'attività costruisce e convalida una descrizione degli argomenti, delle variabili, delle attività figlio e dei delegati dell'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 cachare i metadati per un'attività o un albero delle attività prima di questa fase, ad esempio per gestire in anticipo tutti i costi, è possibile usare il metodo CacheMetadata per cachare i metadati nel momento desiderato.