关于Entity Framework DbContext SaveChanges 返回0的求助

[beckfun]

直切话题， 采用的是Entity Framework+UnitOfWork+Repository+Autofac
UnitOfWork和Repository都是基础代码。网上直接都能搜到，不过按照管理，问问题，还是要贴源码
UnitOfWork的代码

public class UnitOfWork : DbContext, IUnitOfWork
    {
        /// <summary>
        /// 构造方法。
        /// </summary>
        protected UnitOfWork()
        {
        }
        /// <summary>
        /// 构造方法。
        /// </summary>
        protected UnitOfWork(string nameOrConnectionString)
            : base(nameOrConnectionString)
        {
        }

        /// <inheritdoc />
        public void Flush()
        {
            try
            {
                var i = base.SaveChanges();
            }
            catch (DbEntityValidationException ex)
            {
                this.Clear();
                List<string> errorMessageList=new List<string>();
                foreach (var entityValidationError in ex.EntityValidationErrors)
                {
                    errorMessageList.Add(entityValidationError.Entry.Entity.ToString());
                    foreach (var validationError in entityValidationError.ValidationErrors)
                    {
                        errorMessageList.Add(string.Format("属性({0})引发了一个验证错误：{1}", validationError.PropertyName, validationError.ErrorMessage));
                    }
                }
                throw new Exception(string.Join(";\\n", errorMessageList.ToArray()));
            }
            catch (DbUpdateConcurrencyException ex)
            {
                throw new OptimisticConcurrencyException();
            }
        }

        /// <inheritdoc />
        public void Clear()
        {
            base.ChangeTracker.Entries()
                              .ToList()
                              .ForEach(entry => entry.State = EntityState.Detached);
        }
    }

Repository的源码

public class Repository<TUnitOfWork, TAggregateRoot, TId> : IRepository<TAggregateRoot, TId>
        where TUnitOfWork : UnitOfWork
        where TAggregateRoot : class, IAggregateRoot<TId>
    {
        private readonly UnitOfWork _unitOfWork;
        /// <summary>
        /// 构造方法。
        /// </summary>
        protected Repository(TUnitOfWork unitOfWork)
        {
            _unitOfWork = unitOfWork;
        }

        /// <inheritdoc />
        public bool Contains(TAggregateRoot item)
        {
            return _unitOfWork.Entry(item).State != EntityState.Detached;
        }

        /// <inheritdoc />
        public void Save(TAggregateRoot item)
        {
            this.BeforeSave(item);
            _unitOfWork.Set<TAggregateRoot>().Add(item);
        }

        /// <summary>
        /// 模板方法子方法。
        /// </summary>
        protected virtual void BeforeSave(TAggregateRoot item) { }

        /// <inheritdoc />
        public void Update(TAggregateRoot item)
        {
            _unitOfWork.Entry(item).State = EntityState.Modified;
        }

        public void Delete(TAggregateRoot item)
        {
            _unitOfWork.Entry(item).State = EntityState.Deleted;
        }

        public void Merge(TAggregateRoot item)
        {
            var persistItem = _unitOfWork.Set<TAggregateRoot>().Find(item.Id);

            _unitOfWork.Entry(persistItem).CurrentValues.SetValues(item);
        }

        public void Detach(TAggregateRoot item)
        {
            _unitOfWork.Entry(item).State = EntityState.Detached;
        }

        public void Attach(TAggregateRoot item)
        {
            _unitOfWork.Entry(item).State = EntityState.Unchanged;
        }

        public TAggregateRoot Load(TId id)
        {
            return _unitOfWork.Set<TAggregateRoot>().Find(id);
        }

   
        public void Refresh(TAggregateRoot item)
        {
            _unitOfWork.Entry(item).Reload();
        }

        public DbSet<TAggregateRoot> Set<TAggregateRoot>() where TAggregateRoot : class
        {
            return _unitOfWork.Set<TAggregateRoot>();
        }
        public IUnitOfWork UnitOfWork
        {
            get
            {
                return _unitOfWork;
            }
        }

        /// <summary>
        /// 数据库上下文。
        /// </summary>
        protected DbContext DbContext
        {
            get
            {
                return _unitOfWork;
            }
        }
    }

Service调用

public class Service<TUnitOfWork,TRepository >
{
       public TRepository Repository
        {
            get
            {
                if (null == _repository)
                {
                    _repository = UnitOfWork.CreateRepository<TRepository>();
                }

                return _repository;
            }
        }
        protected TUnitOfWork UnitOfWork
        {
            get
            {
                return Service<TUnitOfWork>();
            }
        }
        public void Create(TAggregateRoot aggregate)
        {
            this.Repository.Save(aggregate);

            this.UnitOfWork.Flush();
        }
}

调用
new Service().Create(实体);断点监视，发现 SaveChanges 返回0，数据库没有任何动静，最奇怪的是用new Service().Repository.Set<T>() 查询的时候EF会生成SQL语句，更奇怪的是，之前也有用在一个项目上实践过可以正常使用，我也反复对比了两个项目，可以说代码基本一致。这是什么情况？在什么情况下SaveChanges 的返回值会是0，求助，问题解决，马上结贴！

[beckfun]

忘记补充了。是用的Code First

[feiyun0112]

_unitOfWork.Set<TAggregateRoot>().Add(item);
改成
_unitOfWork.Entry(item).State = EntityState.Added;

[beckfun]

引用 3 楼 feiyun0112 的回复:

_unitOfWork.Set<TAggregateRoot>().Add(item); 改成 _unitOfWork.Entry(item).State = EntityState.Added;

谢谢斑竹的回复，不管用，SaveChange返回还是0。

[feiyun0112]

看看Repository和UnitOfWork用的是不是同一个_unitOfWork

[beckfun]

引用 5 楼 feiyun0112 的回复:

看看Repository和UnitOfWork用的是不是同一个_unitOfWork

是同一个。

[beckfun]

引用 5 楼 feiyun0112 的回复:

看看Repository和UnitOfWork用的是不是同一个_unitOfWork

自己发现问题了。坑爹，其实上次这项目在别的项目也遇到了。是我向Autofac注册的问题。

registry.RegisterType(IUnitOfWorkType,UnitOfWorkType, LifeStyle.Singleton);
//改成
registry.RegisterType(UnitOfWorkType, LifeStyle.Singleton);

就可以了。