Inspeção da Árvore de Atividades

A inspeção da árvore de atividade é usada por autores de aplicativo de fluxo de trabalho para inspecionar os fluxos de trabalho hospedados pelo aplicativo. Usando WorkflowInspectionServices, 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 num momento específico. Este tópico fornece uma visão geral de WorkflowInspectionServices e como usá-la para inspecionar uma árvore de atividade.

Usando WorkflowInspectionServices

O método de GetActivities é usado para enumerar todas as atividades na árvore de atividade especificada. retorna umGetActivities enumerável que abrange todas as atividades dentro da árvore, incluindo subatividades, manipuladores de delegados, variáveis padrão e expressões de argumento. No exemplo a seguir, uma definição de fluxo de trabalho é criada usando Sequence, While, ForEach<T>, WriteLine, e expressões. Depois que a definição de fluxo de trabalho é criada, ela é invocada e, em seguida, o método de InspectActivity é 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, GetActivities é chamado na atividade de raiz, e recursivamente novamente em cada atividade retornada. No exemplo a seguir, DisplayName de cada atividade e expressão na árvore de atividades é escrito no 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);
    }
}

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

Item de Lista 1Item de Lista 2Item de Lista 3Item de Lista 4Item de Lista 5Itens adicionados à coleção.Cadeia de caracteres de lista<<literal>> de sequência enquantoAddToCollection<String>VariableValue<ICollection<String>>LambdaValue<String>LocationReferenceValue<List String<>>LambdaValue<Boolean>LocationReferenceValue<List String<>>ForEach<String>VariableValue<IEnumerable<String>>WriteLineDelegateArgumentValue<String String>WriteLineLiteral<String> To retrieve a specific activity instead of enumerating all of the activities, Resolve is used. Resolve e GetActivities realizam cache de metadados se WorkflowInspectionServices.CacheMetadata não tiver sido chamado anteriormente. Se CacheMetadata tiver sido chamado, então GetActivities é baseado nos metadados existentes. Portanto, se houve alterações na árvore desde a última chamada para CacheMetadata, GetActivities pode produzir resultados inesperados. Se alterações foram feitas no fluxo de trabalho após a chamada para GetActivities, os metadados podem ser armazenados em cache novamente chamando o método ActivityValidationServicesValidate. O armazenamento em cache de metadados será discutido na seção a seguir.

Metadados de Cache

Armazenar em cache os metadados para uma atividade compila e valida uma descrição dos argumentos da atividade, variáveis, as atividades filhas e os delegados de atividade. Os metadados são armazenados em cache por padrão durante o tempo de execução, quando uma atividade é preparada para execução. Se um autor de host de fluxo de trabalho deseja armazenar em cache os metadados para uma atividade ou a árvore de atividades antes disso, por exemplo, tomar com antecedência todos os custos, então, CacheMetadata pode ser usado para armazenar em cache os metadados no momento desejado.