Inspección del árbol de actividades

Los autores de la aplicación de flujo de trabajo usan la inspección del árbol de actividad para inspeccionar los flujos de trabajo hospedados por la aplicación. Al usar WorkflowInspectionServices, se pueden buscar actividades secundarias concretas en flujos de trabajo, se pueden enumerar las actividades individuales y sus propiedades, y los metadatos en tiempo de ejecución de las actividades pueden estar almacenados en memoria caché en un momento concreto. En este tema se proporciona información general de WorkflowInspectionServices y cómo usarlo para inspeccionar un árbol de actividad.

Usar WorkflowInspectionServices

El método GetActivities se usa para enumerar todas las actividades en el árbol de actividad especificado. GetActivities devuelve un enumerable que toca todas las actividades dentro del árbol como elementos secundarios, controladores delegados, valores predeterminados, variables y expresiones de argumento. En el ejemplo siguiente, se crea una definición de flujo de trabajo mediante Sequence, While, ForEach<T>, WriteLine y expresiones. Una vez creada la definición de flujo de trabajo, se invoca y, a continuación, se llama al método 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);

Se llama a GetActivities en la actividad raíz para enumerar las actividades y de nuevo de forma recursiva en cada actividad devuelta. En el siguiente ejemplo, el DisplayName de cada actividad y expresión en el árbol de actividad se escribe en la consola.

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 ejemplo proporciona el siguiente resultado:

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>
Secuencia
WriteLine
Literal<String> Para recuperar una actividad concreta en lugar de enumerar todas las actividades, se usa Resolve. Resolve y GetActivities realizan el almacenamiento en la memoria caché de los metadatos si no se ha llamado previamente a WorkflowInspectionServices.CacheMetadata. Si se ha llamado a CacheMetadata, GetActivities se basará en los metadatos existentes. Por consiguiente, si se han realizado cambios en el árbol desde la última llamada a CacheMetadata, los resultados de GetActivities podrían ser inesperados. Si los cambios se han realizado en el flujo de trabajo después de llamar a GetActivities, los metadatos se pueden volver a almacenar en caché llamando al método ActivityValidationServicesValidate. En la sección siguiente se trata el almacenamiento en la memoria caché de los metadatos.

Almacenar en memoria caché los metadatos

Almacenar en memoria caché los metadatos para una actividad compila y valida una descripción de los argumentos de la actividad, las variables, las actividades secundarias y los delegados de la actividad. De manera predeterminada, el tiempo de ejecución almacena los metadatos en la memoria caché cuando se prepara una actividad para que se ejecute. Si un autor de host de flujo de trabajo desea almacenar en memoria caché los metadatos para una actividad o árbol de actividad antes de esto como, por ejemplo, para calcular el costo inicial, se puede usar CacheMetadata para almacenar en memoria caché los metadatos en el momento deseado.