Crie um provedor de retentativas personalizado para o SqlClient

Aplica-se a: .NET Framework .NET .NET Standard

Baixar ADO.NET

Se os provedores internos de lógica de repetição não atenderem às suas necessidades, você poderá criar seus próprios provedores personalizados. Em seguida, você pode atribuir esses provedores a um objeto SqlConnection ou SqlCommand para aplicar sua lógica personalizada.

Os provedores integrados são projetados em torno de três classes base que você pode estender para implementar um provedor personalizado. Atribua um provedor personalizado a um SqlConnection ou SqlCommand da mesma forma que um provedor embutido:

1. SqlRetryIntervalBaseEnumerator: gera uma sequência de intervalos de tempo.
2. SqlRetryLogicBase: Recupera o próximo intervalo de tempo para um dado enumerador, se o número de tentativas não foi ultrapassado e uma condição transitória for atendida.
3. SqlRetryLogicBaseProvider: aplica a lógica de repetição às operações de conexão e comando.

Exemplo

Este exemplo demonstra os pontos de extensão com uma implementação síncrona mínima. Não está pronto para uso em produção: os métodos assíncronos lançam NotImplementedException, e o provedor não implementa segurança de thread, cancelamento, uso simultâneo nem o evento Retrying. Para uma implementação em produção, consulte a lógica interna de repetição no repositório do GitHub Microsoft.Data.SqlClient.

1. Definir classes de lógica de repetição configurável personalizadas:

   • Enumerador: defina uma sequência fixa de intervalos de tempo e estenda o intervalo aceitável de tempos de dois minutos para quatro 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 repetição: implemente a lógica de repetição em qualquer comando que não faça parte de uma transação ativa. Reduza o número de repetições de 60 para 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;
       }
   }
   

   • Provedor: Implemente um provedor para operações síncronas sem evento Retrying . Trate os números de erro TimeoutException e SqlException configurado como passíveis de nova tentativa.

   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. Crie uma instância de provedor de nova tentativa composta pelos 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;
   }
   

   • Avalie uma exceção em relação aos números de erro configurados e TimeoutException determine se deve tentá-la novamente:

   // 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 a lógica de repetição personalizada:

   • Defina os parâmetros lógicos de repetição:

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

   • Crie um provedor de repetição personalizado:

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

   • Atribua o provedor de nova tentativa ao SqlConnection.RetryLogicProvider ou ao 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();
   

Conteúdo relacionado

• Repositório do GitHub do Microsoft.Data.SqlClient
• Lógica de repetição configurável no SqlClient
• Microsoft. Data.SqlClient para SQL Server