Condividi tramite


Esposizione dei dati con CacheMetadata

Prima di eseguire un'attività, il runtime del flusso di lavoro ottiene tutte le informazioni sull'attività necessarie per la gestione dell'esecuzione. Tali informazioni vengono ottenute durante l'esecuzione del metodo CacheMetadata. L'implementazione predefinita di questo metodo fornisce al runtime tutti gli argomenti pubblici, le variabili e le attività figlio esposti dall'attività al momento dell'esecuzione; se l'attività deve dare ulteriori informazioni al runtime, ad esempio membri privati o attività che devono essere pianificate dall'attività, è possibile eseguire l'override di questo metodo.

Comportamento predefinito di CacheMetadata

L'implementazione predefinita di CacheMetadata per le attività che derivano da NativeActivity elabora i tipi di metodo seguenti nelle modalità riportate di seguito:

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

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

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

  • ActivityDelegate o qualsiasi sottoclasse relativa: 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 elementi figlio pubblici.

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

Anche l'oggetto CacheMetadata per le attività che derivano da Activity, CodeActivity e AsyncCodeActivity funziona nel modo descritto sopra, tranne che per le 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 figli o delegati, pertanto vengono esposti solo gli argomenti.

Override di CacheMetadata per fornire informazioni al runtime

Nel frammento di codice seguente viene illustrato come aggiungere informazioni sui membri ai metadati di un'attività durante l'esecuzione del metodo CacheMetadata. Notare che la base del metodo è chiamata per memorizzare nella cache tutti i dati pubblici sull'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 elementi figlio di implementazione

Per passare dati ad attività figlio che devono essere pianificate da un'attività usando variabili, è necessario aggiungere le variabili come variabili di implementazione; i valori delle variabili pubbliche non possono essere impostati in questo modo. Il motivo di ciò è che le attività devono essere eseguite più come implementazioni di funzioni (che dispongono di parametri) che come classi incapsulate (che dispongono di proprietà). Tuttavia, ci sono situazioni nelle quali gli argomenti devono essere impostati in modo esplicito, ad esempio nel caso dell'utilizzo di ScheduleActivity, dal momento che l'attività pianificata non dispone dell'accesso agli argomenti dell'attività padre come un'attività figlio.

Nel frammento di codice seguente viene illustrato come passare un argomento da un'attività nativa in 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);
    }
}