Inspeção da árvore de atividades

A inspeção da árvore de atividades é usada pelos autores do aplicativo de fluxo de trabalho para inspecionar os fluxos de trabalho hospedados pelo aplicativo. Usando o WorkflowInspectionServices, podem-se pesquisar fluxos de trabalho para atividades filhas específicas, enumerar as atividades individuais e suas propriedades, e armazenar em cache os metadados de tempo de execução das atividades em um momento específico. Este tópico fornece uma visão geral de WorkflowInspectionServices e de como usá-lo para inspecionar uma árvore de atividades.

Usando WorkflowInspectionServices

O GetActivities método é usado para enumerar todas as atividades na árvore de atividades especificada. GetActivities Devolve um enumerável que abrange todas as atividades dentro da árvore, incluindo as suas crianças, manipuladores delegados, padrões de variáveis e expressões de argumento. No exemplo a seguir, uma definição de fluxo de trabalho é criada usando expressões , SequenceWhile, ForEach<T>WriteLine, e . Depois que a definição de fluxo de trabalho é criada, ela é invocada e, em seguida, o InspectActivity método é chamado.

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);

Para enumerar as atividades, o GetActivities é chamado na atividade raiz e novamente recursivamente em cada atividade retornada. No exemplo a seguir, o DisplayName de cada atividade ou expressão na árvore de atividades é registado na consola.

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);
    }
}

Este código de exemplo fornece a seguinte saída.

Item de lista 1
Item da Lista 2Item da Lista 3Item da Lista 4Item da Lista 5Itens adicionados à coleção.SequênciaLiteral<Lista<String>>
Enquanto
Cadeia de caracteres AddToCollection<>
VariableValue<ICollection<String>>
Cadeia de caracteres LambdaValue<>
ValorDeReferênciaDeLocalização<Lista<Texto>>
LambdaValue<Booleano>
ValorDeReferênciaDeLocalização<Lista<Texto>>
ForEach<String>
VariableValue<IEnumerable<String>>
Linha de Escrita
Cadeia de caracteres DelegateArgumentValue<>
Sequência
Linha de Escrita
< > literalPara recuperar uma atividade específica em vez de enumerar todas as atividades, Resolve é usado. Ambos Resolve e GetActivities executam cache de metadados se WorkflowInspectionServices.CacheMetadata não tiver sido chamado anteriormente. Se CacheMetadata foi chamado, então GetActivities é baseado nos metadados existentes. Portanto, se as alterações na árvore tiverem sido feitas desde a última chamada para CacheMetadata, GetActivities podem dar resultados inesperados. Se forem feitas alterações no fluxo de trabalho após a chamada GetActivities, os metadados poderão ser armazenados novamente em cache chamando o ActivityValidationServicesValidate método. O armazenamento em cache de metadados é discutido na próxima seção.

Armazenamento em cache de metadados

O armazenamento em cache dos metadados de uma atividade cria e valida uma descrição dos argumentos, variáveis, atividades filho e delegados desta. Os metadados, por padrão, são armazenados em cache pelo tempo de execução quando uma atividade é preparada para execução. Se um autor de host de fluxo de trabalho quiser armazenar em cache os metadados de uma atividade ou árvore de atividade antes disso, por exemplo, para assumir todo o custo antecipadamente, poderá CacheMetadata ser usado para armazenar em cache os metadados no momento desejado.