Delen via

Wijzigingen detecteren met SqlDependency

  • Artikel

Een SqlDependency object kan worden gekoppeld aan een SqlCommand om te detecteren wanneer queryresultaten verschillen van diegene die oorspronkelijk zijn opgehaald. U kunt ook een gemachtigde toewijzen aan de OnChange gebeurtenis, die wordt geactiveerd wanneer de resultaten voor een bijbehorende opdracht worden gewijzigd. U moet de SqlDependency opdracht aan de opdracht koppelen voordat u de opdracht uitvoert. De HasChanges eigenschap van de SqlDependency functie kan ook worden gebruikt om te bepalen of de queryresultaten zijn gewijzigd sinds de gegevens voor het eerst zijn opgehaald.

Beveiligingsoverwegingen

De afhankelijkheidsinfrastructuur is afhankelijk van een SqlConnection die wordt geopend wanneer Start deze wordt aangeroepen om meldingen te ontvangen die de onderliggende gegevens voor een bepaalde opdracht hebben gewijzigd. De mogelijkheid voor een client om de aanroep naar te SqlDependency.Start initiëren, wordt beheerd door het gebruik van SqlClientPermission en codetoegangsbeveiligingskenmerken. Zie Querymeldingen inschakelen en Beveiliging voor codetoegang en ADO.NET voor meer informatie.

Opmerking

De volgende stappen laten zien hoe u een afhankelijkheid declareert, een opdracht uitvoert en een melding ontvangt wanneer de resultatenset wordt gewijzigd:

  1. Start een SqlDependency verbinding met de server.

  2. Maak SqlConnection en SqlCommand objecten om verbinding te maken met de server en definieer een Transact-SQL-instructie.

  3. Maak een nieuw SqlDependency object of gebruik een bestaand object en bind het aan het SqlCommand object. Intern wordt er een SqlNotificationRequest object gemaakt en wordt het indien nodig gekoppeld aan het opdrachtobject. Deze meldingsaanvraag bevat een interne id die dit SqlDependency object uniek identificeert. De clientlistener wordt ook gestart als deze nog niet actief is.

  4. Abonneer een gebeurtenis-handler op de OnChange gebeurtenis van het SqlDependency object.

  5. Voer de opdracht uit met behulp van een van de Execute methoden van het SqlCommand object. Omdat de opdracht is gebonden aan het meldingsobject, herkent de server dat er een melding moet worden gegenereerd. De wachtrijgegevens verwijzen naar de wachtrijafhankelijkhedenwachtrij.

  6. Stop de SqlDependency verbinding met de server.

Als een gebruiker vervolgens de onderliggende gegevens wijzigt, detecteert Microsoft SQL Server dat er een melding in behandeling is voor een dergelijke wijziging en plaatst een melding die wordt verwerkt en doorgestuurd naar de client via de onderliggende SqlConnection gegevens die zijn gemaakt door aan te roepen SqlDependency.Start. De clientlistener ontvangt het ongeldige bericht. De clientlistener zoekt vervolgens het bijbehorende SqlDependency object en de gebeurtenis wordt OnChange geactiveerd.

In het volgende codefragment ziet u het ontwerppatroon dat u zou gebruiken om een voorbeeldtoepassing te maken.

Sub Initialization()
    ' Create a dependency connection.
    SqlDependency.Start(connectionString, queueName)
End Sub

Sub SomeMethod()
    ' Assume connection is an open SqlConnection.
    ' Create a new SqlCommand object.
    Using command As New SqlCommand( _
      "SELECT ShipperID, CompanyName, Phone FROM dbo.Shippers", _
      connection)

        ' Create a dependency and associate it with the SqlCommand.
        Dim dependency As New SqlDependency(command)
        ' Maintain the reference in a class member.
        ' Subscribe to the SqlDependency event.
        AddHandler dependency.OnChange, AddressOf OnDependencyChange

        ' Execute the command.
        Using reader = command.ExecuteReader()
            ' Process the DataReader.
        End Using
    End Using
End Sub

' Handler method
Sub OnDependencyChange(ByVal sender As Object, _
    ByVal e As SqlNotificationEventArgs)
    ' Handle the event (for example, invalidate this cache entry).
End Sub

Sub Termination()
    ' Release the dependency
    SqlDependency.Stop(connectionString, queueName)
End Sub

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

Zie ook