C++ - Transaktion-Muster für Alles oder Nichts Arbeiten

Angenommen ich habe zwei Funktionen DoTaskA und DoTaskB—sowohl in der Lage zu werfen TaskException—mit Ihren entsprechenden "rollback" - Funktionen UndoTaskA und UndoTaskB. Was ist das beste Muster zu verwenden, so dass entweder beide gelingen oder scheitern beide?

Die besten, die ich jetzt haben, ist

bool is_task_a_done = false,
     is_task_b_done = false;

try {
    DoTaskA();
    is_task_a_done = true;

    DoTaskB();
    is_task_b_done = true;
} catch (TaskException &e) {
    //Before rethrowing, undo any partial work.
    if (is_task_b_done) {
        UndoTaskB();
    }
    if (is_task_a_done) {
        UndoTaskA();
    }
    throw;
}

Ich weiß, dass is_task_b_done unnötig ist, aber vielleicht gut zu zeigen code-Symmetrie im Fall fügen wir eine Dritte oder eine vierte Aufgabe später auf.

Nicht wie dieser code, da der Hilfs-Boolesche Variablen. Vielleicht gibt es etwas in der neuen C++11, die ich bin mir nicht bewusst, die kann code dieses mehr schön?

  • Wenn Sie im catch-block is_task_b_done ist immer false
  • Ich weiß, ich habe den Kommentar, dass es nur für den code Symmetrie im Fall fügen wir eine Dritte oder vierte Aufgabe.
  • Ist Ihre app mit multi-Threading? Hast du einen Blick auf RAII?
  • Für Einfachheit nehmen wir an, es ist nicht multithreaded. Suchen Sie ein design-Muster hier. Wie würde ich versuchen, diese mit RAII?
InformationsquelleAutor kirakun | 2012-06-11
  1. 13

    Etwas RAII commit/rollback-scope guard könnte wie folgt Aussehen:

    #include <utility>
#include <functional>

class CommitOrRollback
{
    bool committed;
    std::function<void()> rollback;

public:
    CommitOrRollback(std::function<void()> &&fail_handler)
        : committed(false),
          rollback(std::move(fail_handler))
    {
    }

    void commit() noexcept { committed = true; }

    ~CommitOrRollback()
    {
        if (!committed)
            rollback();
    }
};

    So, wir sind angenommen, wir werden immer die guard-Objekts, nachdem die Transaktion erfolgreich ist, und rufen Sie commit nur nach alle die Transaktionen gelungen.

    void complicated_task_a();
void complicated_task_b();

void rollback_a();
void rollback_b();

int main()
{
    try {
        complicated_task_a();
        //if this ^ throws, assume there is nothing to roll back
        //ie, complicated_task_a is internally exception safe
        CommitOrRollback taskA(rollback_a);

        complicated_task_b();
        //if this ^ throws however, taskA will be destroyed and the
        //destructor will invoke rollback_a
        CommitOrRollback taskB(rollback_b);


        //now we're done with everything that could throw, commit all
        taskA.commit();
        taskB.commit();

        //when taskA and taskB go out of scope now, they won't roll back
        return 0;
    } catch(...) {
        return 1;
    }
}

    PS. Als Anon-Mail sagt, es ist besser, schieben Sie alle jene taskX Objekte in einem container, wenn Sie haben viele von Ihnen, wodurch der Behälter die gleiche Semantik (call-commit auf die container zu haben, die es Begehen jedes im Besitz guard-Objekt).

    PPS. Im Prinzip können Sie std::uncaught_exception im RAII dtor anstatt explizit zu Begehen. Ich bevorzuge ausdrücklich fest, hier, weil ich denke, es ist klarer, und funktioniert auch einwandfrei, wenn Sie den Bereich verlassen früh mit einem return FAILURE_CODE anstatt eine Ausnahme.

    • Nette Antwort. Ich mag den Kommentar, dass std::uncaught_exception könnte verwendet werden, um zu vermeiden, die commit die etwas losgelöst von der Haupt-Körper fließen, so dass es einfach zu vergessen. Wir sollten nie gemischt error-handling Paradigmen sowieso.
    InformationsquelleAutor Useless
  2. 7

    Es ist schwer zu erreichen-Transaktion die Konsistenz in C++. Es ist eine schöne Methode beschrieben, mit der ScopeGuard Muster in der Dr. Dobb ' s journal. Die Schönheit dieses Ansatzes ist, dass diese Bereinigung in der sowohl die normalen Situationen und in der Ausnahme-Szenarien. Es nutzt die Tatsache, dass die Objekt-Destruktoren sind, der gewährleistet, rufen Sie auf jedem scope beendet und der Ausnahme-Fall ist nur ein weiterer Anwendungsbereich beenden.

    • Vielleicht könnten Sie reproduzieren (oder skizzieren) Sie den code inline, nur für den Fall, Dr. Dobbs passiert sein, wenn jemand Lesen dieser Antwort?
    InformationsquelleAutor PermanentGuest
  3. 1

    Haben Sie darüber nachgedacht, CommandPattern? Befehl Pattern-Beschreibung

    Sie Kapseln alle Daten, die erforderlich sind, um zu tun, was DoTaskA() tut
    in ein Objekt der command-Klasse, mit dem bonus, dass Sie umkehren können
    all dies, wenn nötig (also keine Notwendigkeit, einen speziellen rückgängig machen, wenn Fehler auf
    execute). Command-pattern eignet sich besonders gut für den Umgang mit "alles oder nichts"
    Situationen.

    Wenn Sie mehrere Befehle, die bauen auf einander auf, wie Ihr Beispiel
    gelesen werden können, dann sollten Sie untersuchen, Kette der Verantwortung

    vielleicht eine Reaktor-Muster kann in handliches kommen (Reaktor Beschreibung hier)
    dies wird invertieren die Steuerung, aber es fühlt sich natürlich und hat die
    nutzen verwandeln Sie Ihr system in ein starkes Multithreading, Multi-Komponenten
    design. aber es kann overkill hier, schwer zu sagen, vom Beispiel.

    InformationsquelleAutor Mare Infinitus
  4. 1

    Der beste Weg, dies zu erreichen ist mit scope guards, im Grunde eine kleine RAII idiom, das ruft eine rollback-handler, wenn eine Ausnahme geworfen wird.

    Habe ich Fragen über eine einfache Umsetzung der ScopeGuard ein bisschen her, und die Frage, die sich in eine schöne Umsetzung, ich bin mit meiner production-Projekte. Es arbeitet mit c++11 und Lambda-Ausdrücke als die rollback-Handler.

    meine Quelle hat tatsächlich zwei Versionen: eine, die ruft die rollback-handler, wenn der Konstruktor-handler wirft, und eine andere, die wird nicht werfen, wenn das passiert.

    überprüfen Sie die Quelle und Anwendungsbeispiele hier.

    InformationsquelleAutor lurscher
  5. 0

    Skalierbarkeit, die Sie möchten, speichern Sie die Tatsache, dass Sie benötigen, um ein undo für eine Aufgabe in einem container. Dann, in den catch-block, die Sie gerade aufrufen, alle undo-Schritte werden aufgezeichnet, in den container.

    Kann der container, zum Beispiel, enthalten, die Funktion von Objekten rückgängig zu machen, dass die Aufgabe erfolgreich abgeschlossen haben.

    InformationsquelleAutor Anon Mail
Schreibe einen Kommentar