Esposizione di dati con CacheMetadata

Prima di eseguire un'attività, il runtime del flusso di lavoro ottiene tutte le informazioni sull'attività necessaria per mantenere l'esecuzione. Il runtime del flusso di lavoro ottiene queste informazioni durante l'esecuzione del CacheMetadata metodo . L'implementazione predefinita di questo metodo fornisce al runtime tutti gli argomenti, le variabili e le attività figlie pubbliche messe a disposizione dall'attività nel momento in cui viene eseguita; se l'attività deve fornire più informazioni al runtime, come membri privati o attività da pianificare da parte dell'attività stessa, è possibile eseguire l'override di questo metodo per fornirle.

Comportamento predefinito di CacheMetadata

Implementazione predefinita di CacheMetadata per le attività che derivano da NativeActivity processi i seguenti tipi di metodo nei seguenti modi:

• InArgument<T>, OutArgument<T>o InOutArgument<T> (argomenti generici): questi argomenti vengono esposti al runtime come argomenti con un nome e un tipo uguali al nome e al tipo di proprietà esposti, alla direzione dell'argomento appropriata e ad alcuni dati di convalida.

• Variable o qualsiasi sottoclasse: questi membri vengono esposti al runtime come variabili pubbliche.

• Activity o qualsiasi sottoclasse: questi membri vengono esposti al runtime come attività figlio pubbliche. Il comportamento predefinito può essere implementato in modo esplicito chiamando AddImportedChild, passando l'attività figlia.

• ActivityDelegate o qualsiasi sottoclasse: questi membri vengono esposti al runtime come delegati pubblici.

• ICollection di tipo Variable: tutti gli elementi della raccolta vengono esposti al runtime come variabili pubbliche.

• ICollection di tipo Activity: tutti gli elementi della raccolta vengono esposti al runtime come figli pubblici.

• ICollection di tipo ActivityDelegate: tutti gli elementi della raccolta vengono esposti al runtime come delegati pubblici.

Per CacheMetadata le attività che derivano da Activity, CodeActivitye AsyncCodeActivity funzionano anche come sopra, ad eccezione delle differenze seguenti:

• Le classi che derivano da Activity non possono pianificare attività figlio o delegati, pertanto tali membri vengono esposti come elementi figlio e delegati importati;

• Le classi che derivano da CodeActivity e AsyncCodeActivity non supportano variabili, elementi figlio o delegati, quindi verranno esposti solo gli argomenti.

Sovrascrivere CacheMetadata per fornire informazioni al runtime

Il frammento di codice seguente illustra come aggiungere informazioni sui membri ai metadati di un'attività durante l'esecuzione del CacheMetadata metodo . Si noti che la base del metodo viene chiamata per memorizzare nella cache tutti i dati pubblici relativi all'attività.

protected override void CacheMetadata(NativeActivityMetadata metadata)
{
    base.CacheMetadata(metadata);
    metadata.AddImplementationChild(this._writeLine);
    metadata.AddVariable(this._myVariable);
    metadata.AddImplementationVariable(this._myImplementationVariable);

    RuntimeArgument argument = new RuntimeArgument("MyArgument", ArgumentDirection.In, typeof(SomeType));
    metadata.Bind(argument, this.SomeName);
    metadata.AddArgument(argument);
}

Uso di CacheMetadata per esporre i sottocomponenti di implementazione

Per passare i dati alle attività secondarie che devono essere pianificate da un'attività usando variabili, è necessario aggiungere le variabili come variabili di implementazione; le variabili pubbliche non possono assegnare valori in questo modo specifico. Il motivo è che le attività devono essere eseguite più come implementazioni di funzioni (che hanno parametri), anziché classi incapsulate (che hanno proprietà). Tuttavia, ci sono situazioni in cui gli argomenti devono essere impostati esplicitamente, ad esempio quando si usa ScheduleActivity, poiché l'attività pianificata non ha accesso agli argomenti dell'attività padre come farebbe un'attività figlia.

Il frammento di codice seguente illustra come passare un argomento da un'attività nativa a un'attività pianificata usando CacheMetadata.

public sealed class ChildActivity : NativeActivity
{
    public WriteLine _writeLine;
    public InArgument<string> Message { get; set; }
    private Variable<string> MessageVariable { get; set; }
    public ChildActivity()
    {
        MessageVariable = new Variable<string>();
        _writeLine = new WriteLine
        {
            Text = new InArgument<string>(MessageVariable),
        };
    }
    protected override void CacheMetadata(NativeActivityMetadata metadata)
    {
        base.CacheMetadata(metadata);
        metadata.AddImplementationVariable(this.MessageVariable);
        metadata.AddImplementationChild(this._writeLine);
    }
    protected override void Execute(NativeActivityContext context)
    {
        string configuredMessage = context.GetValue(Message);
        context.SetValue(MessageVariable, configuredMessage);
        context.ScheduleActivity(this._writeLine);
    }
}