Inspeção da árvore de atividade

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 filhos específicas, as atividades individuais e suas propriedades podem ser enumeradas, e os metadados de runtime das atividades podem ser armazenados em cachê em um horário 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 toque em todas as atividades dentro da árvore que inclui filhos, manipuladores de representante opções, variáveis, 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, invoca-se e o método de InspectActivity é então 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 a atividade de raiz, e novamente recursivamente em cada atividade retornado. No exemplo a seguir, DisplayName de cada atividade e expressão na árvore de atividade é 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("{0}{1}", new string(' ', indent), root.DisplayName);

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

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

List Item 1
List Item 2List Item 3List Item 4List Item 5Items added to collection.SequenceLiteral<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>
Sequência
WriteLine
Literal<String> Para recuperar uma atividade específica em vez de enumerar todas as atividades, Resolve é usado. Resolve e GetActivities executam o cachê de metadados WorkflowInspectionServices.CacheMetadata se não tiver sido chamado anteriormente. Se CacheMetadata tiver sido chamado em GetActivities é baseado nos metadados existentes. Portanto, se as alterações de árvore foram feitas desde a última chamada a CacheMetadata, GetActivities pode dar resultados inesperados. Se as alterações foram feitas ao fluxo de trabalho após chamar GetActivities, os metadados que podem ser armazenados em cache novamente chamando o método ActivityValidationServicesValidate. Armazenando em cachê metadados é abordado na seção a seguir.

Metadados de Caching

Armazenando em cachê os metadados para uma atividade compila e valida uma descrição dos argumentos de atividade, variáveis, as atividades filhos, e os representantes de atividade. Os metadados, são armazenados em cachê por padrão no runtime em que uma atividade é preparada para a execução. Se um autor de host de fluxo de trabalho deseja armazenar em cachê os metadados para uma atividade ou a árvore de atividade antes disso, por exemplo tomar com antecedência todos os custos, então CacheMetadata pode ser usada para armazenar em cachê os metadados em tempo desejado.