Beziehung zwischen Projektarchiv und Arbeitseinheit

Ich werde ein Repository implementieren, und ich möchte das UOW-Muster verwenden, da der Konsument des Repository mehrere Operationen ausführen kann, und ich möchte sie gleichzeitig festschreiben.

Nachdem ich mehrere Artikel über die Angelegenheit gelesen habe, verstehe ich immer noch nicht, wie ich diese beiden Elemente in Beziehung setzen soll, je nachdem, wie der Artikel in einer anderen Weise ausgeführt wird.

Manchmal ist das UOW etwas internes im Repository:

public class Repository
{
    UnitOfWork _uow;

    public Repository()
    {
       _uow = IoC.Get<UnitOfWork>();
    }

    public void Save(Entity e)
    {
        _uow.Track(e);
    }

    public void SubmittChanges()
    {
        SaveInStorage(_uow.GetChanges());
    }
}

Und manchmal ist es extern:

public class Repository
{
    public void Save(Entity e, UnitOfWork uow)
    {
        uow.Track(e);
    }

    public void SubmittChanges(UnitOfWork uow)
    {
        SaveInStorage(uow.GetChanges());
    }
}

Ein anderes Mal ist das UOW, das auf das Repository verweist

public class UnitOfWork
{
    Repository _repository;

    public UnitOfWork(Repository repository)
    {
       _repository = repository;
    }

    public void Save(Entity e)
    {
        this.Track(e);
    }

    public void SubmittChanges()
    {
       _repository.Save(this.GetChanges());
    }
}

Wie hängen diese beiden Elemente zusammen? UOW verfolgt die Elemente, die geändert werden müssen, und das Repository enthält die Logik, um diese Änderungen beizubehalten, aber ... wer ruft wen an? Macht das letztere mehr Sinn?

Wer verwaltet die Verbindung? Wenn mehrere Vorgänge im Repository ausgeführt werden müssen, ist die Verwendung derselben Verbindung und sogar der Transaktion meines Erachtens sinnvoller. Platzieren Sie daher möglicherweise das Verbindungsobjekt in der UOW, und dieses Objekt im Repository ist ebenfalls sinnvoll.

Prost

Betreff: "UOW verfolgt die Elemente, die geändert werden müssen, und das Repository enthält die Logik, um diese Änderungen beizubehalten, aber ... wer ruft wen an?"

Sie verstehen die grundlegenden Verantwortlichkeiten dieser Klassen. Sie sagen, dass jeder der Artikel, den Sie gelesen haben, sie auf unterschiedliche Weise miteinander verbindet. Dies bedeutet, dass die Entscheidung, wer wen anruft, bei Ihnen liegt.

Ich würde versuchen, das Problem in Bezug auf Ebenen zu skizzieren, während ich mich an den Grundprinzipien eines guten Software-Designs wie Kohäsion , Entkopplung , Wiederverwendbarkeit , Einheitentestbarkeit usw. orientiere.

So zitieren Sie Eric Evans Domain Driven Design (2004), Addison Wesley, S. 69 :

Das wesentliche Prinzip [von Layered Archituctures] ist, dass jedes Element einer Ebene nur von anderen Elementen in derselben Ebene oder von Elementen der Ebenen "darunter" abhängt.

Meiner Meinung nach sind UOW und Repo zwei sehr unterschiedliche Klassen, die klare, unabhängige Verantwortlichkeiten haben. Zunächst einmal würde ich keinen der beiden dazu bringen, den anderen aufzurufen.

Ich denke, Sie brauchen eine dritte Kundenklasse (dh entweder ein controlleroder service class), die wirklich weiß, wann und was aus dem Repo zu bekommen ist und wann, um die Transaktion zu speichern. Dieser Client befindet sich in der Architektur relativ weit oben (kann also mehr über Klassen wissen ) und kann eine Orchestrierung zwischen den beiden durchführen.

--------------------------------

         [Client]
           /   \
----------/---- \---------------
         /       \
        V         V
[Unit Of Work]  [Repo]


--------------------------------

Die Methoden werden am häufigsten für die UOW-Schnittstelle angegeben (die normalerweise über eine Factory erstellt wird).

Normalerweise rufen Sie Methoden auf einer UOW-Schnittstelle über die Befehlsmusterklasse (n) / Fassade auf. Da UOW die Datenbank-E / A einfach bis zu einem späteren Zeitpunkt zurückstellt (um zu verhindern, dass Sie lange laufende Transaktionen ausführen oder mehrere unnötige Aufrufe an die Datenbank ausführen), sollte die Arbeit mit der UOW auf dem Niveau erfolgen, auf dem Sie normalerweise mit Ihrer Datenbank arbeiten würden.

Microsoft hat einen sehr gründlichen Beitrag zum UOW-Muster:

http://msdn.microsoft.com/en-us/magazine/dd882510.aspx