Che cosa sto facendo di sbagliato con il mio flusso di lavoro dei segnalibri raccogliere grilletto?

Question

Ho un NativeActivity derivato attività che ho scritto che è quello di utilizzare i segnalibri come un trigger per una filiale di prelievo. Usando qualcosa che ho trovato su MSDN ho provato a scrivere questo per innescare il ramo. Il ramo contiene le attività che i callback vigili del fuoco ai client remoti tramite le attività di invio. Se ho impostato un ritardo per il grilletto, callback fuoco ai clienti con successo. Se uso la mia attività di codice, le attività di filiale di prelievo non lo fanno fuoco.

public sealed class UpdateListener : NativeActivity<ClientUpdate>
{
    [RequiredArgument]
    public InArgument<string>     BookmarkName { get; set; }

    protected override void Execute(NativeActivityContext context)
    {
        context.CreateBookmark(BookmarkName.Get(context),
                    new BookmarkCallback(this.OnResumeBookmark));
    }


    protected override bool CanInduceIdle
    {
        get { return true; }
    }


    public void OnResumeBookmark(NativeActivityContext context, Bookmark bookmark, object obj )
    {
        Result.Set(context, (ClientUpdate)obj);
    }
}

Quindi, ci vuole un'arg per impostare il nome del segnalibro per i riferimenti futuri segnalibro per eseguire il grilletto. OnResumeBoookmark () prende in un oggetto ClientUpdate che viene passato dalla mia applicazione che ospita il workflowapp. L'attività è per restituire l'oggetto in modo che il ClientUpdate può essere passato al flusso di lavoro e lo hanno inviato ai client remoti tramite l'attività di invio nel ramo prelievo. In teoria ogni modo.

Per qualche ragione sembra essere corretto, ma si sente male. Non sono sicuro se devo scrivere l'attività in un modo diverso di prendersi cura di quello che mi serve per il mio servizio WF.

Answer 1

Credo che le vostre intenzioni sarebbero un po 'più chiaro se si è creato un'estensione (che implementa IWorkflowInstanceExtension) per eseguire la vostra azione qui.

Ad esempio:

public sealed class AsyncWorkExtension 
    : IWorkflowInstanceExtension
{
    // only one extension per workflow
    private WorkflowInstanceProxy _proxy;
    private Bookmark _lastBookmark;

    /// <summary>
    /// Request the extension does some work for an activity
    /// during which the activity will idle the workflow
    /// </summary>
    /// <param name="toResumeMe"></param>
    public void DoWork(Bookmark toResumeMe)
    {
        _lastBookmark = toResumeMe;
        // imagine I kick off some async op here
        // when complete system calls WorkCompleted below
        // NOTE:  you CANNOT block here or you block the WF!
    }

    /// <summary>
    /// Called by the system when long-running work is complete
    /// </summary>
    /// <param name="result"></param>
    internal void WorkCompleted(object result)
    {
        //NOT good practice!  example only
        //this leaks resources search APM for details
        _proxy.BeginResumeBookmark(_lastBookmark, result, null, null);
    }

    /// <summary>
    /// When implemented, returns any additional extensions 
    /// the implementing class requires.
    /// </summary>
    /// <returns>
    /// A collection of additional workflow extensions.
    /// </returns>
    IEnumerable<object> IWorkflowInstanceExtension
        .GetAdditionalExtensions()
    {
        return new object[0];
    }

    /// <summary>
    /// Sets the specified target 
    /// <see cref="WorkflowInstanceProxy"/>.
    /// </summary>
    /// <param name="instance">The target workflow instance to set.</param>
    void IWorkflowInstanceExtension
        .SetInstance(WorkflowInstanceProxy instance)
    {
        _proxy = instance;
    }
}

all'interno dell'attività, utilizza questo nel seguente modo:

 var ext = context.GetExtension<AsyncWorkExtension>();
 var bookmark = context.CreateBookmark(BookmarkCallback);
 ext.DoWork(bookmark);
 return;

In questo modo è molto più esplicito (invece di utilizzare il nome del segnalibro per trasmettere un senso al mondo "esterno") ed è molto più facile di estendere se, per esempio, si richiede di inviare più informazioni di un nome di segnalibro.

Answer 2

C'è qualcosa che in realtà riprendere il segnalibro qui? In caso contrario il flusso di lavoro attenderà con molta pazienza e non accadrà nulla.