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.)
È necessario implementare l'unità di modello di lavoro per evitare l'ambito della transazione.
Unit of Work
e ilRepository 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();
}
}