Bladwijzers

Bladwijzers zijn het mechanisme waarmee een activiteit passief kan wachten op invoer zonder vast te houden aan een werkstroomthread. Wanneer een activiteit aangeeft dat er wordt gewacht op prikkels, kan er een bladwijzer worden gemaakt. Dit geeft aan de runtime aan dat de uitvoering van de activiteit niet als voltooid moet worden beschouwd, zelfs niet wanneer de momenteel uitgevoerde methode (die de methode Bookmarkheeft gemaakt) retourneert.

Basisbeginselen van bladwijzers

Een Bookmark vertegenwoordigt een punt waarop de uitvoering kan worden hervat (en via welke invoer kan worden geleverd) binnen een werkstroomexemplaren. Normaal gesproken krijgt een Bookmark naam en externe code (host of extensie) is verantwoordelijk voor het hervatten van de bladwijzer met relevante gegevens. Wanneer een Bookmark bestand wordt hervat, plant de werkstroomruntime de BookmarkCallback gemachtigde die eraan Bookmark is gekoppeld op het moment dat deze is gemaakt.

Opties voor bladwijzers

De BookmarkOptions klasse specificeert het type dat Bookmark wordt gemaakt. De mogelijke niet-wederzijds exclusieve waarden zijn None, MultipleResumeen NonBlocking. Gebruik None, de standaardwaarde bij het maken van een Bookmark die naar verwachting exact één keer wordt hervat. Gebruik MultipleResume deze functie bij het maken van een Bookmark bestand dat meerdere keren kan worden hervat. Gebruik NonBlocking deze functie bij het maken van een Bookmark bestand dat mogelijk nooit wordt hervat. In tegenstelling tot bladwijzers die zijn gemaakt met de standaardwaarde BookmarkOptions, NonBlocking verhinderen bladwijzers niet dat een activiteit wordt voltooid.

Hervatting van bladwijzer

Bladwijzers kunnen worden hervat door code buiten een werkstroom met behulp van een van de ResumeBookmark overbelastingen. In dit voorbeeld wordt een ReadLine activiteit gemaakt. Wanneer de ReadLine activiteit wordt uitgevoerd, wordt er een Bookmarkcallback gemaakt, wordt er een callback geregistreerd en wordt gewacht totdat de Bookmark activiteit is hervat. Wanneer deze wordt hervat, wijst de ReadLine activiteit de gegevens toe die met het BookmarkResult argument zijn doorgegeven.

public sealed class ReadLine : NativeActivity<string>  
{  
    [RequiredArgument]  
    public  InArgument<string> BookmarkName { get; set; }  
  
    protected override void Execute(NativeActivityContext context)  
    {  
        // Create a Bookmark and wait for it to be resumed.  
        context.CreateBookmark(BookmarkName.Get(context),
            new BookmarkCallback(OnResumeBookmark));  
    }  
  
    // NativeActivity derived activities that do asynchronous operations by calling
    // one of the CreateBookmark overloads defined on System.Activities.NativeActivityContext
    // must override the CanInduceIdle property and return true.  
    protected override bool CanInduceIdle  
    {  
        get { return true; }  
    }  
  
    public void OnResumeBookmark(NativeActivityContext context, Bookmark bookmark, object obj)  
    {  
        // When the Bookmark is resumed, assign its value to  
        // the Result argument.  
        Result.Set(context, (string)obj);  
    }  
}  

In dit voorbeeld wordt een werkstroom gemaakt die gebruikmaakt van de activiteit om de ReadLine naam van de gebruiker te verzamelen en weer te geven in het consolevenster. De hosttoepassing voert het werkelijke werk uit van het verzamelen van de invoer en geeft deze door aan de werkstroom door de Bookmark.

Variable<string> name = new Variable<string>  
{  
    Name = "name"  
};  
  
Activity wf = new Sequence  
{  
    Variables =  
    {  
        name  
    },  
    Activities =  
    {  
        new WriteLine()  
        {  
            Text = "What is your name?"  
        },  
        new ReadLine()  
        {  
            BookmarkName = "UserName",  
            Result = name  
        },  
        new WriteLine()  
        {  
            Text = new InArgument<string>((env) => "Hello, " + name.Get(env))  
        }  
    }  
};  
  
AutoResetEvent syncEvent = new AutoResetEvent(false);  
  
// Create the WorkflowApplication using the desired  
// workflow definition.  
WorkflowApplication wfApp = new WorkflowApplication(wf);  
  
// Handle the desired lifecycle events.  
wfApp.Completed = delegate(WorkflowApplicationCompletedEventArgs e)  
{  
    // Signal the host that the workflow is complete.  
    syncEvent.Set();  
};  
  
// Start the workflow.  
wfApp.Run();  
  
// Collect the user's name and resume the bookmark.  
// Bookmark resumption only occurs when the workflow  
// is idle. If a call to ResumeBookmark is made and the workflow  
// is not idle, ResumeBookmark blocks until the workflow becomes  
// idle before resuming the bookmark.  
wfApp.ResumeBookmark("UserName", Console.ReadLine());  
  
// Wait for Completed to arrive and signal that  
// the workflow is complete.  
syncEvent.WaitOne();  

Wanneer de ReadLine activiteit wordt uitgevoerd, wordt er een Bookmark benoemde gemaakt UserName en wordt gewacht totdat de bladwijzer is hervat. De host verzamelt de gewenste gegevens en hervat vervolgens de Bookmark. De werkstroom wordt hervat, de naam wordt weergegeven en vervolgens voltooid. Houd er rekening mee dat er geen synchronisatiecode is vereist met betrekking tot het hervatten van de bladwijzer. Een Bookmark kan alleen worden hervat wanneer de werkstroom niet actief is en als de werkstroom niet inactief is, wordt de aanroep om te ResumeBookmark blokkeren totdat de werkstroom niet actief wordt.

Resultaat van hervatting van bladwijzer

ResumeBookmark retourneert een BookmarkResumptionResult opsommingswaarde om de resultaten van de aanvraag voor het hervatten van bladwijzers aan te geven. De mogelijke retourwaarden zijn Success, NotReadyen NotFound. Hosts en extensies kunnen deze waarde gebruiken om te bepalen hoe u doorgaat.