Ejemplo n.º 1
0
        public async Task SetItemsEnsureNotAsync(string setKey, string entityId)
        {
            using (_logger.BeginScope(new Dictionary <string, object>
            {
                { "SetKey", setKey },
                { "EntityId", entityId }
            }))
            {
                var sw = Stopwatch.StartNew();
                _logger.LogDebug("SetItemsEnsureNotAsync started");

                if (await CacheClient.ExistsAsync(setKey).ConfigureAwait(false))
                {
                    if (_options.DisableLocking2)
                    {
                        //if (await CacheClient.ExistsAsync(setKey))
                        //{
                        await CacheClient.SetRemoveAsync(setKey, new[] { entityId }).ConfigureAwait(false);

                        //}
                    }
                    else
                    {
                        var lockId = $"{setKey}.ItemsAdd";

                        await _lockProvider.TryUsingAsync(lockId, () => CacheClient.SetRemoveAsync(setKey, new[] { entityId }), TimeSpan.FromSeconds(2), CancellationToken.None).ConfigureAwait(false);
                    }
                }

                sw.Stop();
                _logger.LogDebug("SetItemsEnsureNotAsync finished in {Elapsed} ms", sw.ElapsedMilliseconds);
            }
        }
Ejemplo n.º 2
0
        public async Task <List <T> > LoadSetItems <T>(string setKey, Expression <Func <T, bool> > where, int minutes = int.MinValue, CancellationToken cancellationToken = default) where T : Entity
        {
            using (_logger.BeginScope(new Dictionary <string, object>
            {
                { "SetKey", setKey },
                { "EntityType", typeof(T).Name }
            }))
            {
                var sw = Stopwatch.StartNew();
                _logger.LogDebug("LoadSetItems started");
                if (string.IsNullOrEmpty(setKey))
                {
                    return(new List <T>());
                }

                if (where == null)
                {
                    return(new List <T>());
                }

                if (!_options.DisableLocking)
                {
                    var isLocked = await _lockProvider.IsLockedAsync(setKey).ConfigureAwait(false);

                    //if is locked wait
                    if (isLocked)
                    {
                        var items = new List <T>();
                        //warten und die fertige liste zurück geben
                        _logger.LogDebug("LoadSetItems: Locked - waiting {Key}", setKey);

                        await _lockProvider.TryUsingAsync(setKey, async() =>
                        {
                            var temp = await LoadList1 <T>(setKey, minutes, cancellationToken).ConfigureAwait(false);
                            items.AddRange(temp);
                        }, null, TimeSpan.FromSeconds(_options.CacheLockTimeoutSeconds)).ConfigureAwait(false);


                        return(items);
                    }
                }

                var existsAsync = await CacheClient.ExistsAsync(setKey).ConfigureAwait(false);

                if (!existsAsync)
                {
                    var items = new List <T>();

                    _logger.LogDebug("LoadSetItems: Key not Found in Cache {Key}", setKey);

                    if (_options.DisableLocking)
                    {
                        var temp = await LoadListAndAddSetToCache(setKey, where, minutes, cancellationToken).ConfigureAwait(false);

                        items.AddRange(temp);
                    }
                    else
                    {
                        await _lockProvider.TryUsingAsync(setKey, async() =>
                        {
                            var temp = await LoadListAndAddSetToCache(setKey, where, minutes, cancellationToken).ConfigureAwait(false);
                            items.AddRange(temp);
                        }, null, TimeSpan.FromSeconds(_options.CacheLockTimeoutSeconds)).ConfigureAwait(false);
                    }
                    return(items);
                }


                var result = await LoadList1 <T>(setKey, minutes, cancellationToken).ConfigureAwait(false);

                sw.Stop();
                _logger.LogDebug("LoadSetItems finished in {Elapsed} ms", sw.ElapsedMilliseconds);

                return(result);
            }
        }