API de núcleo de la lógica de reintento configurables en SqlClient

Se aplica a: .NET Framework .NET .NET Standard

Descargar ADO.NET

Si los proveedores de lógica de reintento integrados no cubren sus necesidades, puede crear sus propios proveedores personalizados. Después, puede asignar esos proveedores a un objeto SqlConnection o SqlCommand para aplicar la lógica personalizada.

Los proveedores integrados se diseñan en torno a tres interfaces que se pueden usar para implementar proveedores personalizados. Los proveedores de reintento personalizados se pueden usar de la misma manera que los proveedores de reintento internos en SqlConnection o SqlCommand:

1. SqlRetryIntervalBaseEnumerator: genera una secuencia de intervalos de tiempo.
2. SqlRetryLogicBase: recupera el siguiente intervalo de tiempo para un enumerador determinado si no se ha superado el número de reintentos y se cumple una condición transitoria.
3. SqlRetryLogicBaseProvider: aplica la lógica de reintento a las operaciones de conexión y comando.

Ejemplo

La implementación de este ejemplo se ha realizado de la manera más sencilla posible para mostrar la personalización paso a paso. No incluye procedimientos avanzados como la seguridad para subprocesos, asincronía y simultaneidad. Para profundizar en una implementación real, puede estudiar la lógica de reintento predefinida en el repositorio de GitHub de Microsoft.Data.SqlClient.

1. Defina las clases de lógica de reintento configurables personalizadas:

   • Enumerador: define una secuencia fija de intervalos de tiempo y amplíe el rango de tiempo aceptable de dos a cuatro minutos.

   public class CustomEnumerator : SqlRetryIntervalBaseEnumerator
   {
       // Set the maximum acceptable time to 4 minutes
       private readonly TimeSpan _maxValue = TimeSpan.FromMinutes(4);
   
       public CustomEnumerator(TimeSpan timeInterval, TimeSpan maxTime, TimeSpan minTime)
           : base(timeInterval, maxTime, minTime) {}
   
       // Return fixed time on each request
       protected override TimeSpan GetNextInterval()
       {
           return GapTimeInterval;
       }
   
       // Override the validate method with the new time range validation
       protected override void Validate(TimeSpan timeInterval, TimeSpan maxTimeInterval, TimeSpan minTimeInterval)
       {
           if (minTimeInterval < TimeSpan.Zero || minTimeInterval > _maxValue)
           {
               throw new ArgumentOutOfRangeException(nameof(minTimeInterval));
           }
   
           if (maxTimeInterval < TimeSpan.Zero || maxTimeInterval > _maxValue)
           {
               throw new ArgumentOutOfRangeException(nameof(maxTimeInterval));
           }
   
           if (timeInterval < TimeSpan.Zero || timeInterval > _maxValue)
           {
               throw new ArgumentOutOfRangeException(nameof(timeInterval));
           }
   
           if (maxTimeInterval < minTimeInterval)
           {
               throw new ArgumentOutOfRangeException(nameof(minTimeInterval));
           }
       }
   }
   

   • Lógica de reintento: implementa la lógica de reintento en cualquier comando que no forme parte de una transacción activa. Reduzca el número de reintentos de 60 a 20.

   public class CustomRetryLogic : SqlRetryLogicBase
   {
       // Maximum number of attempts
       private const int maxAttempts = 20;
   
       public CustomRetryLogic(int numberOfTries,
                                SqlRetryIntervalBaseEnumerator enumerator,
                                Predicate<Exception> transientPredicate)
       {
           if (!(numberOfTries > 0 && numberOfTries <= maxAttempts))
           {
               // 'numberOfTries' should be between 1 and 20.
               throw new ArgumentOutOfRangeException(nameof(numberOfTries));
           }
   
           // Assign parameters to the relevant properties
           NumberOfTries = numberOfTries;
           RetryIntervalEnumerator = enumerator;
           TransientPredicate = transientPredicate;
           Current = 0;
       }
   
       // Prepare this object for the next round
       public override void Reset()
       {
           Current = 0;
           RetryIntervalEnumerator.Reset();
       }
   
       public override bool TryNextInterval(out TimeSpan intervalTime)
       {
           intervalTime = TimeSpan.Zero;
           // First try has occurred before starting the retry process. 
           // Check if retry is still allowed
           bool result = Current < NumberOfTries - 1;
   
           if (result)
           {
               // Increase the number of attempts
               Current++;
               // It's okay if the RetryIntervalEnumerator gets to the last value before we've reached our maximum number of attempts.
               // MoveNext() will simply leave the enumerator on the final interval value and we will repeat that for the final attempts.
               RetryIntervalEnumerator.MoveNext();
               // Receive the current time from enumerator
               intervalTime = RetryIntervalEnumerator.Current;
           }
           return result;
       }
   }
   

   • Proveedor: implementa un proveedor de reintento que vuelve a intentar realizar operaciones sincrónicas sin un evento Retrying. Agrega TimeoutException a los números de error de excepción transitoria SqlException existentes.

   public class CustomProvider : SqlRetryLogicBaseProvider
   {
       // Preserve the given retryLogic on creation
       public CustomProvider(SqlRetryLogicBase retryLogic)
       {
           RetryLogic = retryLogic;
       }
   
       public override TResult Execute<TResult>(object sender, Func<TResult> function)
       {
           // Create a list to save transient exceptions to report later if necessary
           IList<Exception> exceptions = new List<Exception>();
           // Prepare it before reusing
           RetryLogic.Reset();
           // Create an infinite loop to attempt the defined maximum number of tries
           do
           {
               try
               {
                   // Try to invoke the function
                   return function.Invoke();
               }
               // Catch any type of exception for further investigation
               catch (Exception e)
               {
                   // Ask the RetryLogic object if this exception is a transient error
                   if (RetryLogic.TransientPredicate(e))
                   {
                       // Add the exception to the list of exceptions we've retried on
                       exceptions.Add(e);
                       // Ask the RetryLogic for the next delay time before the next attempt to run the function
                       if (RetryLogic.TryNextInterval(out TimeSpan gapTime))
                       {
                           Console.WriteLine($"Wait for {gapTime} before next try");
                           // Wait before next attempt
                           Thread.Sleep(gapTime);
                       }
                       else
                       {
                           // Number of attempts has exceeded the maximum number of tries
                           throw new AggregateException("The number of retries has exceeded the maximum number of attempts.", exceptions);
                       }
                   }
                   else
                   {
                       // If the exception wasn't a transient failure throw the original exception
                       throw;
                   }
               }
           } while (true);
       }
   
       public override Task<TResult> ExecuteAsync<TResult>(object sender, Func<Task<TResult>> function, CancellationToken cancellationToken = default)
       {
           throw new NotImplementedException();
       }
   
       public override Task ExecuteAsync(object sender, Func<Task> function, CancellationToken cancellationToken = default)
       {
           throw new NotImplementedException();
       }
   }
   

2. Crea una instancia de proveedor de reintento que consta de los tipos personalizados definidos:

   public static SqlRetryLogicBaseProvider CreateCustomProvider(SqlRetryLogicOption options)
   {
       // 1. create an enumerator instance
       CustomEnumerator customEnumerator = new CustomEnumerator(options.DeltaTime, options.MaxTimeInterval, options.MinTimeInterval);
       // 2. Use the enumerator object to create a new RetryLogic instance
       CustomRetryLogic customRetryLogic = new CustomRetryLogic(5, customEnumerator, (e) => TransientErrorsCondition(e, options.TransientErrors));
       // 3. Create a provider using the RetryLogic object
       CustomProvider customProvider = new CustomProvider(customRetryLogic);
       return customProvider;
   }
   

   • La siguiente función evaluará una excepción mediante la lista proporcionada de excepciones que se pueden reintentar y la excepción TimeoutException especial para determinar si se puede reintentar:

   // Return true if the exception is a transient fault.
   private static bool TransientErrorsCondition(Exception e, IEnumerable<int> retriableConditions)
   {
       bool result = false;
   
       // Assess only SqlExceptions
       if (retriableConditions != null && e is SqlException ex)
       {
           foreach (SqlError item in ex.Errors)
           {
               // Check each error number to see if it is a retriable error number
               if (retriableConditions.Contains(item.Number))
               {
                   result = true;
                   break;
               }
           }
       }
       // Other types of exceptions can also be assessed
       else if (e is TimeoutException)
       {
           result = true;
       }
       return result;
   }
   

3. Use la lógica de reintento personalizada:

   • Defina los parámetros de la lógica de reintento:

   // Define the retry logic parameters
   var options = new SqlRetryLogicOption()
   {
       // Tries 5 times before throwing an exception
       NumberOfTries = 5,
       // Preferred gap time to delay before retry
       DeltaTime = TimeSpan.FromSeconds(1),
       // Maximum gap time for each delay time before retry
       MaxTimeInterval = TimeSpan.FromSeconds(20),
       // SqlException retriable error numbers
       TransientErrors = new int[] { 4060, 1024, 1025}
   };
   

   • Cree un proveedor personalizado:

   // Create a custom retry logic provider
   SqlRetryLogicBaseProvider provider = CustomRetry.CreateCustomProvider(options);
   

   • Asigne el proveedor de reintento a SqlConnection.RetryLogicProvider o SqlCommand.RetryLogicProvider:

   // Assumes that connection is a valid SqlConnection object 
   // Set the retry logic provider on the connection instance
   connection.RetryLogicProvider = provider;
   // Establishing the connection will trigger retry if one of the given transient failure occurs.
   connection.Open();
   

Vea también

• Repositorio de GitHub Microsoft.Data.SqlClient
• Lógica de reintento configurable en SqlClient
• Microsoft ADO.NET para SQL Server