AsyncOperation<T> Classe

Pacchetto:

com.microsoft.connecteddevices

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

Parametri di tipo

T

public class AsyncOperation

Operazione con un risultato futuro di tipo T o di una possibile eccezione. Questa classe è una versione leggermente semplificata della classe api Android livello 24 CompletableFuture

Implementa l'interfaccia standard Future e fornisce anche funzionalità di continuazione di base. Per informazioni dettagliate su come usare questa classe, vedere CompletableFuture.

Le differenze importanti tra CompletableFuture e AsyncOperation sono le seguenti: 1. L'executor asincrono predefinito di AsyncOperation è Executors.newCachedThreadPool() mentre CompletableFuture usa ForkJoinPool.commonPool(). 2. AsyncOperation non dispone di metodi obtrudeException e obtrudeValue.

Riepilogo dei costruttori

Costruttore	Descrizione
AsyncOperation()	Crea una nuova AsyncOperation

Riepilogo dei metodi

Modificatore e tipo	Metodo e descrizione
<U> AsyncOperation<U>	_handleAsyncInternal(AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, Executor executor) Il trio di handle di funzioni (handle(action), handleAsync(action) e handleAsync(action,Executor)) sono le funzioni di continuazione più di base su cui vengono compilate le altre. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti.
AsyncOperation<T>	_whenCompleteAsyncInternal(AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, Executor executor) Il trio whenComplete di funzioni (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) è simile alle funzioni handle. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti. A differenza di handle, i risultati dell'azione non si propagano alle operazioni dipendenti; osservano l'eccezione o il risultato di questa fase anziché l'azione passata
AsyncOperation<Void>	acceptEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) Il trio acceptEither di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) Il trio acceptEither di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, AsyncOperation.ResultConsumer<? super T> action, @NonNull Executor executor) Il trio acceptEither di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	allOf(@NonNull AsyncOperation<?>... operations) Crea un'operazione che verrà completata al termine di tutte le operazioni passate.
AsyncOperation<Object>	anyOf(@NonNull AsyncOperation<?>... operations) Crea un'operazione che verrà completata al termine di una delle operazioni passate.
<U> AsyncOperation<U>	applyToEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) Il trio applyToEither di funzioni esegue un oggetto passato in ResultFunction quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U> AsyncOperation<U>	applyToEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) Il trio applyToEither di funzioni esegue un oggetto passato in ResultFunction quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U> AsyncOperation<U>	applyToEitherAsync(@NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action, @NonNull Executor executor) Il trio applyToEither di funzioni esegue un oggetto passato in ResultFunction quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
boolean	cancel(boolean mayInterruptIfRunning) Tenta di annullare il futuro e interrompere l'attesa di un risultato. L'annullamento di un oggetto AsyncOperation fa sì che tutti i thread in attesa del futuro tramite get() ricevano immediatamente un'eccezione CancellationException. L'esecuzione dell'operazione non viene interrotta, ma qualsiasi risultato finale da una chiamata annullata verrà ignorato.
final void	complete(T value) Completa questa operazione con un valore specificato.
static<U> AsyncOperation<U>	completedFuture(U value) Crea un'operazione già completata con il valore specificato
final void	completeExceptionally(@NonNull Throwable ex) Imposta l'eccezione che verrà generata quando viene recuperato il valore futuro e contrassegna il futuro.
AsyncOperation<T>	exceptionally(@NonNull AsyncOperation.ResultFunction<Throwable, ? extends T> action) Consente di collegare le continuazioni che vengono eseguite solo nel caso di un completamento eccezionale di questa operazione. Si noti che non esistono varianti *asincrone* di eccezionale, pertanto l'azione non deve essere a lungo in quanto potrebbe bloccare il thread che ha completato questa operazione o il thread chiamante ( nel caso di un'operazione già completata).
T	get() Ottiene il valore futuro, in attesa, se necessario, fino al completamento del futuro.
T	get(long timeout, @NonNull TimeUnit unit) Tenta di ottenere il valore futuro, in attesa, se necessario, fino a quando il futuro non viene eseguito o fino a un timeout.
final T	getNow(T valueIfAbsent) Ottiene il valore dell'operazione che restituisce immediatamente un valore passato se l'operazione non è ancora stata completata.
int	getNumberOfDependents() Ottiene un numero stimato di operazioni che dipendono da questa operazione. Questo non è progettato per essere usato a scopo di sincronizzazione/pianificazione.
<U> AsyncOperation<U>	handle(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) Il trio di handle di funzioni (handle(action), handleAsync(action) e handleAsync(action,Executor)) sono le funzioni di continuazione più di base su cui vengono compilate le altre. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti.
<U> AsyncOperation<U>	handleAsync(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) Il trio di handle di funzioni (handle(action), handleAsync(action) e handleAsync(action,Executor)) sono le funzioni di continuazione più di base su cui vengono compilate le altre. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti.
<U> AsyncOperation<U>	handleAsync( @NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, @NonNull Executor executor) Il trio di handle di funzioni (handle(action), handleAsync(action) e handleAsync(action,Executor)) sono le funzioni di continuazione più di base su cui vengono compilate le altre. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti.
boolean	isCancelled() Controlla se il futuro è stato annullato correttamente.
boolean	isCompletedExceptionally() Controlla se l'operazione è stata completata in modo eccezionale (annullamento o completeExceptionally)
boolean	isDone() Controlla se il futuro viene eseguito. Il futuro viene eseguito quando il risultato viene impostato o viene impostata un'eccezione.
T	join() Ottiene il valore futuro, in attesa, se necessario, fino al completamento del futuro. A differenza di get() join genera un'eccezione CompletionException se si è verificata un'eccezione durante il processo di completamento di questa operazione
AsyncOperation<Void>	runAfterBoth(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Il trio runAfterBoth delle funzioni esegue un oggetto passato in Runnable quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Il trio runAfterBoth delle funzioni esegue un oggetto passato in Runnable quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) Il trio runAfterBoth delle funzioni esegue un oggetto passato in Runnable quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	runAfterEither(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Il trio runAfterEither di funzioni esegue un oggetto passato in Runnable quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	runAfterEitherAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Il trio runAfterEither di funzioni esegue un oggetto passato in Runnable quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	runAfterEitherAsync( @NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) Il trio runAfterEither di funzioni esegue un oggetto passato in Runnable quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable) Crea un'operazione che eseguirà l'oggetto passato in Runnable nell'executor predefinito
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable, @NonNull Executor executor) Crea un'operazione che eseguirà l'oggetto passato in Runnable nell'executor passato
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier) Crea un'operazione che userà l'executor predefinito per ottenere un valore dal fornitore
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier, @NonNull Executor executor) Crea un'operazione che userà l'executor passato per ottenere un valore dal fornitore
AsyncOperation<Void>	thenAccept(@NonNull ResultConsumer<? super T> action) Il trio thenAccept di funzioni (thenAccept(action), quindiAcceptAsync(action) e quindiAcceptAsync(action,Executor)) esegue un passato in ResultConsumer al termine dell'operazione.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action) Il trio thenAccept di funzioni (thenAccept(action), quindiAcceptAsync(action) e quindiAcceptAsync(action,Executor)) esegue un passato in ResultConsumer al termine dell'operazione.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action, @NonNull Executor executor) Il trio thenAccept di funzioni (thenAccept(action), quindiAcceptAsync(action) e quindiAcceptAsync(action,Executor)) esegue un passato in ResultConsumer al termine dell'operazione.
<U> AsyncOperation<Void>	thenAcceptBoth( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) Il trio thenAcceptBoth di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U> AsyncOperation<Void>	thenAcceptBothAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) Il trio thenAcceptBoth di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U> AsyncOperation<Void>	thenAcceptBothAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action, @NonNull Executor executor) Il trio thenAcceptBoth di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U> AsyncOperation<U>	thenApply(@NonNull ResultFunction<? super T, ? extends U> action) Il trio thenApply di funzioni (thenApplyAsync(action), quindiApplyAsync(action) e quindiApplyAsync(action,Executor)) esegue un elemento passato in ResultFunction al termine dell'operazione.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action) Il trio thenApply di funzioni (thenApplyAsync(action), quindiApplyAsync(action) e quindiApplyAsync(action,Executor)) esegue un elemento passato in ResultFunction al termine dell'operazione.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action, @NonNull Executor executor) Il trio thenApply di funzioni (thenApplyAsync(action), quindiApplyAsync(action) e quindiApplyAsync(action,Executor)) esegue un elemento passato in ResultFunction al termine dell'operazione.
<U, V> AsyncOperation<V>	thenCombine( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) Il trio thenCombine di funzioni esegue un oggetto passato in ResultFunction quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U, V> AsyncOperation<V>	thenCombineAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) Il trio thenCombine di funzioni esegue un oggetto passato in ResultFunction quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U, V> AsyncOperation<V>	thenCombineAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action, @NonNull Executor executor) Il trio thenCombine di funzioni esegue un oggetto passato in ResultFunction quando questa operazione e l'operazione passata viene completata correttamente. Se una delle due operazioni viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.
<U> AsyncOperation<U>	thenCompose(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) Il trio di funzioni thenCompose esegue un valore passato in ResultFunction al termine dell'operazione. ResultFunction restituisce un< AsyncOperation>T e l'operazione restituita da questa chiamata restituisce un< AsyncOperation>T anziché AsyncOperation<AsyncOperation<T>>
<U> AsyncOperation<U>	thenComposeAsync(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) Il trio di funzioni thenCompose esegue un valore passato in ResultFunction al termine dell'operazione. ResultFunction restituisce un< AsyncOperation>T e l'operazione restituita da questa chiamata restituisce un< AsyncOperation>T anziché AsyncOperation<AsyncOperation<T>>
<U> AsyncOperation<U>	thenComposeAsync(AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action, Executor executor) Il trio di funzioni thenCompose esegue un valore passato in ResultFunction al termine dell'operazione. ResultFunction restituisce un< AsyncOperation>T e l'operazione restituita da questa chiamata restituisce un< AsyncOperation>T anziché AsyncOperation<AsyncOperation<T>>
AsyncOperation<Void>	thenRun(@NonNull Runnable action) Il trio di funzioni thenRun (thenRun(action), thenRunAsync(action) e quindiRunAsync(action,Executor)) esegue un passato in Runnable al termine dell'operazione.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action) Il trio di funzioni thenRun (thenRun(action), thenRunAsync(action) e quindiRunAsync(action,Executor)) esegue un passato in Runnable al termine dell'operazione.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action, @NonNull Executor executor) Il trio di funzioni thenRun (thenRun(action), thenRunAsync(action) e quindiRunAsync(action,Executor)) esegue un passato in Runnable al termine dell'operazione.
AsyncOperation<T>	whenComplete(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) Il trio whenComplete di funzioni (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) è simile alle funzioni handle. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti. A differenza di handle, i risultati dell'azione non si propagano alle operazioni dipendenti; osservano l'eccezione o il risultato di questa fase anziché l'azione passata
AsyncOperation<T>	whenCompleteAsync(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) Il trio whenComplete di funzioni (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) è simile alle funzioni handle. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti. A differenza di handle, i risultati dell'azione non si propagano alle operazioni dipendenti; osservano l'eccezione o il risultato di questa fase anziché l'azione passata
AsyncOperation<T>	whenCompleteAsync( @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, @NonNull Executor executor) Il trio whenComplete di funzioni (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) è simile alle funzioni handle. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti. A differenza di handle, i risultati dell'azione non si propagano alle operazioni dipendenti; osservano l'eccezione o il risultato di questa fase anziché l'azione passata

Dettagli costruttore

AsyncOperation

public AsyncOperation()

Crea una nuova AsyncOperation

Dettagli metodo

_handleAsyncInternal

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

Il trio di handle di funzioni (handle(action), handleAsync(action) e handleAsync(action,Executor)) sono le funzioni di continuazione più di base su cui vengono compilate le altre. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti.

Parametri:

action - Funzione che verrà eseguita al completamento di questa operazione

executor - Executor con cui eseguire la funzione

Restituisce:

Nuova operazione asincrona che verrà completata in base al risultato del passaggio dell'azione

_whenCompleteAsyncInternal

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

Il trio whenComplete di funzioni (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) è simile alle funzioni handle. Al completamento positivo o eccezionale di questa operazione, l'azione passata verrà eseguita consentendo di osservare sia i risultati precedenti che le eccezioni precedenti. A differenza di handle, i risultati dell'azione non si propagano alle operazioni dipendenti; osservano l'eccezione o il risultato di questa fase anziché l'azione passata

Parametri:

action - Funzione che verrà eseguita al completamento di questa operazione

executor - Executor con cui eseguire la funzione

Restituisce:

Nuova operazione asincrona che verrà completata in base al risultato del passaggio dell'azione

acceptEither

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

Il trio acceptEither di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.

Parametri:

other - l'altra operazione per "OR" insieme

action - ResultConsumer che verrà eseguito al completamento di una delle due operazioni

Restituisce:

Nuova operazione asincrona che verrà completata in base al risultato del passaggio dell'azione

acceptEitherAsync

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

Il trio acceptEither di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.

Parametri:

other - l'altra operazione per "OR" insieme

action - ResultConsumer che verrà eseguito al completamento di una delle due operazioni

Restituisce:

Nuova operazione asincrona che verrà completata in base al risultato del passaggio dell'azione

acceptEitherAsync

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

Il trio acceptEither di funzioni esegue un oggetto passato in ResultConsumer quando questa operazione o l'operazione passata viene completata correttamente. Se l'operazione che viene completata in modo eccezionale, l'operazione restituita viene completata in modo eccezionale.

Parametri:

other - l'altra operazione per "OR" insieme

action - ResultConsumer che verrà eseguito al completamento di una delle due operazioni

executor - Executor con cui eseguire la funzione

Restituisce:

Nuova operazione asincrona che verrà completata in base al risultato del passaggio dell'azione

allOf

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

Crea un'operazione che verrà completata al termine di tutte le operazioni passate.

Parametri:

operations - elenco di operazioni per "AND" insieme

Restituisce:

Nuova operazione asincrona che verrà completata al termine di tutte le operazioni

anyOf

public static AsyncOperation