Azure Redis Cache - Erreurs multiples TimeoutException :Délai d'attente lors de l'exécution de GET {key}

Quelques points qui ont amélioré notre situation :

Protobuf-net au lieu de BinaryFormatter

Je recommande d'utiliser protobuf-net car cela réduira la taille des valeurs que vous souhaitez stocker dans votre cache.

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);
        }
    }

Mettre en œuvre une stratégie de nouvelle tentative

Implémentez cette RedisCacheTransientErrorDetectionStrategy pour gérer les problèmes de délai d'attente.

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;
        }
    }

Instanciez comme ceci :

private readonly RetryPolicy _retryPolicy;

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

Utilisez comme ceci :

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

Vérifiez votre code pour minimiser les appels de cache et les valeurs que vous stockez dans votre cache. J'ai réduit de nombreuses erreurs en stockant les valeurs plus efficacement.

Si rien de tout cela ne vous aide. Déplacer vers un cache supérieur (nous avons fini par utiliser C3 au lieu de C1).