AsyncTask Classe

Riferimento

Definizione

Spazio dei nomi:: Android.OS

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente.

[Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })]
public abstract class AsyncTask : Java.Lang.Object

[<Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })>]
type AsyncTask = class
    inherit Object

Ereditarietà: Object

Object
AsyncTask

Derivato: Android.OS.AsyncTask<TParams,TProgress,TResult>

Attributi: RegisterAttribute JavaTypeParametersAttribute

Commenti

AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. Tuttavia, il caso d'uso più comune era per l'integrazione nell'interfaccia utente e ciò causava perdite di contesto, callback mancanti o arresti anomali delle modifiche alla configurazione. Ha anche un comportamento incoerente nelle diverse versioni della piattaforma, ingoia le eccezioni da doInBackgrounde non fornisce molta utilità rispetto all'uso Executordiretto di s.

AsyncTask è progettato per essere una classe helper e ThreadHandler non costituisce un framework di threading generico. AsyncTasks dovrebbe essere usato idealmente per operazioni brevi (alcuni secondi al massimo). Se è necessario mantenere i thread in esecuzione per lunghi periodi di tempo, è consigliabile usare le varie API fornite dal java.util.concurrent pacchetto, ad Executoresempio , ThreadPoolExecutor e FutureTask.

Un'attività asincrona viene definita da un calcolo eseguito su un thread in background e il cui risultato viene pubblicato nel thread dell'interfaccia utente. Un'attività asincrona è definita da 3 tipi generici, denominati , Progress e e 4 passaggi, denominati ParamsonPreExecute, onProgressUpdatedoInBackgrounde .onPostExecuteResult

<div class="special reference"><h3>Developer Guides</h3>

Per altre informazioni sull'uso di attività e thread, vedere la Guida per sviluppatori processi e thread .

</Div>

<h2>Usage</h2>

AsyncTask deve essere sottoclassato da usare. La sottoclasse eseguirà l'override di almeno un metodo (#doInBackground) e spesso eseguirà l'override di un secondo (#onPostExecute.)

Ecco un esempio di sottoclasse:

private class DownloadFilesTask extends AsyncTask&lt;URL, Integer, Long&gt; {
                protected Long doInBackground(URL... urls) {
                    int count = urls.length;
                    long totalSize = 0;
                    for (int i = 0; i &lt; count; i++) {
                        totalSize += Downloader.downloadFile(urls[i]);
                        publishProgress((int) ((i / (float) count) * 100));
                        // Escape early if cancel() is called
                        if (isCancelled()) break;
                    }
                    return totalSize;
                }

                protected void onProgressUpdate(Integer... progress) {
                    setProgressPercent(progress[0]);
                }

                protected void onPostExecute(Long result) {
                    showDialog("Downloaded " + result + " bytes");
                }
            }

Una volta creata, un'attività viene eseguita molto semplicemente:

new DownloadFilesTask().execute(url1, url2, url3);

<h2>Tipi generici< di AsyncTask/h2>

I tre tipi usati da un'attività asincrona sono i seguenti:

<ol><li>Params, il tipo dei parametri inviati all'attività al momento dell'esecuzione.</li><,>Progress il tipo delle unità di stato pubblicate durante il calcolo in background.</li>Result<>, il tipo del risultato del calcolo in background.</li></ol>

Non tutti i tipi vengono sempre usati da un'attività asincrona. Per contrassegnare un tipo come inutilizzato, usare semplicemente il tipo Void:

private class MyTask extends AsyncTask&lt;Void, Void, Void&gt; { ... }

<h2>I 4 passaggi</h2>

Quando viene eseguita un'attività asincrona, l'attività passa attraverso 4 passaggi:

<ol><li>#onPreExecute(), richiamato sul thread dell'interfaccia utente prima dell'esecuzione dell'attività. Questo passaggio viene in genere usato per configurare l'attività, ad esempio visualizzando un indicatore di stato nell'interfaccia utente.</li><li>#doInBackground, richiamato sul thread in background immediatamente dopo #onPreExecute() il completamento dell'esecuzione. Questo passaggio viene usato per eseguire il calcolo in background che può richiedere molto tempo. I parametri dell'attività asincrona vengono passati a questo passaggio. Il risultato del calcolo deve essere restituito da questo passaggio e verrà restituito all'ultimo passaggio. Questo passaggio può essere usato #publishProgress anche per pubblicare una o più unità di avanzamento. Questi valori vengono pubblicati nel thread dell'interfaccia #onProgressUpdate utente nel passaggio .</li><,>#onProgressUpdate richiamato sul thread dell'interfaccia utente dopo una chiamata a #publishProgress. L'intervallo dell'esecuzione non è definito. Questo metodo viene usato per visualizzare qualsiasi forma di avanzamento nell'interfaccia utente mentre il calcolo in background è ancora in esecuzione. Ad esempio, può essere usato per animare un indicatore di stato o visualizzare i log in un campo di testo.</li><>#onPostExecute, richiamato sul thread dell'interfaccia utente al termine del calcolo in background. Il risultato del calcolo in background viene passato a questo passaggio come parametro.</li></ol>

<h2>Annullamento di un'attività</h2>

Un'attività può essere annullata in qualsiasi momento richiamando #cancel(boolean). La chiamata di questo metodo causerà la restituzione #isCancelled() di true da parte delle chiamate successive. Dopo aver richiamato questo metodo, #onCancelled(Object), invece di #onPostExecute(Object) verrà richiamato dopo #doInBackground(Object[]) la restituzione. Per assicurarsi che un'attività venga annullata il più rapidamente possibile, è consigliabile controllare sempre il valore restituito di periodicamente da #doInBackground(Object[]), se possibile (all'interno di #isCancelled() un ciclo, ad esempio).

<h2>Regole< di threading/h2>

Per il corretto funzionamento di questa classe, è necessario seguire alcune regole di threading:

<ul><li>La classe AsyncTask deve essere caricata nel thread dell'interfaccia utente. Questa operazione viene eseguita automaticamente a partire da android.os.Build.VERSION_CODES#JELLY_BEAN.</li Li><>L'istanza dell'attività deve essere creata nel thread dell'interfaccia utente.</li deve>#execute<> essere richiamato nel thread dell'interfaccia utente.</li><>Non chiamare #onPreExecute(), , #onPostExecute, #doInBackground#onProgressUpdate manualmente.</li Li><>L'attività può essere eseguita una sola volta (verrà generata un'eccezione se viene tentata una seconda esecuzione).</li></ul>

<h2>Osservabilità< memoria/h2>

AsyncTask garantisce che tutte le chiamate di callback siano sincronizzate per garantire quanto segue senza sincronizzazioni esplicite.

<ul><li>Gli effetti di memoria di #onPreExecutee qualsiasi altra operazione eseguita prima della chiamata a #execute, inclusa la costruzione dell'oggetto AsyncTask, sono visibili a #doInBackground. <li>Gli effetti della memoria di #doInBackground sono visibili a #onPostExecute. <li>Eventuali effetti di memoria di #doInBackground una chiamata a #publishProgress sono visibili alla chiamata corrispondente #onProgressUpdate . (Ma #doInBackground continua a essere eseguito e occorre prestare attenzione che gli aggiornamenti successivi in #doInBackground non interferiscano con una chiamata in corso #onProgressUpdate ). <li>Eventuali effetti di memoria precedenti a una chiamata a #cancel sono visibili dopo una chiamata a #isCancelled che restituisce true come risultato, oppure durante e dopo una chiamata risultante a #onCancelled. </ul>

<h2>Ordine di esecuzione</h2>

Quando è stato introdotto per la prima volta, AsyncTasks è stato eseguito in modo seriale su un singolo thread in background. android.os.Build.VERSION_CODES#DONUTA partire da , questo è stato modificato in un pool di thread che consentono l'esecuzione di più attività in parallelo. android.os.Build.VERSION_CODES#HONEYCOMBA partire da , le attività vengono eseguite in un singolo thread per evitare errori comuni dell'applicazione causati dall'esecuzione parallela.

Se si vuole veramente l'esecuzione parallela, è possibile richiamare #executeOnExecutor(java.util.concurrent.Executor, Object[]) con #THREAD_POOL_EXECUTOR.

Metodo deprecato. Usare invece le utilità di concorrenza standard java.util.concurrent o Kotlin .

Documentazione java per android.os.AsyncTask.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal Android e usato in base ai termini descritti in 2.5 Attribution License Creative Commons 2.5 Attribution License.

Costruttori

AsyncTask()	Crea una nuova attività asincrona.
AsyncTask(IntPtr, JniHandleOwnership)	Costruttore utilizzato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime.

Proprietà

Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
IsCancelled	Restituisce `true` se l'attività è stata annullata prima del completamento normale.
JniIdentityHashCode	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
JniPeerMembers	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente.
PeerReference	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
SerialExecutor	Oggetto `Executor` che esegue le attività una alla volta nell'ordine seriale.
ThreadPoolExecutor	Oggetto `Executor` che può essere utilizzato per eseguire attività in parallelo.
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.

Metodi

Cancel(Boolean)	Tenta di annullare l'esecuzione di questa attività.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
Dispose(Boolean)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
DoInBackground(Object[])	Eseguire l'override di questo metodo per eseguire un calcolo in un thread in background.
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
Execute(IRunnable)	Versione utile di `#execute(Object...)` per l'uso con un semplice oggetto Runnable.
Execute(Object[])	Esegue l'attività con i parametri specificati.
ExecuteOnExecutor(IExecutor, Object[])	Esegue l'attività con i parametri specificati.
Get()	Attende se necessario il completamento del calcolo e quindi recupera il risultato.
Get(Int64, TimeUnit)	Attende se necessario per il completamento del calcolo al massimo il tempo specificato e quindi recupera il risultato.
GetAsync()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente.
GetAsync(Int64, TimeUnit)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente.
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
GetStatus()	Restituisce lo stato corrente dell'attività.
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitoraggio di questo oggetto. (Ereditato da Object)
OnCancelled()	Le applicazioni devono preferibilmente eseguire l'override di `#onCancelled(Object)`.
OnCancelled(Object)	Viene eseguito nel thread dell'interfaccia utente dopo `#cancel(boolean)` essere stato richiamato e `#doInBackground(Object[])` completato.
OnPostExecute(Object)	Viene eseguito nel thread dell'interfaccia utente dopo `#doInBackground`.
OnPreExecute()	Viene eseguito nel thread dell'interfaccia utente prima `#doInBackground`di .
OnProgressUpdate(Object[])	Viene eseguito nel thread dell'interfaccia utente dopo `#publishProgress` essere stato richiamato.
PublishProgress(Object[])	Questo metodo può essere richiamato da `#doInBackground` per pubblicare gli aggiornamenti nel thread dell'interfaccia utente mentre il calcolo in background è ancora in esecuzione.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una>notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere eseguendo <una notifica</>em> o <em>interrotto</em> o fino a quando non è trascorsa una certa quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
IJavaPeerable.Finalized()	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo verificato dal runtime Android.
JavaCast<TResult>(IJavaObject)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente.
GetJniTypeName(IJavaPeerable)	AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente.

Si applica a

Condividi tramite