SqlConnection.RetryLogicProvider Propriété

Définition

Espace de noms:

Microsoft.Data.SqlClient

Assembly:

Microsoft.Data.SqlClient.dll

Paquet:

Microsoft.Data.SqlClient v5.2.0

Obtient ou définit une valeur qui spécifie l’objet SqlRetryLogicBaseProvider lié à cette commande.

public:
 property Microsoft::Data::SqlClient::SqlRetryLogicBaseProvider ^ RetryLogicProvider { Microsoft::Data::SqlClient::SqlRetryLogicBaseProvider ^ get(); void set(Microsoft::Data::SqlClient::SqlRetryLogicBaseProvider ^ value); };

public Microsoft.Data.SqlClient.SqlRetryLogicBaseProvider RetryLogicProvider { get; set; }

member this.RetryLogicProvider : Microsoft.Data.SqlClient.SqlRetryLogicBaseProvider with get, set

Public Property RetryLogicProvider As SqlRetryLogicBaseProvider

Valeur de propriété

SqlRetryLogicBaseProvider

Lorsque la valeur est null (valeur par défaut), le fournisseur non retriable par défaut est appliqué.

Remarques

Vous devez définir la valeur de cette propriété avant d’ouvrir la connexion pour prendre effet.

Pour appliquer la logique de nouvelle tentative, effectuez les étapes suivantes avant d’ouvrir la connexion :

1. Définissez les paramètres de configuration à l’aide du SqlRetryLogicOption type.
2. Créez un SqlRetryLogicBaseProvider à l’aide de l’une des méthodes statiques suivantes de la SqlConfigurableRetryFactory classe :
   • CreateFixedRetryProvider
   • CreateIncrementalRetryProvider
   • CreateExponentialRetryProvider
   • CreateNoneRetryProvider
3. Affectez l’objet SqlRetryLogicBaseProvider à la RetryLogicProvider propriété .

Notes

La détection des exceptions pouvant être retentées est une partie essentielle du modèle de nouvelle tentative. Avant d’appliquer la logique de nouvelle tentative, il est important d’examiner les exceptions et de choisir un fournisseur de nouvelles tentatives qui correspond le mieux à votre scénario. Tout d’abord, consignez vos exceptions et recherchez les erreurs temporaires.

Notes

Le délai d’expiration de la connexion redémarre pour chaque exécution d’une connexion ouverte. Il n’y a pas de chevauchement de temps entre ces deux actions.

Notes

Le fournisseur logique de nouvelle tentative par défaut n’est pas activé, sauf s’il est configuré dans un fichier de configuration d’application. Pour plus d’informations, consultez Logique de nouvelle tentative configurable et fichier de configuration.

Exemple

L’exemple suivant tente d’ouvrir une connexion à une base de données non valide pour simuler une condition selon laquelle le service de base de données est temporairement indisponible. Vous devez créer manuellement la base de données pendant que le SqlConnection tente d’établir la connexion.

using Microsoft.Data.SqlClient;

/// Detecting retriable exceptions is a vital part of the retry pattern.
/// Before applying retry logic it is important to investigate exceptions and choose a retry provider that best fits your scenario.
/// First, log your exceptions and find transient faults.
/// The purpose of this sample is to illustrate how to use this feature and the condition might not be realistic.
class RetryLogicSample
{
    private const string DefaultDB = "Northwind";
    private const string CnnStringFormat = "Server=localhost; Initial Catalog={0}; Integrated Security=true; pooling=false;";
    private const string DropDatabaseFormat = "DROP DATABASE {0}";

    // For general use
    private static SqlConnection s_generalConnection = new SqlConnection(string.Format(CnnStringFormat, DefaultDB));

    static void Main(string[] args)
    {
        // 1. Define the retry logic parameters
        var options = new SqlRetryLogicOption()
        {
            NumberOfTries = 5,
            MaxTimeInterval = TimeSpan.FromSeconds(20),
            DeltaTime = TimeSpan.FromSeconds(1)
        };

        // 2. Create a retry provider
        var provider = SqlConfigurableRetryFactory.CreateExponentialRetryProvider(options);

        // define the retrying event to report the execution attempts
        provider.Retrying += (object s, SqlRetryingEventArgs e) =>
            {
                int attempts = e.RetryCount + 1;
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"attempt {attempts} - current delay time:{e.Delay} \n");
                Console.ForegroundColor = ConsoleColor.DarkGray;
                if (e.Exceptions[e.Exceptions.Count - 1] is SqlException ex)
                {
                    Console.WriteLine($"{ex.Number}-{ex.Message}\n");
                }
                else
                {
                    Console.WriteLine($"{e.Exceptions[e.Exceptions.Count - 1].Message}\n");
                }

                // It is not a good practice to do time-consuming tasks inside the retrying event which blocks the running task.
                // Use parallel programming patterns to mitigate it.
                if (e.RetryCount == provider.RetryLogic.NumberOfTries - 1)
                {
                    Console.WriteLine("This is the last chance to execute the command before throwing the exception.");
                    Console.WriteLine("Press Enter when you're ready:");
                    Console.ReadLine();
                    Console.WriteLine("continue ...");
                }
            };

        // Open the general connection.
        s_generalConnection.Open();

        try
        {
            // Assume the database is being created and other services are going to connect to it.
            RetryConnection(provider);
        }
        catch
        {
            // exception is thrown if connecting to the database isn't successful.
            throw;
        }
    }

    private static void ExecuteCommand(SqlConnection cn, string command)
    {
        using var cmd = cn.CreateCommand();
        cmd.CommandText = command;
        cmd.ExecuteNonQuery();
    }

    private static void RetryConnection(SqlRetryLogicBaseProvider provider)
    {
        // Change this if you already have a database with the same name in your database.
        string dbName = "Invalid_DB_Open";

        // Create a connection to an invalid database.
        using var cnn = new SqlConnection(string.Format(CnnStringFormat, dbName));
        // 3. Assign the `provider` to the connection
        cnn.RetryLogicProvider = provider;
        Console.WriteLine($"Connecting to the [{dbName}] ...");
        // Manually execute the following command in SSMS to create the invalid database while the SqlConnection is attempting to connect to it.
        // >> CREATE DATABASE Invalid_DB_Open;
        Console.WriteLine($"Manually, run the 'CREATE DATABASE {dbName};' in the SQL Server before exceeding the {provider.RetryLogic.NumberOfTries} attempts.");
        // the connection tries to connect to the database 5 times
        Console.WriteLine("The first attempt, before getting into the retry logic.");
        cnn.Open();
        Console.WriteLine($"Connected to the [{dbName}] successfully.");

        cnn.Close();

        // Drop it after test
        ExecuteCommand(s_generalConnection, string.Format(DropDatabaseFormat, dbName));
        Console.WriteLine($"The [{dbName}] is removed.");
    }
}