Quale modello di progettazione utilizzare per implementare il meccanismo di transazione o concatenamento

Question

Ho implementato una semplice classe di fabbrica in C# e Java. Questa classe crea istanze di classi di lavoro concrete che hanno una stessa interfaccia. In particolare, tutte queste classi hanno tali metodi come:

create 
select 
alter 
etc. 

Ora voglio avere un meccanismo (costruito sulla cima di qualche modello classico/non classica) che mi permetterà di creare "catene" di questi metodi o per incapsularli in una sorta di transazione. In uno pseudo-codice mi aspetto di vedere qualcosa di simile:

Transaction tnx = create(...args...).alter(...args_2...); 
//tnx.Execute(); 

O qualcosa di simile:

Transaction tnx; 
tnx.Start(); 
tnx.Add(method_name, ... variable list of arguments ...); 
tnx.Add(another_method_name, ... variable list of arguments ...); 
tnx.Execute(); 

Non sono così bravo a modelli di progettazione e non sono sicuro di quale schema da utilizzare. Spero che qualcuno possa condividere e rilasciare un paio di righe di codice (in C# o in Java) che dimostreranno come ciò possa essere implementato. Grazie!

Answer 1

unità di lavoro è il modello diritto di rappresentare le transazioni dominio .

Accumula le modifiche (aggiunge, aggiorna e rimuove) e possono essere atomicamente accettate o scartate. L'atomicità è garantita dall'implementazione dell'intera unità di lavoro e l'implementatore deve essere sicuro che i cambiamenti siano persistenti o scartati atomicamente.

controllare come Martin Fowler definisce on his pattern catalog:

Mantiene un elenco di oggetti colpiti da una transazione commerciale e coordina la scrittura di modifiche e la risoluzione dei problemi di concorrenza .

Una possibile interfaccia per Unità di modello di lavoro potrebbe essere:

public interface IUnitOfWork 
{ 
    void Commit(); 
    void Rollback(); 
} 

E si può anche aggiungere i seguenti metodi per l'interfaccia:

// Note I've added a generic type parameter to define what kind of 
// objects will handle the whole unit of work 
public interface IUnitOfWork<TObject> 
{ 
    void RegisterNew(TObject some); 
    void RegisterUpdated(TObject some); 
    void RegisterDeleted(TObject some); 
    void Commit(); 
    void Rollback(); 
} 

In ogni caso, tutti gli aggiornamenti dovrebbero essere gestito utilizzando un rilevamento delle modifiche monitorato dall'unità di lavoro e alcune aggiunte e Elimina troppo:

• Se si aggiunge un nuovo oggetto di una raccolta associata a qualche altro oggetto (Associazione 1-n), un'unità di lavoro dovrebbe essere in grado di rilevare che l'oggetto è sporco e deve essere mantenuta senza dire manualmente all'unità di lavoro di farlo.

• Uguale per le operazioni di rimozione. Se rimuovi un oggetto da un'associazione 1-n e nessun altro oggetto fa riferimento a esso (un oggetto orfano) dovrebbe essere automaticamente contrassegnato come eliminato.

La maggior parte dei mapper dati come O/M quadri già di attuazione cambiamento oggetto di monitoraggio utilizzando proxy degli oggetti da intercettare le chiamate insieme di proprietà.

Answer 2

Composite pattern è una scelta ovvia per le situazioni in cui si modella un intero sistema. Ecco come lo schema del modello sembra:

Dato che si dispone di una fabbrica di oggetti della stessa interfaccia, si è quasi fatto l'attuazione del composite.

• La vostra fabbrica produce oggetti conformi ad alcune interfacce. Questa interfaccia è l'interfaccia componente della tua implementazione composita.
• La vostra fabbrica produce classi concrete, che rappresentano le classi Leaf nella vostra implementazione composita.

L'unica classe lasciata da costruire è la classe Composite.

Diciamo vostra interfaccia Component si presenta così:

public interface IComponent { 
    void Create(); 
    void Alter(); 
    void Execute(); 
} 

Poi la classe composita Transaction può apparire come segue:

public class Transaction : IComponent { 
    private readonly IList<IComponent> components = new List<IComponent>(); 
    public void Add(IComponent c) { 
     components.Add(c); 
    } 
    void Create() { 
     foreach (var c in components) { 
      c.Create(); 
     } 
    } 
    void Alter() { 
     foreach (var c in components) { 
      c.Alter(); 
     } 
    } 
    void Execute() { 
     foreach (var c in components) { 
      c.Execute(); 
     } 
    } 
}