Chiama il metodo di servizio multiplo in una transazione

Question

Chiama il metodo di servizio multiplo in una transazione

entity-framework entity-framework-6 transactionscope

Domanda

Perdonami, non sono bravo con EF6. Se faccio qualche errore Per favore aiutami a correggerlo. Grazie.

In primo luogo voglio implementare la logica di business nel mio livello di servizio come di seguito.

public class userService
{
    void createWithCommit(User user)
    {
        MyEntityContext db= new MyEntityContext ();
        ...
        db.Users.add(user);//Add a new user entity
        ....
        Work w = new Work();
        ... 
        db.Works.add(w);//Add a new work entity
        db.savechanges();//commit the changes which will insert 2 new record . one is user . another is work.
    }
}

Ma in alcune classi di servizio voglio chiamare più di un altro metodo di servizio in una transazione come di seguito.

class utilService
{
    void update(SomeClass cls)
    {
        using (var tran=new TransactionScope())
        {
          userService userSvr= new userService();
          userSvr.create();//this method already include a savechanges().
          jobService jobSvr= new jobService();
          jobSvr.update();//this method may include another savechanges().
          tran.Complete();//I don't why EF6 doesn't have the Commit method. just has the Complete method.
        }

    }
}

Quindi posso usarlo nel controller MVC ASP.net come di seguito.

class SomeController
{
    ActionResult index()
    {
        userService userSvr = new userService();
        userSvr.createWithCommit();

    }

    ActionResult util()
    {
        utilService utilSvr = new utilService ();
        userSvr.update(....);

    }
}

Quindi puoi vedere la mia idea è che voglio includere più metodi di servizio in un'unica transazione. e ciascuno dei metodi di servizio inclusi può includere o meno il codice SaveChanges() (Ciò significa che una transazione è impegnata. Giusto?).

E tu puoi vedere. Nel mio test, ho provato a utilizzare TransactionScope per includere più metodi di servizio in un'unica transazione. Intendo nel metodo utilService.update() . Ma sembra che TransactionScope non funzioni dopo che SaveChanges() is called . Quindi la mia domanda è:

C'è qualche possibilità di implementarlo come mia idea? Se c'è . Che tipo di modello dovrei applicare? (Ho sentito parlare di pattern UOW e Repository: sono la soluzione? Grazie.)

Joe.wang

Vedi di più su Stack Overflow

Eldho · Accepted Answer · 8/11/2015 3:59:02 PM

È necessario implementare l'unità di modello di lavoro per evitare l'ambito della transazione. Unit of Work e il Repository Pattern è qualcosa che viene usato abbastanza ampiamente al giorno d'oggi.
Uow mostra il metodo pubblico Commit per memorizzare le modifiche.

Repository generico

public class GenericRepository<TEntity> where TEntity : class
{
    internal SchoolContext context;
    internal DbSet<TEntity> dbSet;

    public GenericRepository(SchoolContext context)
    {
        this.context = context;
        this.dbSet = context.Set<TEntity>();
    }

    public virtual IEnumerable<TEntity> Get(
        Expression<Func<TEntity, bool>> filter = null,
        Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderBy = null,
        string includeProperties = "")
    {
        IQueryable<TEntity> query = dbSet;

        if (filter != null)
        {
            query = query.Where(filter);
        }

        foreach (var includeProperty in includeProperties.Split
            (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
        {
            query = query.Include(includeProperty);
        }

        if (orderBy != null)
        {
            return orderBy(query).ToList();
        }
        else
        {
            return query.ToList();
        }
    }

    public virtual TEntity GetByID(object id)
    {
        return dbSet.Find(id);
    }

    public virtual void Insert(TEntity entity)
    {
        dbSet.Add(entity);
    }

    public virtual void Delete(object id)
    {
        TEntity entityToDelete = dbSet.Find(id);
        Delete(entityToDelete);
    }

    public virtual void Delete(TEntity entityToDelete)
    {
        if (context.Entry(entityToDelete).State == EntityState.Detached)
        {
            dbSet.Attach(entityToDelete);
        }
        dbSet.Remove(entityToDelete);
    }

    public virtual void Update(TEntity entityToUpdate)
    {
        dbSet.Attach(entityToUpdate);
        context.Entry(entityToUpdate).State = EntityState.Modified;
    }
}

UnitOFWork

public class UnitOfWork : IDisposable
{
    //Context Creation in the UnitOfWork
    //This context is supplied to all Repository 
    //Hence One Commit save All Changes
    private SchoolContext context = new SchoolContext();
    private GenericRepository<Department> departmentRepository;
    private GenericRepository<Course> courseRepository;

    public GenericRepository<Department> DepartmentRepository
    {
        get
        {

            if (this.departmentRepository == null)
            {
                this.departmentRepository = new GenericRepository<Department>(context);
            }
            return departmentRepository;
        }
    }

    public GenericRepository<Course> CourseRepository
    {
        get
        {

            if (this.courseRepository == null)
            {
                this.courseRepository = new GenericRepository<Course>(context);
            }
            return courseRepository;
        }
    }

    public void Save()
    {
        context.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

uso

  //Sample Controller
 public class CourseController : Controller
   {
      //Initialize the unit of work here
      private UnitOfWork unitOfWork = new UnitOfWork();

      Public Void MyBussinessTransaction()
      {
         unitOfWork.CourseRepository.Insert(course);
         unitOfWork.DepartmentRepository.Insert(department)
         unitOfWork.Save();
      }
   }

Implementazione dei modelli di deposito e unità di lavoro

Spiegazione di Martin Flower di UOW

Chiama il metodo di servizio multiplo in una transazione

Domanda

Fastest Entity Framework Extensions

Risposta accettata

Performance

Expression Evaluator

Related