entité + référentiel unité + ou travail question

Question

Je pense à commencer un nouveau projet en utilisant EF 4 et en passant par des articles, j'ai trouvé un article sur EF avec motif de dépôt et l'unité de travail (http://blogs.msdn.com/b/adonet/archive/2009/06/16/using-repository-and-unit-of-work-patterns-with-entity-framework-4-0.aspx)

En regardant cet article, il utilise ObjectContext comme UnitOfWork et le transmet au Repository. Ma question est que si j'ai 2 ObjectContext ce qui signifie que j'aurai 2 unités de travail, mais je veux que toutes les opérations effectuées sur ces 2 contextes soient une seule unité de travail, ce scénario est-il possible? Je ne veux pas appeler enregistrer sur chaque contexte, je voudrais qu'il soit transactionnel .... sans utiliser transactionscope ...

Par exemple, j'ai un contexte qui gère le journal d'opération et un autre contexte qui gère Ordres. Disons que dans ma couche métier, j'ai une méthode appelée AddOrder(). AddOrder() utilisera le contexte de la commande pour créer une nouvelle commande, mais utilisera également le contexte du journal des opérations pour créer une nouvelle entrée dans le journal des opérations. Puisque ce sont 2 contexte, je vais devoir appeler enregistrer sur les deux contexte à commettre .... peut-être la seule option est d'avoir un seul contexte unique ....

EDIT: Je voulais dire 2 contextes de types différents par exemple: OperationalLogContext et OrderContext.

Answer 1

Oui - je crois que c'est possible.

Le kicker est la façon dont gérer vos référentiels. Par exemple, chaque référentiel doit prendre un contexte. Il suffit donc de créer un contexte et de le transmettre à chaque référentiel.

(code s'il vous plaît!) Heureux u demandé :)

public interface IOrderRepository 
{ 
    IQueryable<Order> FindAll(); 
} 

public interface IOperationLogRepository 
{ 
    IQueryable<OperationLog> FindAll(); 
} 

public interface IUnitOfWork 
{ 
    void Commit(); 
} 

.

public class SqlServerContext : ObjectContext, IUnitOfWork 
{ 
    public void SqlServerContext(string connectionString) 
     : base(connectionString) 
    { 
    } 

    public void Commit() 
    { 
     this.SaveChanges(); 
    } 

    // Your other POCO's and stuff here ..etc.. 
} 

.

public class OrderRepostiory : IOrderRepository 
{ 
    private readonly SqlServerContext _sqlServerContext; 
    public void OrderRepostiory(SqlServerContext sqlServerContext) 
    { 
     _sqlServerContext = sqlServerContext; 
    } 

    public IQueryable<Order> FindAll() 
    { 
     _sqlServerContext.Orders; 
    } 
} 

.. et enfin, l'instanciation. Parce que ton un bon garçon/fille/licorne arc en ciel, vous utilisez l'injection de dépendance ..

public class SqlServerRegistry : Registry 
{ 
    public SqlServerRegistry(string connectionString) 
    { 
     For<SqlServerContext>() 
      .HybridHttpOrThreadLocalScoped() 
      .Use<SqlServerContext>() 
      .Ctor<string>("connectionString") 
       .Is(connectionString); 

     For<IOrderRepository>().Use<OrderRepository>(); 
     For<IOperationLogRepository>().Use<OperationLogRepository>(); 
    } 
} 

et parce que le SqlServerContext est défini comme HttpOrThreadLocal, il sera instantied UNE FOIS et réutilisé dans plusieurs Référentiels.

Vous ne connaissez pas ou ne comprenez pas DI/IoC?

alors ce serait aussi travailler ....

private SqlServerContext _sqlServerContext; 
private IOrderRepository _orderRepository; 
private IOperationLogRepository _operationLogRepository; 

[TestInitialize] 
public void TestInitialise() 
{ 
    _sqlServerContext = new SqlServerContext(
      ConfigurationManager.AppSettings["connectionString"]); 
    _orderRepository = new OrderRepository(_sqlServerContext); 
    _operationLogRepository= new OperationLogRepository(_sqlServerContext); 
} 

[TestMethod] 
public void SomeTest() 
{ 
    // Arrange. 
    const int count = 10; 

    // Act. 
    var orders = _orderRepository.FindAll().Take(10).ToArray(); 

    // Assert. 
    Assert.IsNotNull(orders); 
    CollectionAssert.AllItemsAreNotNull(orders); 
    Assert.AreEqual(count, orders.Length); 
} 

une fois de plus, c'est tout code non testé que je viens tapé, comme je pensais à répondre à cette question.

HTH.