public Task AddRecord(IDatabaseAsync database, IDataKey objectKey, params T[] instances)
        {
            if (database == null)
            {
                throw new ArgumentNullException(nameof(database));
            }

            if (objectKey == null)
            {
                throw new ArgumentNullException(nameof(objectKey));
            }

            if (instances == null)
            {
                throw new ArgumentNullException(nameof(instances));
            }

            log.LogDebug("AddRecords: {0}", instances.Length);
            if (instances.Length > 1)
            {
                throw new ArgumentOutOfRangeException();
            }

            var instance  = instances[0];
            var tasks     = new List <Task>();
            var actualKey = link.GetKey(objectKey);
            var entries   = objectSerialization.GetEntries(instance).ToArray();

            tasks.Add(database.HashSetAsync(actualKey, entries));
            tasks.AddRange(mainIndexManager.Add(database, objectKey));
            return(Task.WhenAll(tasks));
        }
Esempio n. 2
0
        public Task SaveItems(IDatabaseAsync database, IDataKey key, params RedisValue[] redisValues)
        {
            var redisKey = link.GetKey(key);

            logger.LogTrace("SaveItems: <{0}>", key);

            var tasks = new List <Task>(mainIndexManager.Add(database, key));
            var size  = GetLimit(key);

            if (size.HasValue)
            {
                var list = redisValues.ToList();
                list.Add(size.Value);
                tasks.Add(database.ScriptEvaluateAsync(
                              link.Generator.GenerateInsertScript(true, redisValues.Length),
                              new[] { redisKey },
                              list.ToArray()));
            }
            else
            {
                tasks.Add(database.ListRightPushAsync(redisKey, redisValues));
            }

            return(Task.WhenAll(tasks));
        }
Esempio n. 3
0
        public Task SaveItems(IDatabaseAsync database, IDataKey key, params RedisValue[] redisValues)
        {
            var redisKey = link.GetKey(key);

            logger.LogTrace("SaveItems: <{0}>", key);

            var time     = DateTime.UtcNow.ToUnixTime();
            var saveTask = database.SortedSetAddAsync(
                redisKey,
                redisValues.Select(item => new SortedSetEntry(item, time)).ToArray());

            List <Task> tasks = new List <Task>(indexManager.Add(database, key));

            tasks.Add(saveTask);
            return(Task.WhenAll(tasks));
        }
        public Task AddRecords(IDatabaseAsync database, IEnumerable <IDataKey> keys, params T[] instances)
        {
            if (database == null)
            {
                throw new ArgumentNullException(nameof(database));
            }

            if (keys == null)
            {
                throw new ArgumentNullException(nameof(keys));
            }

            if (instances == null)
            {
                throw new ArgumentNullException(nameof(instances));
            }

            if (typeof(T) != typeof(SortedSetEntry))
            {
                throw new ArgumentOutOfRangeException(nameof(T));
            }

            var tasks   = new List <Task>();
            var entries = instances.Cast <SortedSetEntry>().ToArray();

            foreach (var key in keys)
            {
                var redisKey = link.GetKey(key);
                var saveTask = database.SortedSetAddAsync(
                    redisKey,
                    entries);

                tasks.AddRange(mainIndexManager.Add(database, key));
                tasks.Add(saveTask);
            }

            return(Task.WhenAll(tasks));
        }