Azure Redis Cache — wiele błędów TimeoutException:przekroczenie limitu czasu wykonywania GET {klucz}

Kilka punktów, które poprawiły naszą sytuację:

Protobuf-net zamiast BinaryFormatter

Polecam używanie protobuf-net, ponieważ zmniejszy to rozmiar wartości, które chcesz przechowywać w pamięci podręcznej.

public interface ICacheDataSerializer
    {
        byte[] Serialize(object o);
        T Deserialize<T>(byte[] stream);
    }

public class ProtobufNetSerializer : ICacheDataSerializer
    {
        public byte[] Serialize(object o)
        {
            using (var memoryStream = new MemoryStream())
            {
                Serializer.Serialize(memoryStream, o);

                return memoryStream.ToArray();
            }
        }

        public T Deserialize<T>(byte[] stream)
        {
            var memoryStream = new MemoryStream(stream);

            return Serializer.Deserialize<T>(memoryStream);
        }
    }

Zaimplementuj strategię ponawiania prób

Zaimplementuj tę RedisCacheTransientErrorDetectionStrategy, aby poradzić sobie z problemami z przekroczeniem limitu czasu.

using Microsoft.Practices.TransientFaultHandling;

public class RedisCacheTransientErrorDetectionStrategy : ITransientErrorDetectionStrategy
    {
        /// <summary>
        /// Custom Redis Transient Error Detenction Strategy must have been implemented to satisfy Redis exceptions.
        /// </summary>
        /// <param name="ex"></param>
        /// <returns></returns>
        public bool IsTransient(Exception ex)
        {
            if (ex == null) return false;

            if (ex is TimeoutException) return true;

            if (ex is RedisServerException) return true;

            if (ex is RedisException) return true;

            if (ex.InnerException != null)
            {
                return IsTransient(ex.InnerException);
            }

            return false;
        }
    }

Utwórz wystąpienie w ten sposób:

private readonly RetryPolicy _retryPolicy;

// CODE
var retryStrategy = new FixedInterval(3, TimeSpan.FromSeconds(2));
            _retryPolicy = new RetryPolicy<RedisCacheTransientErrorDetectionStrategy>(retryStrategy);

Użyj w ten sposób:

var cachedString = _retryPolicy.ExecuteAction(() => dataCache.StringGet(fullCacheKey));

Sprawdź swój kod aby zminimalizować wywołania pamięci podręcznej i wartości, które przechowujesz w pamięci podręcznej. Zmniejszyłem wiele błędów, bardziej efektywnie przechowując wartości.

Jeśli nic z tego nie pomoże. Przejdź do wyższej pamięci podręcznej (skończyło się na użyciu C3 zamiast C1).