Favoritos

Indexadores são o mecanismo que permite uma atividade para esperar passiva entrada sem conter um segmento de fluxo de trabalho. Quando uma atividade sinaliza que está aguardando um estímulo, ela pode criar um marcador. Isso indica ao runtime que a execução da atividade não deve ser considerada concluída mesmo quando o método em execução (que criou o Bookmark) retorna.

Noções básicas do indexador

Um Bookmark representa um ponto no qual a execução pode ser retomada (e por meio do qual a entrada pode ser entregue) em uma instância de fluxo de trabalho. Normalmente, um Bookmark recebe um nome, e um código externo (host ou extensão) é responsável por retomar o marcador com dados relevantes. Quando Bookmark é que, o runtime de fluxo de trabalho agenda o representante de BookmarkCallback que foi associado com esse Bookmark na altura do projeto.

Opções de marcador

A BookmarkOptions classe especifica o tipo de Bookmark que está sendo criado. Os possíveis valores não mutuamente exclusivos são None, MultipleResumee NonBlocking. Use None, o padrão, ao criar um Bookmark que deve ser retomado exatamente uma vez. Use MultipleResume ao criar um Bookmark que pode ser retomado várias vezes. Use NonBlocking ao criar um Bookmark que talvez nunca seja retomado. Ao contrário dos favoritos criados usando o padrão BookmarkOptions, os favoritos NonBlocking não impedem a conclusão de uma atividade.

Ressunção do indexador

Indexadores podem ser continuados pelo código fora de um fluxo de trabalho usando uma das sobrecargas de ResumeBookmark . Neste exemplo, 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 ela é retomada, a ReadLine atividade atribui os dados que foram passados com o Bookmark ao seu argumento 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);  
    }  
}  

Neste exemplo, um fluxo de trabalho é criado 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 chamado UserName e 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, em seguida, é concluído. Observe que nenhum código de sincronização é necessário em relação à retomada do marcador. 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.

Resultado de ressunção do indexador

ResumeBookmark retorna um valor de enumeração BookmarkResumptionResult para indicar os resultados da solicitação de ressunção do indexador. Os valores retornados possíveis são Success, NotReadye NotFound. Hosts e extensões podem usar esse valor para determinar como proceder.