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 a seguir, uma ReadLine atividade é criada. Quando executada, a atividade de ReadLine cria Bookmark, registra um retorno de chamada, e espera em Bookmark a ser continuado. Quando é continuada, a atividade de ReadLine atribui os dados que foram passados com Bookmark ao seu argumento de 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);  
    }  
}  

No exemplo a seguir, é criado um fluxo de trabalho que usa a ReadLine atividade para coletar o nome do usuário e exibi-lo na janela do console. O aplicativo host executa o trabalho real de coletar entrada e passá-lo para o fluxo de trabalho continuando 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 atividade de ReadLine é executada, cria Bookmark chamado UserName e espera no indexador a ser continuado. O host reúne os dados desejados e depois Bookmark. Retoma de fluxo de trabalho, exibe o nome, e então usa. Observe que nenhum código de sincronização é necessário em relação ao indexador continuar. Bookmark só pode ser que quando o fluxo de trabalho estiver ocioso, e se o fluxo de trabalho não estiver ocioso, a chamada para blocos de ResumeBookmark até que o fluxo de trabalho se torne ocioso.

Comentários

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

Os indicadores podem ser retomados pelo aplicativo host usando uma das ResumeBookmark sobrecargas.

Para obter mais informações sobre indicadores, consulte Using WorkflowInvoker and WorkflowApplication and Bookmarks.

Construtores

Propriedades

Métodos

Aplica-se a