ICompletionStage Interface

Définition

Espace de noms:: Java.Util.Concurrent

Assembly:: Mono.Android.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.

Étape d’un calcul éventuellement asynchrone, qui effectue une action ou calcule une valeur quand un autre CompletionStage se termine.

[Android.Runtime.Register("java/util/concurrent/CompletionStage", "", "Java.Util.Concurrent.ICompletionStageInvoker", ApiSince=24)]
[Java.Interop.JavaTypeParameters(new System.String[] { "T" })]
public interface ICompletionStage : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/util/concurrent/CompletionStage", "", "Java.Util.Concurrent.ICompletionStageInvoker", ApiSince=24)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "T" })>]
type ICompletionStage = interface
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Dérivé: Java.Util.Concurrent.CompletableFuture

Attributs: RegisterAttribute JavaTypeParametersAttribute

Implémente: IJavaObject IJavaPeerable IDisposable

Remarques

Étape d’un calcul éventuellement asynchrone, qui effectue une action ou calcule une valeur quand un autre CompletionStage se termine. Une étape se termine à l’arrêt de son calcul, mais cela peut à son tour déclencher d’autres étapes dépendantes. La fonctionnalité définie dans cette interface ne prend que quelques formes de base, qui s’étendent à un plus grand ensemble de méthodes pour capturer une plage de styles d’utilisation :

<ul>

<Li>Le calcul effectué par une étape peut être exprimé sous la forme d’une fonction, d’un consommateur ou d’un runnable (en utilisant des méthodes avec des noms incluant apply, accept>, <><respectivement) selon qu’il nécessite des arguments et/ou produit des résultats. Par exemple:

{@code
            stage.thenApply(x -> square(x))
                 .thenAccept(x -> System.out.print(x))
                 .thenRun(() -> System.out.println());}

Un formulaire supplémentaire (compose) permet la construction de pipelines de calcul à partir de fonctions retournant des phases d’achèvement.

Tout argument du calcul d’une étape est le résultat du calcul d’une phase de déclenchement.

<L’exécution de li>One stage peut être déclenchée par l’achèvement d’une seule étape, ou les deux étapes, ou l’une ou l’autre des deux étapes. Les dépendances d’une seule étape sont organisées à l’aide de méthodes avec le préfixe puis. Ceux déclenchés par l’achèvement d’em>>< deux< étapes peuvent> leurs résultats ou effets, à l’aide de méthodes nommées correspondantes. Ceux déclenchés par soit de deux phases ne garantissent pas quels résultats ou effets sont utilisés pour le calcul de l’étape dépendante.

<Les dépendances entre>les étapes contrôlent le déclenchement des calculs, mais ne garantissent pas d’ordre particulier. En outre, l’exécution des calculs d’une nouvelle étape peut être organisée de trois façons : exécution par défaut, exécution asynchrone par défaut (à l’aide de méthodes avec suffixe qui utilisent l’installation d’exécution asynchrone par défaut de l’étape) ou personnalisée (via un fournisseurExecutor>). Les propriétés d’exécution des modes par défaut et asynchrone sont spécifiées par les implémentations CompletionStage, et non par cette interface. Les méthodes avec des arguments Exécuteur explicites peuvent avoir des propriétés d’exécution arbitraires et peuvent ne pas même prendre en charge l’exécution simultanée, mais sont organisées pour le traitement d’une manière qui prend en charge l’asynchronie.

<li>Two method forms (#handle handle and #whenComplete whenComplete) supporte le calcul inconditionnelle si l’étape de déclenchement s’est terminée normalement ou exceptionnellement. La méthode #exceptionally exceptionally prend en charge le calcul uniquement lorsque la phase de déclenchement se termine exceptionnellement, en calculant un résultat de remplacement, de la même façon que le mot clé Java catch . Dans tous les autres cas, si le calcul d’une étape se termine brusquement avec une exception (non cochée) ou une erreur, toutes les étapes dépendantes nécessitant son achèvement se terminent exceptionnellement, avec une CompletionException exception de conservation comme cause. Si une étape dépend des <>deux< phases/em> de deux étapes, et que les deux se terminent exceptionnellement, l’élément CompletionException peut correspondre à l’une de ces exceptions. Si une étape dépend d’em>< soit de deux autres, et qu’une seule d’entre elles se termine exceptionnellement, aucune garantie n’est faite quant à savoir si l’étape dépendante se termine normalement ou exceptionnellement. Dans le cas de la méthode whenComplete, lorsque l’action fournie elle-même rencontre une exception, l’étape se termine exceptionnellement avec cette exception, sauf si l’étape source s’est également terminée exceptionnellement, auquel cas l’achèvement exceptionnel de l’étape source est donné une préférence et propagé à l’étape dépendante.

</ul>

Toutes les méthodes adhèrent au déclencheur, à l’exécution et aux spécifications d’achèvement exceptionnelles ci-dessus (qui ne sont pas répétées dans les spécifications de méthode individuelles). En outre, tandis que les arguments utilisés pour passer un résultat d’achèvement (autrement dit, pour les paramètres de type T) pour les méthodes qui les acceptent peuvent être null, le passage d’une valeur Null pour tout autre paramètre entraîne une NullPointerException levée.

La forme #handle handle de méthode est le moyen le plus général de créer une phase de continuation, d’effectuer inconditionnellement un calcul qui reçoit à la fois le résultat et l’exception (le cas échéant) du déclenchement de CompletionStage et l’informatique d’un résultat arbitraire. La méthode #whenComplete whenComplete est similaire, mais conserve le résultat de l’étape de déclenchement au lieu de calculer un nouveau. Étant donné que le résultat normal d’une étape peut être null, les deux méthodes doivent avoir un calcul structuré ainsi :

{@code (result, exception) -> {
              if (exception == null) {
                // triggering stage completed normally
              } else {
                // triggering stage completed exceptionally
              }
            }}

Cette interface ne définit pas les méthodes de création initiale, de fin forcée normale ou exceptionnelle, de détection de l’état ou des résultats d’achèvement, ou d’attente de l’achèvement d’une phase. Les implémentations de CompletionStage peuvent fournir des moyens d’obtenir ces effets, le cas échéant. La méthode #toCompletableFuture permet l’interopérabilité entre différentes implémentations de cette interface en fournissant un type de conversion commun.

Ajouté dans la version 1.8.

Java documentation pour java.util.concurrent.CompletionStage.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.

Propriétés

Nom	Description
Handle	Obtient la valeur JNI de l’objet Android sous-jacent. (Hérité de IJavaObject)
JniIdentityHashCode	Retourne la valeur de `java.lang.System.identityHashCode()` l’instance encapsulée. (Hérité de IJavaPeerable)
JniManagedPeerState	État de l’homologue managé. (Hérité de IJavaPeerable)
JniObjectReferenceControlBlock	Étape d’un calcul éventuellement asynchrone, qui effectue une action ou calcule une valeur quand un autre CompletionStage se termine. (Hérité de IJavaPeerable)
JniPeerMembers	Prise en charge de l’accès aux membres et de l’appel. (Hérité de IJavaPeerable)
PeerReference	Retourne une JniObjectReference instance d’objet Java encapsulée. (Hérité de IJavaPeerable)

Méthodes

Nom	Description
AcceptEither(ICompletionStage, IConsumer)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, est exécutée avec le résultat correspondant en tant qu’argument de l’action fournie.
AcceptEitherAsync(ICompletionStage, IConsumer, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, est exécutée à l’aide de l’exécuteur fourni, avec le résultat correspondant en tant qu’argument de l’action fournie.
AcceptEitherAsync(ICompletionStage, IConsumer)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, est exécutée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape, avec le résultat correspondant sous forme d’argument à l’action fournie.
ApplyToEither(ICompletionStage, IFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, est exécutée avec le résultat correspondant en tant qu’argument de la fonction fournie.
ApplyToEitherAsync(ICompletionStage, IFunction, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, est exécutée à l’aide de l’exécuteur fourni, avec le résultat correspondant en tant qu’argument de la fonction fournie.
ApplyToEitherAsync(ICompletionStage, IFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, est exécutée à l’aide de l’installation d’exécution asynchrone par défaut de cette étape, avec le résultat correspondant en tant qu’argument de la fonction fournie.
Disposed()	Appelé lorsque l’instance a été supprimée. (Hérité de IJavaPeerable)
DisposeUnlessReferenced()	S’il n’existe aucune référence en suspens à cette instance, les appels `Dispose()`; sinon, ne fait rien. (Hérité de IJavaPeerable)
Exceptionally(IFunction)	Retourne un nouveau CompletionStage qui, une fois cette étape terminée exceptionnellement, est exécutée avec l’exception de cette étape comme argument de la fonction fournie.
ExceptionallyAsync(IFunction, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine exceptionnellement, est exécutée avec l’exception de cette étape en tant qu’argument de la fonction fournie, à l’aide de l’exécuteur fourni.
ExceptionallyAsync(IFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine exceptionnellement, est exécutée avec l’exception de cette étape en tant qu’argument de la fonction fournie, à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape.
ExceptionallyCompose(IFunction)	Retourne un nouveau CompletionStage qui, une fois cette étape terminée exceptionnellement, est composée à l’aide des résultats de la fonction fournie appliquée à l’exception de cette étape.
ExceptionallyComposeAsync(IFunction, IExecutor)	Retourne un nouveau CompletionStage qui, une fois cette étape terminée exceptionnellement, est composée à l’aide des résultats de la fonction fournie appliquée à l’exception de cette étape, à l’aide de l’exécuteur fourni.
ExceptionallyComposeAsync(IFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine exceptionnellement, est composée à l’aide des résultats de la fonction fournie appliquée à l’exception de cette étape, à l’aide de l’installation d’exécution asynchrone par défaut de cette étape.
Finalized()	Appelé lorsque l’instance a été finalisée. (Hérité de IJavaPeerable)
Handle(IBiFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement ou exceptionnellement, est exécutée avec le résultat et l’exception de cette étape en tant qu’arguments de la fonction fournie.
HandleAsync(IBiFunction, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement ou exceptionnellement, est exécutée à l’aide de l’exécuteur fourni, avec le résultat et l’exception de cette étape en tant qu’arguments de la fonction fournie.
HandleAsync(IBiFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement ou exceptionnellement, est exécutée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape, avec le résultat et l’exception de cette étape en tant qu’arguments de la fonction fournie.
RunAfterBoth(ICompletionStage, IRunnable)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, exécute l’action donnée.
RunAfterBothAsync(ICompletionStage, IRunnable, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, exécute l’action donnée à l’aide de l’exécuteur fourni.
RunAfterBothAsync(ICompletionStage, IRunnable)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, exécute l’action donnée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape.
RunAfterEither(ICompletionStage, IRunnable)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, exécute l’action donnée.
RunAfterEitherAsync(ICompletionStage, IRunnable, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, exécute l’action donnée à l’aide de l’exécuteur fourni.
RunAfterEitherAsync(ICompletionStage, IRunnable)	Retourne un nouveau CompletionStage qui, lorsque cette étape ou l’autre étape donnée se termine normalement, exécute l’action donnée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape.
SetJniIdentityHashCode(Int32)	Définissez la valeur retournée par `JniIdentityHashCode`. (Hérité de IJavaPeerable)
SetJniManagedPeerState(JniManagedPeerStates)	Étape d’un calcul éventuellement asynchrone, qui effectue une action ou calcule une valeur quand un autre CompletionStage se termine. (Hérité de IJavaPeerable)
SetPeerReference(JniObjectReference)	Définissez la valeur retournée par `PeerReference`. (Hérité de IJavaPeerable)
ThenAccept(IConsumer)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, est exécutée avec le résultat de cette étape en tant qu’argument de l’action fournie.
ThenAcceptAsync(IConsumer, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, est exécutée à l’aide de l’exécuteur fourni, avec le résultat de cette étape comme argument de l’action fournie.
ThenAcceptAsync(IConsumer)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, est exécutée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape, avec le résultat de cette étape comme argument de l’action fournie.
ThenAcceptBoth(ICompletionStage, IBiConsumer)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, sont exécutées avec les deux résultats sous forme d’arguments pour l’action fournie.
ThenAcceptBothAsync(ICompletionStage, IBiConsumer, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, sont exécutées à l’aide de l’exécuteur fourni, avec les deux résultats sous forme d’arguments de l’action fournie.
ThenAcceptBothAsync(ICompletionStage, IBiConsumer)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, est exécutée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape, avec les deux résultats sous forme d’arguments de l’action fournie.
ThenApply(IFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, est exécutée avec le résultat de cette étape en tant qu’argument de la fonction fournie.
ThenApplyAsync(IFunction, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, est exécutée à l’aide de l’exécuteur fourni, avec le résultat de cette étape comme argument de la fonction fournie.
ThenApplyAsync(IFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, est exécutée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape, avec le résultat de cette étape comme argument de la fonction fournie.
ThenCombine(ICompletionStage, IBiFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, sont exécutées avec les deux résultats sous forme d’arguments pour la fonction fournie.
ThenCombineAsync(ICompletionStage, IBiFunction, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, sont exécutées à l’aide de l’exécuteur fourni, avec les deux résultats en tant qu’arguments de la fonction fournie.
ThenCombineAsync(ICompletionStage, IBiFunction)	Retourne un nouveau CompletionStage qui, lorsque cette étape et l’autre étape donnée se terminent normalement, sont exécutées à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape, avec les deux résultats sous forme d’arguments de la fonction fournie.
ThenCompose(IFunction)	Retourne un nouveau CompletionStage qui est terminé avec la même valeur que la fonction CompletedStage retournée par la fonction donnée.
ThenComposeAsync(IFunction, IExecutor)	Retourne un nouveau CompletionStage qui est terminé avec la même valeur que le CompletionStage retourné par la fonction donnée, exécuté à l’aide de l’exécuteur fourni.
ThenComposeAsync(IFunction)	Retourne un nouveau CompletionStage qui est terminé avec la même valeur que la fonction CompletedStage retournée par la fonction donnée, exécutée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape.
ThenRun(IRunnable)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, exécute l’action donnée.
ThenRunAsync(IRunnable, IExecutor)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, exécute l’action donnée à l’aide de l’exécuteur fourni.
ThenRunAsync(IRunnable)	Retourne un nouveau CompletionStage qui, lorsque cette étape se termine normalement, exécute l’action donnée à l’aide de la fonctionnalité d’exécution asynchrone par défaut de cette étape.
ToCompletableFuture()	Retourne une `CompletableFuture` maintenance des mêmes propriétés d’achèvement que cette étape.
UnregisterFromRuntime()	Annulez l’inscription de cette instance afin que le runtime ne le retourne pas à partir d’appels futurs Java.Interop.JniRuntime+JniValueManager.PeekValue . (Hérité de IJavaPeerable)
WhenComplete(IBiConsumer)	Retourne un nouveau CompletionStage avec le même résultat ou exception que cette étape, qui exécute l’action donnée une fois cette étape terminée.
WhenCompleteAsync(IBiConsumer, IExecutor)	Retourne un nouveau CompletionStage avec le même résultat ou exception que cette étape, qui exécute l’action donnée à l’aide de l’exécuteur fourni une fois cette étape terminée.
WhenCompleteAsync(IBiConsumer)	Retourne un nouveau CompletionStage avec le même résultat ou exception que cette étape, qui exécute l’action donnée à l’aide de l’installation d’exécution asynchrone par défaut de cette étape lorsque cette étape se termine.

Méthodes d’extension

Nom	Description
GetJniTypeName(IJavaPeerable)	Obtient le nom JNI du type de l’instance `self`.
JavaAs<TResult>(IJavaPeerable)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.
JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Étape d’un calcul éventuellement asynchrone, qui effectue une action ou calcule une valeur quand un autre CompletionStage se termine.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Essayez de forcer `self` le type`TResult`, en vérifiant que le forçage est valide côté Java.

S’applique à