예제 #1
0
        protected void PushUpdates <IdType, EntityType>(IList <EntityType> entities, IEntityWriter writer)
            where EntityType : class, IEntity, IHaveId <IdType>
            where IdType : IComparable <IdType>
        {
            var hash = entities.First().GetTypeHashCode();

            foreach (var entity in entities)
            {
                var key = new IdKey(entity.Id, hash);

                lock (_syncRoot)
                {
                    if (_deletes.Contains(key))
                    {
                        throw new InvalidOperationException(string.Format("Entity already marked for deletion, id : {0}", entity.Id));
                    }

                    if (_updates.Contains(key))
                    {
                        _tasks.Remove(key);
                    }

                    _tasks.Add(key, new WorkAction(ActionType.Update, entity, writer));
                }
            }
        }
예제 #2
0
        public void Add <EntityType>(EntityType entity, IEntityWriter writer)
            where EntityType : class, IEntity
        {
            var key = new IdKey(entity.GetHashCode(), entity.GetTypeHashCode());

            lock (_syncRoot)
                if (!_adds.Contains(key))
                {
                    _tasks.Add(key, new WorkAction(ActionType.Add, entity, writer));
                }
        }
예제 #3
0
        public void Add <EntityType>(IList <EntityType> entities, IEntityWriter writer)
            where EntityType : class, IEntity
        {
            lock (_syncRoot)
                foreach (var e in entities)
                {
                    var key = new IdKey(e.GetHashCode(), e.GetTypeHashCode());

                    if (!_adds.Contains(key))
                    {
                        _tasks.Add(key, new WorkAction(ActionType.Add, e, writer));
                    }
                }
        }
예제 #4
0
        protected void PushDelete <IdType>(IdType id, int typeHash, IEntityWriter writer)
            where IdType : IComparable <IdType>
        {
            var key = new IdKey(id, typeHash);

            lock (_syncRoot)
            {
                if (_updates.Contains(key))
                {
                    _tasks.Remove(key);
                }

                if (_deletes.Contains(key))
                {
                    _tasks.Remove(key);
                }

                _tasks.Add(key, new WorkAction(ActionType.Remove, null, writer));
            }
        }
예제 #5
0
        protected void PushUpdate <IdType, EntityType>(IdType id, EntityType entity, IEntityWriter writer)
            where EntityType : class, IEntity, IHaveId <IdType>
            where IdType : IComparable <IdType>
        {
            lock (_syncRoot)
            {
                var key = new IdKey(id, entity.GetTypeHashCode());

                if (_deletes.Contains(key))
                {
                    throw new InvalidOperationException(string.Format("Entity already marked for deletion, id : {0}", id));
                }

                if (_updates.Contains(key))
                {
                    _tasks.Remove(key);
                }

                _tasks.Add(key, new WorkAction(ActionType.Update, entity, writer));
                _deletes.ToDictionary(i => i);
            }
        }