Ispezione dell'albero delle attivitàActivity Tree Inspection

L'ispezione dell'albero delle attività viene usata dagli autori dell'applicazione flusso di lavoro per controllare i flussi di lavoro ospitati dall'applicazione.Activity tree inspection is used by workflow application authors to inspect the workflows hosted by the application. Tramite l'oggetto WorkflowInspectionServices, nei flussi di lavoro è possibile cercare attività figlio specifiche, enumerare attività singole e le relative proprietà, nonché memorizzare nella cache i metadati di runtime delle attività in un momento specifico.By using WorkflowInspectionServices, workflows can be searched for specific child activities, individual activities and their properties can be enumerated, and runtime metadata of the activities can be cached at a specific time. In questo argomento viene fornita una panoramica sull'oggetto WorkflowInspectionServices e viene descritto come usarlo per controllare un albero delle attività.This topic provides an overview of WorkflowInspectionServices and how to use it to inspect an activity tree.

Utilizzo dell'oggetto WorkflowInspectionServicesUsing WorkflowInspectionServices

Il metodo GetActivities viene usato per enumerare tutte le attività nell'albero delle attività specificato.The GetActivities method is used to enumerate all of the activities in the specified activity tree. GetActivities restituisce un enumerabile che tocca tutte le attività all'interno dell'albero, inclusi gli elementi figlio, i gestori delegato, le impostazioni predefinite variabili e le espressioni argomento.GetActivities returns an enumerable that touches all activities within the tree including children, delegate handlers, variable defaults, and argument expressions. Nell'esempio seguente viene creata una definizione di flusso di lavoro tramite gli oggetti Sequence, While, ForEach<T>, WriteLine e le espressioni.In the following example, a workflow definition is created by using a Sequence, While, ForEach<T>, WriteLine, and expressions. Una volta creata, la definizione di flusso di lavoro viene richiamata, quindi viene chiamato il metodo InspectActivity.After the workflow definition is created, it is invoked and then the InspectActivity method is called.

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

Per enumerare le attività, viene chiamato GetActivities nell'attività radice e di nuovo in modo ricorsivo in ogni attività restituita.To enumerate the activities, the GetActivities is called on the root activity, and again recursively on each returned activity. Nell'esempio seguente la proprietà DisplayName di ogni attività ed espressione dell'albero delle attività viene scritta nella console.In the following example, the DisplayName of each activity and expression in the activity tree is written to the 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);
    }
}

Questo codice di esempio fornisce l'output seguente.This sample code provides the following output.

Elemento dell'elenco 1List Item 1
Elemento di elenco 2 List Item 2
Elemento di elenco 3 List Item 3
Elemento 4 dell'elenco List Item 4
Elemento di elenco 5 List Item 5
Elementi aggiunti alla raccolta. Items added to collection.
sequenza Sequence
Valore letterale < elenco<stringa >>Literal<List<String>>
WhileWhile
AddToCollection<stringa >AddToCollection<String>
VariableValue < ICollection<stringa >>VariableValue<ICollection<String>>
LambdaValue<stringa >LambdaValue<String>
LocationReferenceValue < elenco<stringa >>LocationReferenceValue<List<String>>
LambdaValue<booleano >LambdaValue<Boolean>
LocationReferenceValue < elenco<stringa >>LocationReferenceValue<List<String>>
ForEach<stringa >ForEach<String>
VariableValue < IEnumerable<stringa >>VariableValue<IEnumerable<String>>
WriteLineWriteLine
DelegateArgumentValue<stringa >DelegateArgumentValue<String>
sequenzaSequence
WriteLineWriteLine
Valore letterale<stringa > per recuperare un'attività specifica anziché enumerare tutte le attività, Resolve viene utilizzato.Literal<String> To retrieve a specific activity instead of enumerating all of the activities, Resolve is used. Entrambi i metodi Resolve e GetActivities eseguono la memorizzazione dei metadati nella cache se non è stato precedentemente chiamato l'oggetto WorkflowInspectionServices.CacheMetadata.Both Resolve and GetActivities perform metadata caching if WorkflowInspectionServices.CacheMetadata has not been previously called. Se il metodo CacheMetadata è stato chiamato, il metodo GetActivities si basa sui metadati esistenti.If CacheMetadata has been called then GetActivities is based on the existing metadata. Pertanto, se sono state apportate modifiche all'albero dall'ultima chiamata al metodo CacheMetadata, il metodo GetActivities potrebbe fornire risultati imprevisti.Therefore, if tree changes have been made since the last call to CacheMetadata, GetActivities might give unexpected results. Se sono state apportate modifiche al flusso di lavoro dopo la chiamata GetActivities, i metadati possono essere nuovamente memorizzati nella cache chiamando il ActivityValidationServices Validate metodo.If changes have been made to the workflow after calling GetActivities, metadata can be re-cached by calling the ActivityValidationServices Validate method. La memorizzazione dei metadati nella cache è descritta nella prossima sezione.Caching metadata is discussed in the next section.

Memorizzazione dei metadati nella cacheCaching Metadata

La memorizzazione dei metadati nella cache per un'attività compila e convalida una descrizione degli argomenti dell'attività, delle variabili, delle attività figlio e dei delegati di attività.Caching the metadata for an activity builds and validates a description of the activity’s arguments, variables, child activities, and activity delegates. Per impostazione predefinita, i metadati vengono memorizzati nella cache dal runtime quando un'attività viene preparata per l'esecuzione.Metadata, by default, is cached by the runtime when an activity is prepared for execution. Se un autore dell'host del flusso di lavoro desidera memorizzare i metadati nella cache per un'attività o un albero delle attività prima di questa fase, ad esempio per accettare in anticipo tutto il costo, è possibile usare il metodo CacheMetadata per memorizzare i metadati nella cache nel momento desiderato.If a workflow host author wants to cache the metadata for an activity or activity tree before this, for example to take all of the cost upfront, then CacheMetadata can be used to cache the metadata at the desired time.