Détection des changements avec SqlDependency

Télécharger ADO.NET

Un objet SqlDependency peut être associé à une SqlCommand pour détecter si les résultats de requête diffèrent de ceux qui ont été récupérés à l’origine. Vous pouvez également attribuer un délégué à l’événement OnChange, qui se déclenche lorsque les résultats changent pour une commande associée. Associez SqlDependency à la commande avant d’exécuter la commande. La propriété HasChanges de la SqlDependency peut également être utilisée pour déterminer si les résultats de la requête ont changé depuis la première récupération des données.

Considérations relatives à la sécurité

L’infrastructure de dépendance repose sur une SqlConnection qui est ouverte quand Start est appelé pour recevoir des notifications de changement des données sous-jacentes pour une commande donnée. La possibilité pour un client de lancer l’appel à SqlDependency.Start est contrôlée à l’aide de SqlClientPermission et des attributs de sécurité d’accès du code. Pour plus d’informations, consultez Activation de notifications de requête.

Exemple

Les étapes suivantes montrent comment déclarer une dépendance, exécuter une commande et recevoir une notification lorsque le jeu de résultats change :

1. Établit une connexion SqlDependency au serveur.

2. Créez des objets SqlConnection et SqlCommand pour vous connecter au serveur et définir une instruction Transact-SQL.

3. Créez un objet SqlDependency ou utilisez un objet existant, puis liez-le à l’objet SqlCommand. En interne, cette association crée un objet SqlNotificationRequest et le lie à l’objet de commande en fonction des besoins. Cette requête de notification contient un identificateur interne qui identifie de façon unique cet objet SqlDependency. L’écouteur client est également démarré s’il n’est pas déjà actif.

4. Abonnez un gestionnaire d’événements à l’événement OnChange de l’objet SqlDependency.

5. Exécutez la commande à l’aide de l’une des méthodes Execute de l’objet SqlCommand. Étant donné que la commande est liée à l’objet de notification, le serveur reconnaît qu’il doit générer une notification, et les informations de la file d’attente pointent vers la file d’attente des dépendances.

6. Arrêtez la connexion SqlDependency au serveur.

Si un utilisateur change ensuite les données sous-jacentes, Microsoft SQL Server détecte qu’une notification est en attente concernant ce changement. Il publie alors une notification qui est traitée et transférée au client via la SqlConnection sous-jacente qui a été créée en appelant SqlDependency.Start. L’écouteur client reçoit le message d’invalidation. L’écouteur client localise ensuite l’objet SqlDependency associé et déclenche l’événement OnChange.

Le fragment de code suivant montre le modèle de conception que vous utiliseriez pour créer un exemple d’application.

void Initialization()
{
    // Create a dependency connection.
    SqlDependency.Start(connectionString, queueName);
}

void SomeMethod()
{
    // Assume connection is an open SqlConnection.

    // Create a new SqlCommand object.
    using (SqlCommand command=new SqlCommand(
        "SELECT ShipperID, CompanyName, Phone FROM dbo.Shippers",
        connection))
    {

        // Create a dependency and associate it with the SqlCommand.
        SqlDependency dependency=new SqlDependency(command);
        // Maintain the reference in a class member.

        // Subscribe to the SqlDependency event.
        dependency.OnChange+=new
           OnChangeEventHandler(OnDependencyChange);

        // Execute the command.
        using (SqlDataReader reader = command.ExecuteReader())
        {
            // Process the DataReader.
        }
    }
}

// Handler method
void OnDependencyChange(object sender,
   SqlNotificationEventArgs e )
{
  // Handle the event (for example, invalidate this cache entry).
}

void Termination()
{
    // Release the dependency.
    SqlDependency.Stop(connectionString, queueName);
}

Étapes suivantes

• Notifications de requête dans SQL Server