Stwórz niestandardowego dostawcy powtórek dla SqlClient

Dotyczy: .NET Framework .NET Standard

Pobieranie ADO.NET

Jeśli wbudowani dostawcy logiki ponawiania nie spełniają Twoich wymagań, możesz utworzyć własnych niestandardowych dostawców. Następnie możesz przypisać tych dostawców do obiektu SqlConnection lub SqlCommand, aby zastosować własną logikę.

Wbudowani dostawcy są oparci na trzech klasach bazowych, które można rozszerzyć, aby zaimplementować niestandardowego dostawcę. Przypisz niestandardowego dostawcę do elementu SqlConnection lub SqlCommand w taki sam sposób jak dostawcę wbudowanego:

1. SqlRetryIntervalBaseEnumerator: generuje sekwencję interwałów czasu.
2. SqlRetryLogicBase: Pobiera kolejny przedział czasu dla danego enumeratora, jeśli nie przekroczono liczby ponowień i występuje stan przejściowy.
3. SqlRetryLogicBaseProvider: stosuje logikę ponawiania prób do operacji połączenia i poleceń.

Example

Ten przykład demonstruje punkty rozszerzenia przy minimalnej synchronicznej implementacji. Nie nadaje się jeszcze do użycia produkcyjnego: metody asynchroniczne zgłaszają NotImplementedException, a dostawca nie obsługuje bezpieczeństwa wątkowego, anulowania, użycia współbieżnego ani zdarzenia Retrying. W przypadku wdrożenia produkcyjnego zapoznaj się z wbudowaną logiką ponawiania prób w repozytorium GitHub Microsoft.Data.SqlClient GitHub repository.

1. Zdefiniuj niestandardowe konfigurowalne klasy logiki ponawiania prób:

   • Moduł wyliczający: zdefiniuj stałą sekwencję interwałów czasu i rozszerz akceptowalny zakres czasu od dwóch minut do czterech minut.

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

   • Logika ponawiania: zaimplementuj logikę ponawiania prób dla dowolnego polecenia, które nie jest częścią aktywnej transakcji. Obniż liczbę ponownych prób z zakresu od 60 do 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;
       }
   }
   

   • Dostawca: Zaimplementuj dostawcę dla operacji synchronicznych bez zdarzenia Retrying. Traktuj TimeoutException i skonfigurowane numery błędów SqlException jako podlegające ponowieniu.

   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. Utwórz instancję dostawcy ponowień składającą się ze zdefiniowanych typów niestandardowych:

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

   • Oceń wyjątek na podstawie skonfigurowanych numerów błędów i TimeoutException, aby ustalić, czy należy ponowić próbę jego wykonania:

   // 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. Użyj dostosowanej logiki ponawiania prób:

   • Zdefiniuj parametry logiki ponawiania prób:

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

   • Utwórz niestandardowego dostawcę ponawiania prób:

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

   • Przypisz dostawcę ponawiania prób do elementu SqlConnection.RetryLogicProvider lub 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();
   

Treści powiązane

• Repozytorium GitHub Microsoft.Data.SqlClient
• Konfigurowalna logika ponawiania prób w programie SqlClient
• Microsoft. Data.SqlClient for SQL Server