Пример #1
0
        public T Commit(TT pars = default(TT))
        // Pars are the extra parameters send to the save and delete callbacks, in this way we can forward behaviors to the callbacks
        {
            object obj = _repo.BeginSave(Entity, Original, pars);
            T      ret;

            using (_repo.RepoLock.WriterLock())
            {
                ShokoContext ctx = _repo.Provider.GetContext();
                if (Original == null || !IsUpdate)
                {
                    ret = Entity;
                    ctx.Add(Entity);
                }
                else
                {
                    ret = Original;
                    Entity.DeepCloneTo(Original); //Tried to be 100% atomic and failed miserably, so is 99%.
                                                  //If we replace Original with Entity in cache (updating with 'this' as the model to update will not get the changes).
                                                  //So this is the best effort
                    ctx.Attach(Original);
                    ctx.Update(Original);
                }
                Release();
                if (_repo.IsCached)
                {
                    _repo.Cache.Update(ret);
                }
                ctx.SaveChanges();
            }
            _repo.EndSave(ret, obj, pars);
            return(ret);
        }
Пример #2
0
        public List <T> Commit(TT pars = default(TT))
        {
            Dictionary <T, object> savedObjects = new Dictionary <T, object>();

            foreach (T t in EntityList)
            {
                savedObjects[t] = _repo.BeginSave(t, References[t], pars);
            }
            List <T> returns = new List <T>();
            var      updates = References.Where(a => a.Value != null).ToList();
            var      creates = References.Where(a => a.Value == null).ToList();

            using (_repo.RepoLock.WriterLock())
            {
                ShokoContext ctx = _repo.Provider.GetContext();
                foreach (KeyValuePair <T, T> r in updates)
                {
                    ctx.UpdateChanges(r.Value, r.Key);

                    /*
                     *                  r.Key.DeepCloneTo(r.Value);   //Tried to be 100% atomic and failed miserably, so is 99%.
                     *                                                //If we replace Original with Entity in cache (updating with 'this' as the model to update will not get the changes).
                     *                                                //So this is the best effort
                     *                  ctx.Attach(r.Value);
                     *                  ctx.Update(r.Value);*/
                    returns.Add(r.Value);
                }
                foreach (KeyValuePair <T, T> r in creates)
                {
                    ctx.Add(r.Key);
                    returns.Add(r.Key);
                }
                Release();
                if (_repo.IsCached)
                {
                    returns.ForEach(_repo.Cache.Update);
                }
                ctx.SaveChanges();
                ctx.DetachRange(returns);
            }

            // TODO Needs a better way to index. r.Value and r.Key are not always the same, throwing an error on indexing
            // At least the current references will work with this.
            foreach (T t in savedObjects.Keys)
            {
                if (savedObjects.ContainsKey(t))
                {
                    _repo.EndSave(t, savedObjects[t], pars);
                }
            }
            return(EntityList);
        }
Пример #3
0
        public List <T> Commit(TT pars = default(TT))
        {
            Dictionary <T, object> savedObjects = new Dictionary <T, object>();

            foreach (T t in EntityList)
            {
                savedObjects[t] = _repo.BeginSave(t, References[t], pars);
            }
            List <T> returns = new List <T>();
            var      updates = References.Where(a => a.Value != null).ToList();
            var      creates = References.Where(a => a.Value == null).ToList();

            using (_repo.RepoLock.WriterLock())
            {
                ShokoContext ctx = _repo.Provider.GetContext();
                foreach (KeyValuePair <T, T> r in updates)
                {
                    r.Key.DeepCloneTo(r.Value);   //Tried to be 100% atomic and failed miserably, so is 99%.
                                                  //If we replace Original with Entity in cache (updating with 'this' as the model to update will not get the changes).
                                                  //So this is the best effort
                    ctx.Attach(r.Value);
                    ctx.Update(r.Value);
                    returns.Add(r.Value);
                }
                foreach (KeyValuePair <T, T> r in creates)
                {
                    ctx.Add(r.Key);
                    returns.Add(r.Key);
                }
                Release();
                if (_repo.IsCached)
                {
                    returns.ForEach(_repo.Cache.Update);
                }
                ctx.SaveChanges();
            }
            foreach (T t in returns)
            {
                _repo.EndSave(t, savedObjects[t], pars);
            }
            return(EntityList);
        }
Пример #4
0
        public List <T> Commit(TT pars = default(TT))
        {
            Dictionary <T, object> savedobjects = new Dictionary <T, object>();

            if (_delete_not_updated)
            {
                foreach (T t in _originalItems.Keys.ToList())
                {
                    if (_references.ContainsKey(t))
                    {
                        _originalItems.Remove(t);
                    }
                }

                if (_originalItems.Keys.Count > 0)
                {
                    foreach (T e in _originalItems.Values)
                    {
                        savedobjects[e] = _repo.BeginDelete(e, pars);
                    }
                    ShokoContext ctx = _repo.Provider.GetContext();
                    ctx.AttachRange(_originalItems.Values);
                    ctx.RemoveRange(_originalItems.Values);
                    ctx.SaveChanges();
                    if (_repo.IsCached)
                    {
                        _originalItems.Values.ForEach(_repo.Cache.Remove);
                    }
                    foreach (T e in _originalItems.Values)
                    {
                        _repo.EndDelete(e, savedobjects[e], pars);
                    }
                }
            }
            savedobjects.Clear();

            List <T> returns = new List <T>();

            if (_references.Count > 0)
            {
                foreach (T t in _references.Keys)
                {
                    savedobjects[t] = _repo.BeginSave(t, _references[t], pars);
                }

                var updates = _references.Where(a => a.Value != null).ToList();
                var creates = _references.Where(a => a.Value == null).ToList();
                using (_repo.RepoLock.WriterLock())
                {
                    ShokoContext ctx = _repo.Provider.GetContext();
                    foreach (KeyValuePair <T, T> r in updates)
                    {
                        ctx.UpdateChanges(r.Value, r.Key);

                        /*
                         *
                         * r.Key.DeepCloneTo(r.Value); //Tried to be 100% atomic and failed miserably, so is 99%.
                         * //If we replace Original with Entity in cache (updating with 'this' as the model to update, will not get the changes).
                         * //So this is the best effort
                         * ctx.Attach(r.Value);
                         * ctx.Update(r.Value);*/
                        returns.Add(r.Value);
                    }

                    foreach (KeyValuePair <T, T> r in creates)
                    {
                        ctx.Add(r.Key);
                        returns.Add(r.Key);
                    }

                    if (_repo.IsCached)
                    {
                        returns.ForEach(_repo.Cache.Update);
                    }
                    ctx.SaveChanges();
                    ctx.DetachRange(returns);
                }

                // At least the current references will work with this.
                foreach (T t in savedobjects.Keys)
                {
                    if (savedobjects.ContainsKey(t))
                    {
                        _repo.EndSave(t, savedobjects[t], pars);
                    }
                }
            }

            return(returns);
        }