AsyncOperation<T> Classe

Paquet:

com.microsoft.connecteddevices

• java.lang.Object
• • java.util.concurrent.Future<T>
  • • com.microsoft.connecteddevices.AsyncOperation<T>

Paramètres de type

T

public class AsyncOperation

Opération qui a un résultat futur de type T ou d’une exception possible. Cette classe est une version légèrement simplifiée de la classe Api Android 24 CompletableFuture

Implémente l’interface standard Future et fournit également des fonctionnalités de continuation de base. Pour plus d’informations sur l’utilisation de cette classe, consultez CompletableFuture.

Les différences importantes entre CompletableFuture et AsyncOperation sont les suivantes : 1. L’exécuteur asynchrone par défaut d’AsyncOperation est Executors.newCachedThreadPool() tandis que CompletableFuture utilise ForkJoinPool.commonPool(). 2. AsyncOperation manque de méthodes obtrudeException et obtrudeValue.

Récapitulatif du constructeur

Constructeur	Description
AsyncOperation()	Crée un AsyncOperation

Résumé de la méthode

Modificateur et type	Méthode et description
<U> AsyncOperation<U>	_handleAsyncInternal(AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, Executor executor) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Executor)) sont les fonctions de continuation les plus élémentaires sur lesquelles les autres sont générées. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
AsyncOperation<T>	_whenCompleteAsyncInternal(AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, Executor executor) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) sont similaires aux fonctions de handle. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement au handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/ le résultat de cette étape au lieu du passage en action
AsyncOperation<Void>	acceptEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) Le trio acceptEither de fonctions exécute un résultat passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) Le trio acceptEither de fonctions exécute un résultat passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, AsyncOperation.ResultConsumer<? super T> action, @NonNull Executor executor) Le trio acceptEither de fonctions exécute un résultat passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	allOf(@NonNull AsyncOperation<?>... operations) Crée une opération qui se termine lorsque toutes les opérations passées sont terminées.
AsyncOperation<Object>	anyOf(@NonNull AsyncOperation<?>... operations) Crée une opération qui se termine une fois l’une des opérations passées terminées.
<U> AsyncOperation<U>	applyToEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) Le trio applyToEither de fonctions exécute un résultat passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	applyToEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) Le trio applyToEither de fonctions exécute un résultat passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	applyToEitherAsync(@NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action, @NonNull Executor executor) Le trio applyToEither de fonctions exécute un résultat passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
boolean	cancel(boolean mayInterruptIfRunning) Tente d’annuler l’avenir et d’arrêter d’attendre un résultat. L’annulation d’une opération AsyncOperation entraîne la réception immédiate d’un threads qui attendent l’avenir via get() pour recevoir immédiatement une cancellationException. L’exécution de l’opération n’est pas interrompue, mais tout résultat final d’un appel annulé est ignoré.
final void	complete(T value) Termine cette opération avec une valeur donnée.
static<U> AsyncOperation<U>	completedFuture(U value) Crée une opération déjà terminée avec la valeur donnée
final void	completeExceptionally(@NonNull Throwable ex) Définit l’exception qui sera levée lorsque la valeur future est récupérée et marque l’avenir terminé.
AsyncOperation<T>	exceptionally(@NonNull AsyncOperation.ResultFunction<Throwable, ? extends T> action) Permet aux continuations d’être attachées qui ne s’exécutent qu’en cas d’achèvement exceptionnel de cette opération. Notez qu’il n’existe pas de variantes *async* exceptionnellement, de sorte que l’action ne doit pas être longue car elle peut bloquer le thread qui a terminé cette opération ou le thread appelant (dans le cas d’une opération déjà terminée).
T	get() Obtient la valeur future, en attendant si nécessaire jusqu’à ce que l’avenir soit terminé.
T	get(long timeout, @NonNull TimeUnit unit) Tente d’obtenir la valeur future, en attendant si nécessaire jusqu’à ce que l’avenir soit terminé ou jusqu’à ce qu’un délai d’expiration soit écoulé.
final T	getNow(T valueIfAbsent) Obtient la valeur de l’opération qui retourne immédiatement une valeur passée si l’opération n’est pas encore terminée.
int	getNumberOfDependents() Obtient un nombre estimé d’opérations dépendantes de cette opération. Cela n’est pas destiné à être utilisé à des fins de synchronisation/planification.
<U> AsyncOperation<U>	handle(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Executor)) sont les fonctions de continuation les plus élémentaires sur lesquelles les autres sont générées. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
<U> AsyncOperation<U>	handleAsync(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Executor)) sont les fonctions de continuation les plus élémentaires sur lesquelles les autres sont générées. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
<U> AsyncOperation<U>	handleAsync( @NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, @NonNull Executor executor) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Executor)) sont les fonctions de continuation les plus élémentaires sur lesquelles les autres sont générées. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
boolean	isCancelled() Vérifie si l’avenir a été annulé avec succès.
boolean	isCompletedExceptionally() Vérifie si l’opération s’est terminée de manière exceptionnelle (annulation ou completeExceptionally)
boolean	isDone() Vérifie si l’avenir est terminé. L’avenir est effectué lorsque le résultat est défini ou qu’une exception est définie.
T	join() Obtient la valeur future, en attendant si nécessaire jusqu’à ce que l’avenir soit terminé. Contrairement à get() join lève une exception CompletionException si une exception s’est produite dans le processus de fin de cette opération
AsyncOperation<Void>	runAfterBoth(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio de fonctions runAfterBoth exécute un runnable passé lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio de fonctions runAfterBoth exécute un runnable passé lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) Le trio de fonctions runAfterBoth exécute un runnable passé lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterEither(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio runAfterEither de fonctions exécute un runnable passé lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterEitherAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio runAfterEither de fonctions exécute un runnable passé lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterEitherAsync( @NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) Le trio runAfterEither de fonctions exécute un runnable passé lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable) Crée une opération qui exécutera l’exécution transmise dans Runnable sur l’exécuteur par défaut
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable, @NonNull Executor executor) Crée une opération qui exécutera l’exécution transmise dans Runnable sur l’exécuteur passé
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier) Crée une opération qui utilisera l’exécuteur par défaut pour obtenir une valeur du fournisseur
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier, @NonNull Executor executor) Crée une opération qui utilisera l’exécuteur passé pour obtenir une valeur du fournisseur
AsyncOperation<Void>	thenAccept(@NonNull ResultConsumer<? super T> action) Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécute un résultat passé dans ResultConsumer une fois cette opération terminée avec succès.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action) Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécute un résultat passé dans ResultConsumer une fois cette opération terminée avec succès.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action, @NonNull Executor executor) Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécute un résultat passé dans ResultConsumer une fois cette opération terminée avec succès.
<U> AsyncOperation<Void>	thenAcceptBoth( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) Le trio de fonctions thenAcceptBoth exécute un passage dans ResultConsumer lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<Void>	thenAcceptBothAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) Le trio de fonctions thenAcceptBoth exécute un passage dans ResultConsumer lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<Void>	thenAcceptBothAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action, @NonNull Executor executor) Le trio de fonctions thenAcceptBoth exécute un passage dans ResultConsumer lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	thenApply(@NonNull ResultFunction<? super T, ? extends U> action) Le trio de fonctions thenApply (puisApplyAsync(action), puisApplyAsync(action), puisApplyAsync(action,Executor)) exécute un résultat passé dans ResultFunction lorsque cette opération se termine correctement.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action) Le trio de fonctions thenApply (puisApplyAsync(action), puisApplyAsync(action), puisApplyAsync(action,Executor)) exécute un résultat passé dans ResultFunction lorsque cette opération se termine correctement.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action, @NonNull Executor executor) Le trio de fonctions thenApply (puisApplyAsync(action), puisApplyAsync(action), puisApplyAsync(action,Executor)) exécute un résultat passé dans ResultFunction lorsque cette opération se termine correctement.
<U, V> AsyncOperation<V>	thenCombine( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) Le trio de fonctions thenCombine exécute une opération passée dans ResultFunction lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U, V> AsyncOperation<V>	thenCombineAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) Le trio de fonctions thenCombine exécute une opération passée dans ResultFunction lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U, V> AsyncOperation<V>	thenCombineAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action, @NonNull Executor executor) Le trio de fonctions thenCombine exécute une opération passée dans ResultFunction lorsque cette opération et que l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	thenCompose(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) Le trio de fonctions thenCompose exécute un résultat passé dans ResultFunction une fois cette opération terminée avec succès. ResultFunction retourne un< T AsyncOperation>et l’opération de retour de cet appel retourne un< AsyncOperation>T par opposition à un AsyncOperation<AsyncOperation<T>>
<U> AsyncOperation<U>	thenComposeAsync(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) Le trio de fonctions thenCompose exécute un résultat passé dans ResultFunction une fois cette opération terminée avec succès. ResultFunction retourne un< T AsyncOperation>et l’opération de retour de cet appel retourne un< AsyncOperation>T par opposition à un AsyncOperation<AsyncOperation<T>>
<U> AsyncOperation<U>	thenComposeAsync(AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action, Executor executor) Le trio de fonctions thenCompose exécute un résultat passé dans ResultFunction une fois cette opération terminée avec succès. ResultFunction retourne un< T AsyncOperation>et l’opération de retour de cet appel retourne un< AsyncOperation>T par opposition à un AsyncOperation<AsyncOperation<T>>
AsyncOperation<Void>	thenRun(@NonNull Runnable action) Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action), puisRunAsync(action,Executor)) exécute un runnable passé lorsque cette opération se termine correctement.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action) Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action), puisRunAsync(action,Executor)) exécute un runnable passé lorsque cette opération se termine correctement.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action, @NonNull Executor executor) Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action), puisRunAsync(action,Executor)) exécute un runnable passé lorsque cette opération se termine correctement.
AsyncOperation<T>	whenComplete(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) sont similaires aux fonctions de handle. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement au handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/ le résultat de cette étape au lieu du passage en action
AsyncOperation<T>	whenCompleteAsync(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) sont similaires aux fonctions de handle. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement au handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/ le résultat de cette étape au lieu du passage en action
AsyncOperation<T>	whenCompleteAsync( @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, @NonNull Executor executor) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) sont similaires aux fonctions de handle. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement au handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/ le résultat de cette étape au lieu du passage en action

Détails du constructeur

AsyncOperation

public AsyncOperation()

Crée un AsyncOperation

Détails de la méthode

_handleAsyncInternal

protected AsyncOperation _handleAsyncInternal(AsyncOperation.ResultBiFunction action, Executor executor)

Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Executor)) sont les fonctions de continuation les plus élémentaires sur lesquelles les autres sont générées. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.

Paramètres:

action - Fonction qui sera exécutée à l’achèvement de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Retours:

Nouvelle opération asynchrone qui se termine en fonction du résultat de l’action passée

_whenCompleteAsyncInternal

protected AsyncOperation _whenCompleteAsyncInternal(AsyncOperation.ResultBiConsumer action, Executor executor)

Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) sont similaires aux fonctions de handle. Une fois cette opération réussie ou exceptionnelle, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement au handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/ le résultat de cette étape au lieu du passage en action

Paramètres:

action - Fonction qui sera exécutée à l’achèvement de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Retours:

Nouvelle opération asynchrone qui se termine en fonction du résultat de l’action passée

acceptEither

public AsyncOperation acceptEither( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultConsumer action)

Le trio acceptEither de fonctions exécute un résultat passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Paramètres:

other - l’autre opération sur « OR » ensemble

action - ResultConsumer qui sera exécuté à l’achèvement de l’une ou l’autre opération

Retours:

Nouvelle opération asynchrone qui se termine en fonction du résultat de l’action passée

acceptEitherAsync

public AsyncOperation acceptEitherAsync( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultConsumer action)

Le trio acceptEither de fonctions exécute un résultat passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Paramètres:

other - l’autre opération sur « OR » ensemble

action - ResultConsumer qui sera exécuté à l’achèvement de l’une ou l’autre opération

Retours:

Nouvelle opération asynchrone qui se termine en fonction du résultat de l’action passée

acceptEitherAsync

public AsyncOperation acceptEitherAsync( @NonNull AsyncOperation other, AsyncOperation.ResultConsumer action, @NonNull Executor executor)

Le trio acceptEither de fonctions exécute un résultat passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Paramètres:

other - l’autre opération sur « OR » ensemble

action - ResultConsumer qui sera exécuté à l’achèvement de l’une ou l’autre opération

executor - Exécuteur avec lequel exécuter la fonction

Retours:

Nouvelle opération asynchrone qui se termine en fonction du résultat de l’action passée

allOf

public static AsyncOperation allOf(@NonNull AsyncOperation... operations)

Crée une opération qui se termine lorsque toutes les opérations passées sont terminées.

Paramètres:

operations - liste des opérations sur « AND » ensemble

Retours:

Nouvelle opération asynchrone qui se termine une fois toutes les opérations terminées

anyOf

public static AsyncOperation