WorkflowInvoker.EndInvoke(IAsyncResult) Méthode

Référence

Définition

Espace de noms:: System.Activities

Assembly:: System.Activities.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne les résultats d'un flux de travail appelé à l'aide de l'une des surcharges de BeginInvoke.

public:
 System::Collections::Generic::IDictionary<System::String ^, System::Object ^> ^ EndInvoke(IAsyncResult ^ result);

public System.Collections.Generic.IDictionary<string,object> EndInvoke (IAsyncResult result);

member this.EndInvoke : IAsyncResult -> System.Collections.Generic.IDictionary<string, obj>

Public Function EndInvoke (result As IAsyncResult) As IDictionary(Of String, Object)

Paramètres

result: IAsyncResult

Objet IAsyncResult qui fait référence à l'opération BeginInvoke ayant démarré le flux de travail.

Retours

IDictionary<String,Object>

Dictionnaire des valeurs OutArgument et InOutArgument de l’activité racine indexées par nom d’argument et représentant les sorties du flux de travail.

Exemples

L'exemple suivant appelle un flux de travail composé d'une activité LongRunningDiceRoll. L’activité LongRunningDiceRoll a deux arguments de sortie qui représentent les résultats du jet de dés. Ces arguments sont récupérés via l'appel de EndInvoke. Lors du retour de l’appel à EndInvoke, chaque argument de sortie, indexé par nom d’argument, est retourné dans le dictionnaire de sorties.

public sealed class LongRunningDiceRoll : Activity
{
    public OutArgument<int> D1 { get; set; }
    public OutArgument<int> D2 { get; set; }

    public LongRunningDiceRoll()
    {
        this.Implementation = () => new Sequence
        {
            Activities =
            {
                new WriteLine
                {
                    Text = "Rolling the dice for 5 seconds."
                },
                new Delay
                {
                    Duration = TimeSpan.FromSeconds(5)
                },
                new DiceRoll
                {
                    D1 = new OutArgument<int>(env => this.D1.Get(env)),
                    D2 = new OutArgument<int>(env => this.D2.Get(env))
                }
            }
        };
    }
}

static void BeginInvokeExample()
{
    WorkflowInvoker invoker = new WorkflowInvoker(new LongRunningDiceRoll());

    string userState = "BeginInvoke example";
    IAsyncResult result = invoker.BeginInvoke(new AsyncCallback(WorkflowCompletedCallback), userState);

    // You can inspect result from the host to determine if the workflow
    // is complete.
    Console.WriteLine("result.IsCompleted: {0}", result.IsCompleted);

    // The results of the workflow are retrieved by calling EndInvoke, which
    // can be called from the callback or from the host. If called from the
    // host, it blocks until the workflow completes. If a callback is not
    // required, pass null for the callback parameter.
    Console.WriteLine("Waiting for the workflow to complete.");
    IDictionary<string, object> outputs = invoker.EndInvoke(result);

    Console.WriteLine("The two dice are {0} and {1}.",
        outputs["D1"], outputs["D2"]);
}

static void WorkflowCompletedCallback(IAsyncResult result)
{
    Console.WriteLine("Workflow complete.");
}

Remarques

Pour être informé quand le flux de travail est terminé et extraire les paramètres de sortie du flux de travail, appelez la méthode EndInvoke à partir de la méthode callback spécifiée par BeginInvoke. Si la méthode EndInvoke est appelée avant que le flux de travail ne soit terminé, elle s'interrompt jusqu'à la fin du flux de travail.

Cette méthode retourne le résultat d'un flux de travail appelé de façon asynchrone à l'aide du modèle de conception asynchrone IAsyncResult. Pour plus d’informations, consultez Vue d’ensemble de la programmation asynchrone.

S’applique à

Partager via