Marcadores

Os marcadores são o mecanismo que permite que uma atividade aguarde passivamente a entrada sem segurar um thread de fluxo de trabalho. Quando uma atividade sinaliza que está à espera de estímulo, pode criar um marcador. Isso indica ao tempo de execução que a execução da atividade não deve ser considerada completa, mesmo quando o método atualmente em execução (que criou o Bookmark) retorna.

Noções básicas de favoritos

A Bookmark representa um ponto no qual a execução pode ser retomada (e através do qual a entrada pode ser entregue) dentro de uma instância de fluxo de trabalho. Normalmente, um é dado um nome e o Bookmark código externo (host ou extensão) é responsável por retomar o marcador com dados relevantes. Quando um Bookmark é retomado, o tempo de execução do fluxo de trabalho agenda o BookmarkCallback delegado que estava associado a ele Bookmark no momento de sua criação.

Opções de favoritos

A BookmarkOptions classe especifica o tipo de Bookmark criação que está sendo criada. Os possíveis valores não mutuamente exclusivos são None, MultipleResumee NonBlocking. Use None, o padrão, ao criar um Bookmark que se espera que seja retomado exatamente uma vez. Use MultipleResume ao criar um Bookmark que pode ser retomado várias vezes. Use NonBlocking ao criar um Bookmark que pode nunca ser retomado. Ao contrário dos marcadores criados usando o padrão BookmarkOptions, NonBlocking os marcadores não impedem que uma atividade seja concluída.

Retomada do marcador

Os favoritos podem ser retomados por código fora de um fluxo de trabalho usando uma das ResumeBookmark sobrecargas. Neste exemplo, uma ReadLine atividade é criada. Quando executada, a ReadLine atividade cria um Bookmark, registra um retorno de chamada e, em seguida, aguarda que o Bookmark seja retomado. Quando é retomada, a ReadLine atividade atribui os dados que foram passados com o Bookmark 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);  
    }  
}  

Neste exemplo, é 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 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 nome UserName e, em seguida, aguarda que o marcador seja retomado. O host coleta os dados desejados e, em seguida, retoma o Bookmark. O fluxo de trabalho é retomado, exibe o nome e é concluído. 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.

Resultado da retomada do marcador

ResumeBookmark Retorna um BookmarkResumptionResult valor de enumeração para indicar os resultados da solicitação de retomada do indicador. Os valores de retorno possíveis são Success, NotReady, e NotFound. Hosts e extensões podem usar esse valor para determinar como proceder.