使用存储库和工作单元模式进行多个DB事务的C＃实体框架

Question

I have defined three tables, Parts , Models and PartModel . For each Part row, there may be multiple Models row defined, and they are joined in a relationship via the PartModel table.

Parts

ID  PartName
1   Motorcycle
2   Cars

Models

ID  ModelName
1   Suzuki
2   Yamaha
3   Toyota
4   Nissan

PartModel

ID    PartID         ModelID
1       1               1
2       1               2
3       2               3
4       2               4

C# Models

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.Spatial;

namespace TestApplication.Model
{
    [Table("Parts")]
    public partial class Parts
    {
        [Key]
        public int PartID { get; set; }

        [Required]
        [StringLength(50)]
        public string PartName { get; set; }
    }

    [Table("Models")]
    public partial class Models
    {
        [Key]
        public int ModelID { get; set; }

        [Required]
        [StringLength(50)]
        public string ModelName { get; set; }
    }

    [Table("PartModel")]
    public partial class PartModel
    {
        [Key]
        public int PartModelID { get; set; }

        public int PartID { get; set; }

        public int ModelID { get; set; }
    }
}

And here are my repository classes:

BaseRepository.cs

using System;
using System.Transactions;

namespace TestApplication.Data
{
    public abstract class BaseRepository<TContext> : IDisposable
        where TContext : class, new()
    {
        private readonly bool startedNewUnitOfWork;
        private readonly IUnitOfWork<TContext> unitOfWork;
        private readonly TContext context;
        private bool disposed;

        public BaseRepository()
            : this(null)
        {
        }

        public BaseRepository(IUnitOfWork<TContext> unitOfWork)
        {
            if (unitOfWork == null)
            {
                this.startedNewUnitOfWork = true;
                this.unitOfWork = BeginUnitOfWork();
            }
            else
            {
                this.startedNewUnitOfWork = false;
                this.unitOfWork = unitOfWork;
            }

            this.context = this.unitOfWork.Context;
            this.disposed = false;
        }


        ~BaseRepository()
        {
            this.Dispose(false);
        }


        protected TContext Context
        {
            get
            {
                return this.context;
            }
        }

        public IUnitOfWork<TContext> UnitOfWork
        {
            get
            {
                return this.unitOfWork;
            }
        }


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

        public void Rollback()
        {
            this.unitOfWork.Rollback();
        }

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

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

                this.disposed = true;
            }
        }

        protected virtual void DisposeManagedResources()
        {
            if (this.startedNewUnitOfWork && (this.unitOfWork != null))
            {
                this.unitOfWork.Dispose();
            }
        }

        public IUnitOfWork<TContext> BeginUnitOfWork()
        {
            return BeginUnitOfWork(IsolationLevel.ReadCommitted);
        }

        public static IUnitOfWork<TContext> BeginUnitOfWork(IsolationLevel isolationLevel)
        {
            return new UnitOfWorkFactory<TContext>().Create(isolationLevel);
        }
    }
}

IRepository.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

namespace TestApplication.Data
{
    public interface IRepository<TContext, TEntity, TKey>
        where TContext : class
        where TEntity : class        
    {
        IUnitOfWork<TContext> UnitOfWork { get; }

        List<TEntity> Find(Expression<Func<TEntity, bool>> predicate = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderByMethod = null, string includePaths = "");
        TEntity FindByID(TKey id);
        List<TEntity> FindAll();
        void Add(TEntity entity, Guid userId);
        void Update(TEntity entity, Guid userId);
        void Remove(TKey id, Guid userId);
        void Remove(TEntity entity, Guid userId);
    }
}

Repository.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Linq.Expressions;

namespace TestApplication.Data
{
    public class Repository<TContext, TEntity, TKey> : BaseRepository<TContext>, IRepository<TContext, TEntity, TKey>
        where TContext : class, new()
        where TEntity : class        
    {
        private readonly DbSet<TEntity> _dbSet;

        private DbContext CurrentDbContext
        {
            get
            {
                return Context as DbContext;
            }
        }

        public Repository()
            : this(null)
        {
        }

        public Repository(IUnitOfWork<TContext> unitOfWork)
            : base(unitOfWork)
        {
            _dbSet = CurrentDbContext.Set<TEntity>();
        }

        public virtual List<TEntity> Find(Expression<Func<TEntity, bool>> predicate = null, Func<IQueryable<TEntity>, IOrderedQueryable<TEntity>> orderByMethod = null, string includePaths = "")
        {
            IQueryable<TEntity> query = _dbSet;

            if (predicate != null)
                query = query.Where(predicate);

            if (includePaths != null)
            {
                var paths = includePaths.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);

                query = paths.Aggregate(query, (current, path) => current.Include(path));
            }

            var entities = orderByMethod == null ? query.ToList() : orderByMethod(query).ToList();

            return entities;
        }

        public virtual TEntity FindByID(TKey id)
        {
            var entity = _dbSet.Find(id);

            return entity;
        }

        public virtual List<TEntity> FindAll()
        {
            return Find();
        }

        public virtual void Add(TEntity entity, Guid userId)
        {
            if (entity == null)
                throw new ArgumentNullException("entity");

            _dbSet.Add(entity);
        }

        public virtual void Update(TEntity entity, Guid userId)
        {
            if (entity == null) throw new ArgumentNullException("entity");

            _dbSet.Attach(entity);
            CurrentDbContext.Entry(entity).State = EntityState.Modified;
        }

        public virtual void Remove(TKey id, Guid userId)
        {
            var entity = _dbSet.Find(id);
            Remove(entity, userId);
        }

        public virtual void Remove(TEntity entity, Guid userId)
        {
            if (entity == null)
                throw new ArgumentNullException("entity");

            if (CurrentDbContext.Entry(entity).State == EntityState.Detached)
                _dbSet.Attach(entity);

            _dbSet.Remove(entity);
        }
    }
}

PartsRepository.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using TestApplication.Model;

namespace TestApplication.Data
{
    public class PartsRepository : Repository<DBContext, Parts, int>
    {
        public PartsRepository() : this(null) { }
        public PartsRepository(IUnitOfWork<DBContext> unitOfWork) : base(unitOfWork) { }
    }
}

ModelsRepository.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using TestApplication.Model;

namespace TestApplication.Data
{
    public class ModelsRepository : Repository<DBContext, Models, int>
    {
        public ModelsRepository() : this(null) { }
        public ModelsRepository(IUnitOfWork<DBContext> unitOfWork) : base(unitOfWork) { }
    }
}

PartModelRepository.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using TestApplication.Model;

namespace TestApplication.Data
{
    public class PartModelRepository : Repository<DBContext, PartModel, int>
    {
        public PartModelRepository() : this(null) { }
        public PartModelRepository(IUnitOfWork<DBContext> unitOfWork) : base(unitOfWork) { }

        public PartModel GetPartModelByModelID(ModelID)
        {
            // LINQ Query here to get the PartModel object based on the ModelID
            var q = (from a in this.Context.PartModel.Where(a => a.ModelID == ModelID)
                             select a);
            PartModel partModel = q.FirstOrDefault();
            return partModel;
        }
    }
}

What I need to do is to use the repository to say, for example, I wanted to delete the model 1 (Suzuki), I can perform multiple table delete in a single transaction so that I can be assured that the data will be deleted from both tables Model and PartModel .

Currently, my codes are as follows (this works but notice that I am committing on both Repository calls, which then has the tendency where one transaction may fail but still the changes to the database would be pushed on the other repository call):

public bool DeleteModel(int ModelID)
{
    // Get the PartModel based on the ModelID
    using(PartModelRepository partModelRepo = new PartModelRepository())
    {
        PartModel partModel = partModelRepo.GetPartModelByModelID(ModelID);
        partModelRepo.Remove(partModel, Guid.NewGuid());
        partModel.Commit();
    }

    // Delete the Model
    using(ModelsRepository modelRepo = new ModelsRepository())
    {
        Models model = modelRepo.FindByID(ModelID);
        modelRepo.Remove(model, Guid.NewGuid());
        modelRepo.Commit();
    }
}

How would I be able to translate this so that I can have a single Commit for both DB delete commands?

I tried the following:

public bool DeleteModel(int ModelID)
{
    // Get the PartModel based on the ModelID
    using(ModelsRepository modelsRepo = new ModelsRepository())
    {
        using(PartModelRepository partModelRepo = new PartModelRepository(modelsRepo.UnitOfWork))
        {
            PartModel partModel = partModelRepo.GetPartModelByModelID(ModelID);
            partModelRepo.Remove(partModel, Guid.NewGuid());

            Models model = modelRepo.FindByID(ModelID);
            modelRepo.Remove(model, Guid.NewGuid());
            modelRepo.Commit();
        }
    }
}

But it is throwing an error saying something about FK Constraint Violation.

I do understand that I am deleting the PartModel and the Model , but it seems it can't take both delete actions into a single transaction operation.

Appreciate any input.

UPDATE

As some people have posted here, I have updated my code to utilize Transactions as recommended by Microsoft .

public bool DeleteModel(int ModelID)
    {
        // Get the PartModel based on the ModelID

        using (var transaction = this.Context.Database.BeginTransaction())
        {
            PartModel partModel = this.Context.PartModel.First(s => s.ModelID == ModelID);
            Models model = this.Context.Models.First(s => s.ModelID == ModelID);

            this.Context.PartModel.Remove(partModel);
            this.Context.Models.Remove(model);

            this.Context.SaveChanges();
            transaction.Commit();
        }

        return true;
    }

I traced the database call using MS SQL Profiler and the commands being issued are correct. The issue I am having is that it seems that the changes are not being persisted to the database.

I used a try catch block on the above code, but no error is being thrown, hence, I know that the operation is ok.

Any ideas on where to look further?

Answer 1

DbContext is aware of ambient transactions.

To do show, reference System.Transactions in your project and enclose all the actions inside a block like this, which instances a TrasnactionScope :

using(var ts = new TransactinScope())
{
    // inside transaction scope

    // run all the transactional operations here

    // call .Complete to "commit" them all
    ts.Complete();
}

If there is an exception, or you don't call ts.Complete() or you explicitly call ts.Dispose() the transaction, which means all the operations inside the block, is rolled back.

For example, you can modify your public bool DeleteModel(int ModelID) including a using that wraps all the operations, and they'll share the same transaction.

Update:

Just to add more to this answer, since I am mostly performing data related changes, I have opted to use Database.BeginTransaction .

Answer 2

You can use .Net's TransactionScope class to do a Multi-database transaction. You'll still have to call SaveChanges() on each context separately within the transaction, but calling Commit() on the outer TransactionScope will do the final commit.

As far as your fk violation, I'd recommend using SqlServer profiler or a DB interceptor to trace the queries EF is executing. Sometimes you need to be more explicit in telling EF to delete dependencies: the trace should make it easy to tell what is t being deleted. Another thing to watch out for is that EF assumes FK relationships are Cascade On Delete by default. If you haven't disabled this in your configuration and EF is not the one generating your DB, then the mismatch can cause EF to assume it needs to issue fewer delete queries than is actually required.