Bookmark Classe

Définition

public ref class Bookmark : IEquatable<System::Activities::Bookmark ^>

[System.Runtime.Serialization.DataContract]
public class Bookmark : IEquatable<System.Activities.Bookmark>

[<System.Runtime.Serialization.DataContract>]
type Bookmark = class
    interface IEquatable<Bookmark>

Public Class Bookmark
Implements IEquatable(Of Bookmark)

Héritage

Object

Bookmark

Attributs

DataContractAttribute

Implémente

IEquatable<Bookmark>

Exemples

Dans l’exemple suivant, une ReadLine activité est créée. Lorsqu'elle est exécutée, l'activité ReadLine crée un Bookmark, enregistre un rappel, puis attend que Bookmark soit repris. Lorsqu'elle reprend, l'activité ReadLine attribue les données transmises avec le Bookmark à son argument 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);
    }
}

Dans l’exemple suivant, un flux de travail est créé qui utilise l’activité ReadLine pour collecter le nom de l’utilisateur et l’afficher dans la fenêtre de console. L’application hôte effectue le travail réel de collecte de l’entrée et le transmet au flux de travail en reprenant le 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();

Lorsque l'activité ReadLine est exécutée, elle crée un Bookmark nommé UserName, puis attend la reprise du signet. L’hôte collecte les données souhaitées, puis reprend le Bookmark. Le flux de travail reprend, affiche le nom, puis se termine. Notez qu’aucun code de synchronisation n’est requis en ce qui concerne la reprise du signet. Un Bookmark ne peut être repris que lorsque le flux de travail est inactif, et si le flux de travail n'est pas inactif, l'appel à ResumeBookmark bloque jusqu'à ce que le flux de travail devienne inactif.

Remarques

Lorsqu’une activité crée une Bookmarkactivité, elle devient inactive et attend la Bookmark reprise. S’il existe d’autres activités en parallèle avec l’activité qui a créé le Bookmark, elles sont planifiées pour l’exécution.

Les signets peuvent être repris par l’application hôte à l’aide de l’une ResumeBookmark des surcharges.

Pour plus d’informations sur les signets, consultez Utilisation de WorkflowInvoker et workflowApplication et signets.