Qu'est-ce que je fais de mal avec mon déclencheur de sélection de signets Workflow?

Question

J'ai une activité dérivée NativeActivity que j'ai écrite pour utiliser les signets comme déclencheur pour une branche de sélection. En utilisant quelque chose que j'ai trouvé sur MSDN j'ai essayé d'écrire ceci pour déclencher la branche. La branche contient des activités qui envoient des rappels de service aux clients distants via des activités d'envoi. Si je définis un délai pour le déclencheur, les rappels se déclenchent sur les clients avec succès. Si j'utilise mon activité de code, les activités de branche de sélection ne se déclenchent pas. Il faut donc un argument pour définir le nom du signet pour les futures références de signets afin d'exécuter le déclencheur. OnResumeBoookmark() prend un objet ClientUpdate qui est passé par mon application qui héberge l'application workflow. L'activité consiste à renvoyer l'objet afin que le ClientUpdate puisse être transmis au flux de travail et qu'il soit envoyé aux clients distants via l'activité d'envoi dans la branche de sélection. En théorie de toute façon.

Pour une raison quelconque, il semble être correct, mais se sent mal. Je ne suis pas sûr si je devrais écrire l'activité d'une manière différente pour prendre soin de ce dont j'ai besoin pour mon service WF.

Answer 1

Je pense que vos intentions seraient un peu plus claires si vous créiez une extension (qui implémente IWorkflowInstanceExtension) pour effectuer votre action ici.

Par exemple:

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

Au sein de l'activité, vous utiliseriez ce ainsi:

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

De cette façon est beaucoup plus explicite (au lieu d'utiliser le nom du signet pour transmettre un sens à la "monde extérieur") et est beaucoup plus facile à étendre si, disons, vous avez besoin d'envoyer plus d'informations qu'un nom de signet.

Answer 2

Y at-il quelque chose qui reprend le signet ici? Si ce n'est pas le flux de travail attendra très patiemment et rien ne se passera.