AsyncTask Klasse

Referenz

Definition

Namespace:: Android.OS

Assembly:: Mono.Android.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen.

[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

Vererbung: Object

Object
AsyncTask

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

Attribute: RegisterAttribute JavaTypeParametersAttribute

Hinweise

AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. Der häufigste Anwendungsfall war jedoch die Integration in die Benutzeroberfläche, und dies würde zu Kontextverlusten, verpassten Rückrufen oder Abstürze bei Konfigurationsänderungen führen. Es weist auch inkonsistentes Verhalten auf verschiedenen Versionen der Plattform auf, verschluckt Ausnahmen von doInBackgroundund bietet nicht viel Hilfsprogramm gegenüber der direkten Verwendung von Executors.

AsyncTask ist als Hilfsklasse Thread konzipiert und Handler stellt kein generisches Threadingframework dar. AsyncTasks sollte idealerweise für kurze Vorgänge (maximal wenige Sekunden) verwendet werden. Wenn Sie Threads über einen langen Zeitraum ausführen müssen, wird dringend empfohlen, die verschiedenen APIs zu verwenden, die java.util.concurrent vom Paket bereitgestellt werden, z Executor. B. , ThreadPoolExecutor und FutureTask.

Eine asynchrone Aufgabe wird durch eine Berechnung definiert, die in einem Hintergrundthread ausgeführt wird und deren Ergebnis im UI-Thread veröffentlicht wird. Eine asynchrone Aufgabe wird durch 3 generische Typen namens Params, Progress und Resultund 4 Schritte definiert, die , doInBackgroundund onPostExecuteonProgressUpdate genannt onPreExecutewerden.

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

Weitere Informationen zur Verwendung von Aufgaben und Threads finden Sie im Entwicklerhandbuch für Prozesse und Threads .

</Div>

<h2>Nutzung</h2>

AsyncTask muss für die Verwendung unterklassig sein. Die Unterklasse überschreibt mindestens eine Methode (#doInBackground) und am häufigsten eine zweite (#onPostExecute.)

Hier sehen Sie ein Beispiel für Unterklassen:

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");
                }
            }

Nach der Erstellung wird eine Aufgabe ganz einfach ausgeführt:

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

<Generische Typen< von h2>AsyncTask/h2>

Die drei Typen, die von einer asynchronen Aufgabe verwendet werden, sind die folgenden:

<ol><li>Params, der Typ der Parameter, die bei der Ausführung an die Aufgabe gesendet werden.</li><li>Progress, der Typ der Fortschrittseinheiten, die während der Hintergrundberechnung veröffentlicht wurden.</li><li,>Result der Typ des Ergebnisses der Hintergrundberechnung.</li></ol>

Nicht alle Typen werden immer von einer asynchronen Aufgabe verwendet. Um einen Typ als nicht verwendet zu markieren, verwenden Sie einfach den Typ Void:

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

<h2>Die 4 Schritte</h2>

Wenn ein asynchroner Task ausgeführt wird, führt der Task vier Schritte aus:

<ol><li>#onPreExecute(), wird im UI-Thread aufgerufen, bevor die Aufgabe ausgeführt wird. Dieser Schritt wird normalerweise zum Einrichten der Aufgabe verwendet, um instance durch Anzeigen einer Statusleiste in der Benutzeroberfläche.</li><li,>#doInBackground wird unmittelbar nach #onPreExecute() Abschluss der Ausführung im Hintergrundthread aufgerufen. Dieser Schritt wird verwendet, um Hintergrundberechnungen durchzuführen, die lange dauern können. Die Parameter der asynchronen Aufgabe werden an diesen Schritt übergeben. Das Ergebnis der Berechnung muss von diesem Schritt zurückgegeben werden und wird an den letzten Schritt zurückgegeben. Dieser Schritt kann auch zum Veröffentlichen einer oder mehrerer Fortschrittseinheiten verwendet #publishProgress werden. Diese Werte werden im Benutzeroberflächenthread im #onProgressUpdate Schritt veröffentlicht.</li><li>#onProgressUpdate, wird im UI-Thread nach einem Aufruf von #publishProgressaufgerufen. Der Zeitpunkt der Ausführung ist nicht definiert. Diese Methode wird verwendet, um jede Form des Fortschritts auf der Benutzeroberfläche anzuzeigen, während die Hintergrundberechnung noch ausgeführt wird. Für instance kann sie verwendet werden, um eine Statusleiste zu animieren oder Protokolle in einem Textfeld anzuzeigen.</li><li>#onPostExecute, wird nach Abschluss der Hintergrundberechnung im UI-Thread aufgerufen. Das Ergebnis der Hintergrundberechnung wird als Parameter an diesen Schritt übergeben.</li></ol>

<h2>Aufgabe abbrechen</h2>

Eine Aufgabe kann jederzeit abgebrochen werden, indem Sie aufrufen #cancel(boolean). Das Aufrufen dieser Methode führt dazu, dass nachfolgende Aufrufe von #isCancelled() true zurückgeben. Nach dem Aufrufen dieser Methode #onCancelled(Object)wird anstelle von #onPostExecute(Object) nach #doInBackground(Object[]) rückgaben aufgerufen. Um sicherzustellen, dass eine Aufgabe so schnell wie möglich abgebrochen wird, sollten Sie den Rückgabewert von #isCancelled() immer in regelmäßigen Abständen von #doInBackground(Object[])überprüfen(innerhalb einer Schleife für instance).)

<h2>Threadingregeln</h2>

Es gibt einige Threadingregeln, die befolgt werden müssen, damit diese Klasse ordnungsgemäß funktioniert:

<ul><li>Die AsyncTask-Klasse muss in den UI-Thread geladen werden. Dies erfolgt automatisch ab android.os.Build.VERSION_CODES#JELLY_BEAN.</li><li>Die Aufgabe instance muss im UI-Thread erstellt werden.</li><li>#execute muss im UI-Thread aufgerufen werden.</li>li Rufen Sie , #onPostExecute, #doInBackgroundnicht #onProgressUpdate manuell auf#onPreExecute().<></li><li>Der Task kann nur einmal ausgeführt werden (eine Ausnahme wird ausgelöst, wenn eine zweite Ausführung versucht wird.)</li></ul>

<h2>Arbeitsspeicher-Beobachtbarkeit</h2>

AsyncTask garantiert, dass alle Rückrufaufrufe synchronisiert werden, um Folgendes ohne explizite Synchronisierungen sicherzustellen.

<ul><li>Die Speichereffekte von #onPreExecuteund alles andere, das vor dem Aufruf #executevon ausgeführt wurde, einschließlich der Konstruktion des AsyncTask-Objekts, sind für #doInBackgroundsichtbar. <li>Die Speichereffekte von #doInBackground sind für #onPostExecutesichtbar. <li>Alle Speichereffekte vor #doInBackground einem Aufruf von #publishProgress sind für den entsprechenden #onProgressUpdate Aufruf sichtbar. (Wird aber #doInBackground weiterhin ausgeführt, und es muss darauf geachtet werden, dass spätere Updates einen #doInBackground laufenden #onProgressUpdate Aufruf nicht beeinträchtigen.) <li>Alle Speichereffekte, die einem Aufruf #cancel von vorangehen, sind nach einem Aufruf von #isCancelled sichtbar, der als Ergebnis true zurückgibt, oder während und nach einem resultierenden Aufruf von #onCancelled. </ul>

<h2>Ausführungsreihenfolge</h2>

Bei der ersten Einführung wurden AsyncTasks seriell in einem einzelnen Hintergrundthread ausgeführt. android.os.Build.VERSION_CODES#DONUTAb wurde dies in einen Pool von Threads geändert, sodass mehrere Aufgaben parallel ausgeführt werden können. android.os.Build.VERSION_CODES#HONEYCOMBAb werden Aufgaben in einem einzelnen Thread ausgeführt, um häufige Anwendungsfehler zu vermeiden, die durch parallele Ausführung verursacht werden.

Wenn Sie wirklich eine parallele Ausführung wünschen, können Sie mit #THREAD_POOL_EXECUTORaufrufen#executeOnExecutor(java.util.concurrent.Executor, Object[]).

Dieses Member ist veraltet. Verwenden Sie stattdessen die Standard java.util.concurrent - oder Kotlin-Parallelitätshilfsprogramme .

Java-Dokumentation für android.os.AsyncTask.

Teile dieser Seite sind Änderungen, die auf Arbeiten basieren, die vom Android Open Source Project erstellt und freigegeben wurden und gemäß den In der Attribution License beschriebenen Begriffen verwendet werden.

Konstruktoren

AsyncTask()	Erstellt eine neue asynchrone Aufgabe.
AsyncTask(IntPtr, JniHandleOwnership)	Ein Konstruktor, der beim Erstellen verwalteter Darstellungen von JNI-Objekten verwendet wird; wird von der Runtime aufgerufen.

Eigenschaften

Class	Gibt die Laufzeitklasse dieses `Object`zurück. (Geerbt von Object)
Handle	Das Handle zum zugrunde liegenden Android-instance. (Geerbt von Object)
IsCancelled	Gibt zurück `true` , wenn diese Aufgabe abgebrochen wurde, bevor sie normal abgeschlossen wurde.
JniIdentityHashCode	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
JniPeerMembers	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen.
PeerReference	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
SerialExecutor	Ein `Executor` , der Aufgaben einzeln in serieller Reihenfolge ausführt.
ThreadPoolExecutor	Ein `Executor` , mit dem Aufgaben parallel ausgeführt werden können.
ThresholdClass	Diese API unterstützt die Mono für Android-Infrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code vorgesehen.
ThresholdType	Diese API unterstützt die Mono für Android-Infrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code vorgesehen.

Methoden

Cancel(Boolean)	Versucht, die Ausführung dieser Aufgabe abzubrechen.
Clone()	Erstellt und gibt eine Kopie dieses Objekts zurück. (Geerbt von Object)
Dispose()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
Dispose(Boolean)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
DoInBackground(Object[])	Überschreiben Sie diese Methode, um eine Berechnung für einen Hintergrundthread durchzuführen.
Equals(Object)	Gibt an, ob ein anderes Objekt diesem "gleich" ist. (Geerbt von Object)
Execute(IRunnable)	Komfortversion von `#execute(Object...)` für die Verwendung mit einem einfachen Runnable-Objekt.
Execute(Object[])	Führt den Task mit den angegebenen Parametern aus.
ExecuteOnExecutor(IExecutor, Object[])	Führt den Task mit den angegebenen Parametern aus.
Get()	Wartet bei Bedarf, bis die Berechnung abgeschlossen ist, und ruft dann das Ergebnis ab.
Get(Int64, TimeUnit)	Wartet bei Bedarf bis maximal die angegebene Zeit, bis die Berechnung abgeschlossen ist, und ruft dann das Ergebnis ab.
GetAsync()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen.
GetAsync(Int64, TimeUnit)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen.
GetHashCode()	Gibt einen Hashcodewert für das Objekt zurück. (Geerbt von Object)
GetStatus()	Gibt den aktuellen status dieser Aufgabe zurück.
JavaFinalize()	Wird vom Garbage Collector für ein Objekt aufgerufen, wenn die Garbage Collection feststellt, dass keine Verweise mehr auf das Objekt vorhanden sind. (Geerbt von Object)
Notify()	Aktiviert einen einzelnen Thread, der auf dem Monitor dieses Objekts wartet. (Geerbt von Object)
NotifyAll()	Aktiviert alle Threads, die auf dem Monitor dieses Objekts warten. (Geerbt von Object)
OnCancelled()	Anwendungen sollten vorzugsweise überschreiben `#onCancelled(Object)`.
OnCancelled(Object)	Wird auf dem UI-Thread ausgeführt, nachdem `#cancel(boolean)` aufgerufen wurde und `#doInBackground(Object[])` abgeschlossen wurde.
OnPostExecute(Object)	Wird im UI-Thread nach `#doInBackground`ausgeführt.
OnPreExecute()	Wird im UI-Thread vor `#doInBackground`ausgeführt.
OnProgressUpdate(Object[])	Wird im UI-Thread ausgeführt, nachdem `#publishProgress` aufgerufen wurde.
PublishProgress(Object[])	Diese Methode kann aufgerufen `#doInBackground` werden, um Updates im UI-Thread zu veröffentlichen, während die Hintergrundberechnung noch ausgeführt wird.
SetHandle(IntPtr, JniHandleOwnership)	Legt die Handle-Eigenschaft fest. (Geerbt von Object)
ToArray<T>()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
ToString()	Gibt eine Zeichenfolgendarstellung des Objekts zurück. (Geerbt von Object)
UnregisterFromRuntime()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
Wait()	Bewirkt, dass der aktuelle Thread wartet, bis er aktiviert wird, in der Regel durch em benachrichtigen/em> oder <em>interrupted</em>.<>< (Geerbt von Object)
Wait(Int64)	Bewirkt, dass der aktuelle Thread wartet, bis er aktiviert wird, in der Regel, indem <er>benachrichtigt</em> oder <em>interrupted</em> oder bis eine bestimmte Menge an Echtzeit verstrichen ist. (Geerbt von Object)
Wait(Int64, Int32)	Bewirkt, dass der aktuelle Thread wartet, bis er aktiviert wird, in der Regel, indem <er>benachrichtigt</em> oder <em>interrupted</em> oder bis eine bestimmte Menge an Echtzeit verstrichen ist. (Geerbt von Object)

Explizite Schnittstellenimplementierungen

IJavaPeerable.Disposed()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
IJavaPeerable.DisposeUnlessReferenced()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
IJavaPeerable.Finalized()	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
IJavaPeerable.JniManagedPeerState	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. (Geerbt von Object)

Erweiterungsmethoden

JavaCast<TResult>(IJavaObject)	Führt eine Für Android-Runtime überprüfte Typkonvertierung aus.
JavaCast<TResult>(IJavaObject)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen.
GetJniTypeName(IJavaPeerable)	AsyncTask sollte eine ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen.

Gilt für: