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. WorkflowInspectionServicesUsando o , os fluxos de trabalho podem ser pesquisados para atividades filhas específicas, as atividades individuais e suas propriedades podem ser enumeradas e os metadados de tempo de execução das atividades podem ser armazenados em cache em um momento específico. Este tópico fornece uma visão geral e como usá-lo para inspecionar uma árvore de WorkflowInspectionServices atividades.

Usando WorkflowInspectionServices

O GetActivities método é usado para enumerar todas as atividades na árvore de atividades especificada. GetActivities Retorna um enumerável que toca todas as atividades dentro da árvore, incluindo filhos, 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 e expressão na árvore de atividades é gravado no 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);
    }
}

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

Item de lista 1
Listar Item 2Listar Item 3Listar Item 4Listar Item 5Itens adicionados à coleção.Seqüênciade caracteres de lista<literal<>>
Enquanto
Cadeia de caracteres AddToCollection<>
VariableValue<ICollection<String>>
Cadeia de caracteres LambdaValue<>
LocationReferenceValue<List<String>>
LambdaValue<Booleano>
LocationReferenceValue<List<String>>
ForEach<String>
VariableValue<IEnumerable<String>>
Linha de Escrita
Cadeia de caracteres DelegateArgumentValue<>
Sequência
Linha de Escrita
Cadeia de caracteres> literal<Para recuperar uma atividade específica em vez de enumerar todas as atividades, Resolve é usado. Ambos Resolve e GetActivities executar 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 ActivityValidationServices Validate 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 de atividade da atividade. 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.