Back to Qt.io
Contact Us Blog Download Qt
Auf dieser Seite

QtTaskTree::QCustomTask Class

template <typename Task, typename Adapter, typename Deleter> class QtTaskTree::QCustomTask

Eine Klassenvorlage, die zum Deklarieren benutzerdefinierter Aufgabenelemente und zum Definieren ihrer „Setup“- und „Done“-Handler verwendet wird. Mehr...

Header: #include <qtasktree.h>
CMake: find_package(Qt6 REQUIRED COMPONENTS TaskTree)
target_link_libraries(mytarget PRIVATE Qt6::TaskTree)
qmake: QT += tasktree
Seit: Qt 6.11
Erbt von: QtTaskTree::ExecutableItem
Status: Technologievorschau

Diese Klasse befindet sich in der Technologievorschau und kann sich noch ändern.

Hinweis: Alle Funktionen dieser Klasse sind reentrant.

Öffentliche Typen

TaskDoneHandler
TaskSetupHandler

Öffentliche Funktionen

QCustomTask(SetupHandler &&setup = QCustomTask::TaskSetupHandler(), DoneHandler &&done = QCustomTask::TaskDoneHandler(), QtTaskTree::CallDone callDone = QtTaskTree::CallDoneFlag::Always)
QBarrierTask
QNetworkReplyWrapperTask
QProcessTask
QTaskTreeTask
QTcpSocketWrapperTask
QThreadFunctionTask
QTimeoutTask

Ausführliche Beschreibung

Beschreibt benutzerdefinierte Aufgabenelemente innerhalb von Rezepten im Aufgabebaum.

Benutzerdefinierte Aufgabennamen werden mithilfe der Vorlage `QCustomTask` mit den angegebenen Parametern ` Task`, ` Adapter ` und ` Deleter` als Aliase mit eindeutigen Namen versehen. Beispielsweise ist ` QThreadFunctionTask<T>` ein Alias für die `QCustomTask`, die so definiert ist, dass sie mit ` QThreadFunction<T>` als zugehörige Aufgabenklasse zusammenarbeitet. Die folgende Tabelle enthält benutzerdefinierte Aufgaben, die von der TaskTree-Bibliothek bereitgestellt werden, sowie die zugehörigen Aufgabenklassen:

Name der Aufgabe mit AliasZugehörige AufgabenklasseKurzbeschreibung
QBarrierTaskQBarrierStartet eine Awaiter-Aufgabe.
QThreadFunctionTask<ReturnType>QThreadFunction<Rückgabetyp>Startet eine asynchrone Aufgabe. Wird in einem separaten Thread ausgeführt.
QProcessTaskQProcessStartet einen Prozess.
QNetworkReplyWrapperTaskQNetworkReplyWrapperSendet eine Netzwerkabfrage.
QTaskTreeTaskQTaskTreeStartet einen verschachtelten Aufgabenbaum.
QTcpSocketWrapperTaskQTcpSocketWrapperStellt eine TCP-Verbindung her.
QTimeoutTaskstd::chrono::millisecondsStartet einen Timer.

Der Vorlagenparameter „ Task “ ist obligatorisch und legt fest, welche Art von „ Task “ die ausgeführte „ QTaskTree “ instanziieren soll, wenn sie Teil eines Rezepts ist. Der Typ „ Task “ muss standardmäßig konstruierbar sein.

Das Template-Argument „ Adapter “ ist optional. Es kann weggelassen werden, wenn „ QDefaultTaskAdapter<Task>“ für die Anpassung an den Typ „ Task “ geeignet ist. Andernfalls muss der Typ „ Adapter “ für bestimmte „ Task “ folgende Form haben:

class Adapter
{
public:
    void operator()(Task *task, QTaskInterface *iface) { ... }
};

Implementieren Sie den oben genannten Operator() zum Starten der „ task “ und rufen Sie die Methode „ QTaskInterface::reportDone()“ für die übergebene „ iface “ auf, sobald die Aufgabe abgeschlossen ist.

Es ist gewährleistet, dass die übergebenen Objekte ` Task ` und ` QTaskInterface ` länger bestehen als die ` Adapter`. Falls erforderlich, darf der Destruktor von ` Adapter ` weiterhin auf das übergebene ` Task` zugreifen.

Weitere Details finden Sie unter QTaskInterface.

Das Template-Argument „ Deleter “ ist optional. Standardmäßig wird „ std::default_delete<Task> “ verwendet. Der benutzerdefinierte „ Deleter “ ist nützlich, wenn der Destruktor der laufenden „ Task “ den aufrufenden Thread möglicherweise blockieren könnte. Anstatt zu blockieren, kann der benutzerdefinierte „Deleter“ die laufende Aufgabe in einen separaten Thread verschieben und dort die blockierende Zerstörung implementieren. Auf diese Weise lässt sich die (aus Sicht des aufrufenden Threads) schnelle Zerstörung der laufenden Aufgabe mit einem blockierenden Destruktor erreichen.

Siehe auch QTaskInterface.

Dokumentation zu Mitgliedstypen

[alias] QCustomTask::TaskDoneHandler

Typalias für „ std::function<QtTaskTree::DoneResult(const Task &, QtTaskTree::DoneWith)> “ oder „ DoneResult “.

Der `TaskDoneHandler` ist ein optionales Argument des Konstruktors eines benutzerdefinierten Task-Elements. Jede Funktion mit der oben genannten Signatur, die als Task-Done-Handler übergeben wird, wird vom laufenden Task-Baum aufgerufen, nachdem die Task-Ausführung abgeschlossen ist und bevor das Endergebnis der Ausführung an die übergeordnete Gruppe zurückgemeldet wird.

Im Hauptteil des Handlers können Sie die endgültigen Daten der abgeschlossenen Aufgabe abrufen. Die zusätzlichen Parameter, einschließlich der Speicher, können über die Lambda-Erfassung an den Handler übergeben werden. Es ist auch möglich, dynamisch zu entscheiden, ob die Aufgabe mit ihrem Rückgabewert beendet werden soll oder ob das Endergebnis angepasst werden soll.

Das Argument „ DoneWith “ ist optional und kann in Ihrem „done“-Handler weggelassen werden. Wenn es angegeben wird, enthält es die Informationen über das Endergebnis einer Aufgabe, die an die übergeordnete Gruppe gemeldet werden.

Wenn Sie nicht vorhaben, Daten aus der abgeschlossenen Aufgabe auszulesen, können Sie das Argument „ const Task & “ weglassen.

Der zurückgegebene Wert „ DoneResult “ ist optional, und Ihr Handler kann stattdessen „ void “ zurückgeben. In diesem Fall entspricht das Endergebnis der Aufgabe dem durch das Argument „ DoneResult “ angegebenen Wert. Wenn der Handler den Wert „ DoneResult “ zurückgibt, kann das Endergebnis der Aufgabe innerhalb des Körpers des „done“-Handlers durch den zurückgegebenen Wert angepasst werden.

Bei einem `TaskDoneHandler` vom Typ ` DoneResult ` wird keine zusätzliche Verarbeitung durchgeführt, und die Aufgabe wird bedingungslos mit dem übergebenen Wert von ` DoneResult` beendet.

Siehe auch „ QCustomTask()“, „ TaskSetupHandler “ und „ GroupDoneHandler “.

[alias] QCustomTask::TaskSetupHandler

Typalias für „ std::function<SetupResult(Task &)> “.

`TaskSetupHandler` ist ein optionales Argument des Konstruktors eines benutzerdefinierten Aufgabenelements. Jede Funktion mit der oben genannten Signatur, die als Aufgaben-Setup-Handler übergeben wird, wird vom laufenden Aufgabenbaum nach der Erstellung der Aufgabe und vor deren Start aufgerufen.

Im Hauptteil des Handlers können Sie die Aufgabe entsprechend Ihren Anforderungen konfigurieren. Die zusätzlichen Parameter, einschließlich Speicher, können über die Lambda-Erfassung an den Handler übergeben werden. Sie können dynamisch entscheiden, ob die Aufgabe gestartet oder bei Erfolg bzw. bei einem Fehler übersprungen werden soll.

Hinweis: Starten Sie die Aufgabe nicht selbst innerhalb des Start-Handlers. Überlassen Sie dies „ QTaskTree “, andernfalls ist das Verhalten undefiniert. „ QTaskTree “ weiß dank des an den Konstruktor von „ QCustomTask<Task, Adapter, Deleter>“ übergebenen Adapter-Template-Parameters bereits, wie die Aufgabe gestartet wird.

Der Rückgabewert des Handlers gibt dem laufenden Aufgabenbaum vor, wie nach Beendigung des Handler-Aufrufs weiter verfahren werden soll. Der Rückgabewert von ` SetupResult::Continue ` weist den Aufgabenbaum an, die Ausführung fortzusetzen, d. h. den zugehörigen ` Task` auszuführen. Der Rückgabewert von ` SetupResult::StopWithSuccess ` oder ` SetupResult::StopWithError ` weist den Aufgabenbaum an, die Ausführung der Aufgabe zu überspringen und sie sofort erfolgreich bzw. mit einem Fehler zu beenden.

Wenn der Rückgabetyp entweder „ SetupResult::StopWithSuccess “ oder „ SetupResult::StopWithError “ ist, wird der „done“-Handler der Aufgabe (sofern vorhanden) anschließend nicht aufgerufen.

Der Konstruktor einer benutzerdefinierten Aufgabe akzeptiert auch Funktionen in der verkürzten Form „ std::function<void(Task &)> “, d. h., der Rückgabewert lautet „ void “. In diesem Fall wird davon ausgegangen, dass der Rückgabewert „ SetupResult::Continue “ ist.

Siehe auch „ QCustomTask()“, „ TaskDoneHandler “ und „ GroupSetupHandler “.

Dokumentation zu Mitgliedsfunktionen

[explicit] template < typename SetupHandler = QtTaskTree::QCustomTask<Task, Adapter, Deleter>::TaskSetupHandler, typename DoneHandler = QtTaskTree::QCustomTask<Task, Adapter, Deleter>::TaskDoneHandler, std::enable_if_t<!std::is_same_v<q20::remove_cvref_t<SetupHandler>, QCustomTask<Task, Adapter, Deleter>>, bool> = true > QCustomTask::QCustomTask(SetupHandler &&setup = QCustomTask::TaskSetupHandler(), DoneHandler &&done = QCustomTask::TaskDoneHandler(), QtTaskTree::CallDone callDone = QtTaskTree::CallDoneFlag::Always)

Erstellt eine QCustomTask-Instanz und fügt der Aufgabe die Handler „ setup “ und „ done “ hinzu. Wenn der laufende Aufgabenbaum die Aufgabe starten will, instanziiert er das zugehörige „ Task “-Objekt, ruft den „ setup “-Handler mit einer Referenz auf die erstellte Aufgabe auf und startet diese. Wenn die laufende Aufgabe beendet ist, ruft der Aufgabenbaum den „ done “-Handler mit einer „ const “-Referenz auf die erstellte Aufgabe auf.

Der übergebene Handler „ setup “ ist vom Typ „ TaskSetupHandler “. Beispiel:

static void parseAndLog(const QString &input);

...

const QString input = ...;

const auto onFirstSetup = [input](QThreadFunction<void> &task) {
    if (input == "Skip")
        return SetupResult::StopWithSuccess; // This task won't start, the next one will
    if (input == "Error")
        return SetupResult::StopWithError; // This task and the next one won't start
    task.setThreadFunctionData(parseAndLog, input);
    // This task will start, and the next one will start after this one finished with success
    return SetupResult::Continue;
};

const auto onSecondSetup = [input](QThreadFunction<void> &task) {
    task.setThreadFunctionData(parseAndLog, input);
};

const Group group {
    QThreadFunctionTask<void>(onFirstSetup),
    QThreadFunctionTask<void>(onSecondSetup)
};

Der ` done `-Handler ist vom Typ ` TaskDoneHandler `. Standardmäßig wird der ` done `-Handler immer dann aufgerufen, wenn die Aufgabe beendet ist. Übergeben Sie einen vom Standard abweichenden Wert für das Argument ` callDone `, wenn der Handler nur bei erfolgreicher, fehlgeschlagener oder abgebrochener Ausführung aufgerufen werden soll.

Siehe auch „ TaskSetupHandler “ und „ TaskDoneHandler “.

Verwandte Nicht-Mitglieder

[alias] QBarrierTask

Typalias für die Klasse „ QCustomTask “ <QBarrier> zur Verwendung in Rezepten.

[alias] QNetworkReplyWrapperTask

Typalias für die Klasse „ QCustomTask “ <QNetworkReplyWrapper>, zur Verwendung in Rezepten.

[alias] QProcessTask

Typalias für die „ QCustomTask “ <QProcess> unter Verwendung von QProcessTaskDeleter, zur Verwendung in Rezepten.

[alias] QTaskTreeTask

Typalias für die Klasse „ QCustomTask “ <QTaskTree>, zur Verwendung in Rezepten.

[alias] QTcpSocketWrapperTask

Typalias für die „ QCustomTask “ <QTcpSocketWrapper>, zur Verwendung in Rezepten.

[alias] template <typename ResultType> QThreadFunctionTask

Typalias für „ QCustomTask<QThreadFunction<ResultType>>“, wobei „ ResultType “ den Rückgabetyp der Thread-Funktion angibt, der innerhalb von Rezepten verwendet werden soll.

[alias] QTimeoutTask

Typalias für die „ QCustomTask “ <std::chrono::milliseconds>, zur Verwendung in Rezepten. Mit „ std::chrono::milliseconds “ wird die Zeitüberschreitungsdauer festgelegt. Die Standard-Zeitüberschreitung ist „ std::chrono::milliseconds::zero() “, d. h., die „QTimeoutTask“ wird beendet, sobald die Steuerung zur laufenden Ereignisschleife zurückkehrt.

Anwendungsbeispiel:

using namespace std::chrono;
using namespace std::chrono_literals;

const auto onSetup = [](milliseconds &timeout) { timeout = 1000ms; }
const auto onDone = [] { qDebug() << "Timed out."; }

const Group root {
    QTimeoutTask(onSetup, onDone)
};

Siehe auch „ timeoutTask()“.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.