Bokmärken

Bokmärken är den mekanism som gör det möjligt för en aktivitet att passivt vänta på indata utan att hålla i en arbetsflödestråd. När en aktivitet signalerar att den väntar på stimulans kan den skapa ett bokmärke. Detta indikerar för körningen att aktivitetens körning inte ska betraktas som fullständig även när den metod som körs för närvarande (som skapade Bookmark) returnerar.

Grunderna i bokmärken

A Bookmark representerar en punkt där körningen kan återupptas (och genom vilken indata kan levereras) i en arbetsflödesinstans. Vanligtvis får en Bookmark ett namn och extern kod (värd eller tillägg) ansvarar för att återuppta bokmärket med relevanta data. När en Bookmark återupptas schemalägger arbetsflödeskörningen det BookmarkCallback ombud som var associerat med det Bookmark när det skapades.

Bokmärkesalternativ

Klassen BookmarkOptions anger vilken typ av Bookmark som skapas. Möjliga icke ömsesidigt uteslutande värden är None, MultipleResumeoch NonBlocking. Använd None, standardvärdet när du skapar en Bookmark som förväntas återupptas exakt en gång. Använd MultipleResume när du skapar en Bookmark som kan återupptas flera gånger. Använd NonBlocking när du skapar en Bookmark som kanske aldrig återupptas. Till skillnad från bokmärken som skapats med standardinställningen BookmarkOptionsNonBlocking hindrar bokmärken inte en aktivitet från att slutföras.

Återtagande av bokmärke

Bokmärken kan återupptas med kod utanför ett arbetsflöde med hjälp av en av överlagringarna ResumeBookmark . I det här exemplet skapas en ReadLine aktivitet. När den ReadLine körs skapar aktiviteten en Bookmark, registrerar ett återanrop och väntar sedan på Bookmark att återupptas. När den återupptas ReadLine tilldelar aktiviteten de data som skickades med Bookmark argumentet till .Result

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

I det här exemplet skapas ett arbetsflöde som använder ReadLine aktiviteten för att samla in användarens namn och visa det i konsolfönstret. Värdprogrammet utför det faktiska arbetet med att samla in indata och skickar det till arbetsflödet genom att Bookmarkåteruppta .

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();  

När aktiviteten körs skapar den ett Bookmark namngivet ReadLineUserName och väntar sedan på att bokmärket ska återupptas. Värden samlar in önskade data och återupptar Bookmarksedan . Arbetsflödet återupptas, visar namnet och slutförs sedan. Observera att ingen synkroniseringskod krävs för att återuppta bokmärket. A Bookmark kan bara återupptas när arbetsflödet är inaktivt, och om arbetsflödet inte är inaktivt blockeras anropet till ResumeBookmark tills arbetsflödet blir inaktivt.

Resultat för återtagande av bokmärke

ResumeBookmark returnerar ett BookmarkResumptionResult uppräkningsvärde för att visa resultatet av begäran om att återuppta bokmärket. Möjliga returvärden är Success, NotReadyoch NotFound. Värdar och tillägg kan använda det här värdet för att avgöra hur du ska gå vidare.