Bookmark Classe

Definição

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)

Herança

Object

Bookmark

Atributos

DataContractAttribute

Implementações

IEquatable<Bookmark>

Exemplos

No exemplo seguinte, é criada uma ReadLine atividade. Quando executada, a ReadLine atividade cria um Bookmark, regista um retorno de chamada e depois aguarda que o Bookmark seja retomado. Quando é retomada, a ReadLine atividade atribui os dados que foram passados com o Bookmark ao seu Result argumento.

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

No exemplo seguinte, é criado um fluxo de trabalho que utiliza a ReadLine atividade para recolher o nome do utilizador e exibi-lo na janela da consola. O aplicativo host executa o trabalho real de coleta da entrada e a passa para o fluxo de trabalho retomando o 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();

Quando a ReadLine atividade é executada, ela cria um Bookmark chamado UserName e, em seguida, aguarda pela retoma do marcador. O host coleta os dados desejados e, em seguida, retoma o Bookmark. O fluxo de trabalho retoma, exibe o nome e depois conclui. Observe que nenhum código de sincronização é necessário em relação a retomar o marcador. A Bookmark só pode ser retomado quando o fluxo de trabalho estiver ocioso e, se o fluxo de trabalho não estiver ocioso, a chamada para ResumeBookmark será bloqueada até que o fluxo de trabalho fique ocioso.

Observações

Quando uma atividade cria um Bookmark, fica inativa e espera que o Bookmark seja retomado. Se existirem outras atividades em paralelo com a atividade que criou o Bookmark, elas serão agendadas para execução.

Os marcadores podem ser retomados pela aplicação anfitriã usando uma das ResumeBookmark sobrecargas.

Para mais informações sobre favoritos, consulte Utilização do WorkflowInvoker e WorkflowApplication e Marcadores.