Freigeben über

Exemplarische Vorgehensweise: Erweitern des Caches für lokale Datenbanken zur Unterstützung der bidirektionalen Synchronisierung

  • Artikel

In Visual Studio 2008 konfiguriert der Cache für lokale Datenbanken eine SQL Server Compact-Datenbank und eine Gruppe partieller Klassen, mit denen Sync Framework aktiviert wird. Da mit Visual Studio partielle Klassen generiert werden, können Sie Code zum Hinzufügen von Synchronisierungsfunktionen schreiben und haben dennoch die Möglichkeit, Einstellungen im Dialogfeld Datensynchronisierung konfigurieren anzuzeigen und zu ändern. Weitere Informationen zum Cache für lokale Datenbanken und zu partiellen Klassen finden Sie in der Visual Studio 2008-Dokumentation.

Standardmäßig ermöglicht das Dialogfeld Datensynchronisierung konfigurieren die Konfiguration von Sync Framework ausschließlich für Downloadszenarien. Das bedeutet, dass nach der Konfiguration der Datensynchronisierung beim Aufrufen von Synchronize nur Änderungen vom Server in die Clientdatenbank heruntergeladen werden. Eine der üblichsten Methoden für die Erweiterung des Synchronisierungscodes besteht darin, eine bidirektionale Synchronisierung zu konfigurieren. Auf diese Weise können Änderungen vom Client auf den Server hochgeladen werden. Es empfiehlt sich, zum Aktivieren der bidirektionalen Synchronisierung den generierten Code wie im Folgenden dargestellt zu erweitern:

  • Festlegen der Synchronisierungsrichtung als bidirektional

  • Hinzufügen von Code zum Beheben von Synchronisierungskonflikten

  • Entfernen von Spalten für die Serverüberwachung aus den Synchronisierungsbefehlen

Hinweis

Visual Studio 2008 verwendet Sync Framework für ADO.NET 1.0, wenn es Code für Cache für lokale Datenbanken erstellt.

Vorbereitungsmaßnahmen

Bevor Sie mit dieser exemplarischen Vorgehensweise beginnen, müssen Sie folgende exemplarische Vorgehensweise in der Visual Studio 2008-Dokumentation abgeschlossen haben: "Exemplarische Vorgehensweise: Erstellen einer gelegentlich verbundenen Anwendung". Nachdem Sie diese exemplarische Vorgehensweise abgeschlossen haben, verfügen Sie über ein Projekt mit einem Cache für lokale Datenbanken und eine Windows Form-Anwendung, mit der Sie Änderungen aus der "Northwind Customers"-Tabelle in eine SQL Server Compact-Datenbank herunterladen können. Es sind nun alle Voraussetzungen erfüllt, um diese Projektmappe der exemplarischen Vorgehensweise zu laden und bidirektionale Funktionen hinzuzufügen.

So öffnen Sie die Projektmappe OCSWalkthrough

  1. Öffnen Sie Visual Studio.

  2. Öffnen Sie im Menü Datei eine vorhandene Projektmappe oder ein vorhandenes Projekt, und suchen Sie die Projektmappe OCSWalkthrough. Dies ist die Datei OCSWalkthrough.sln.

Festlegen der Synchronisierungsrichtung

Im Dialogfeld Datensynchronisierung konfigurieren ist die SyncDirection-Eigenschaft auf DownloadOnly oder Snapshot festgelegt. Legen Sie die SyncDirection-Eigenschaft zum Aktivieren der bidirektionalen Synchronisierung für jede Tabelle, aus der Änderungen hochgeladen werden sollen, auf Bidirectional fest.

So legen Sie die Synchronisierungsrichtung fest

  1. Klicken Sie mit der rechten Maustaste auf NorthwindCache.sync, und wählen Sie Code anzeigen. Wenn diese Aktion zum ersten Mal ausgeführt wird, erstellt Visual Studio eine NorthwindCache-Klassendatei unter dem Knoten NorthwindCache.sync im Projektmappen-Explorer. Diese Datei enthält eine partielle NorthwindCacheSyncAgent-Klasse, und Sie können nach Bedarf weitere Klassen hinzufügen.

  2. Fügen Sie der NorthwindCacheSyncAgent.OnInitialized()-Methode in der NorthwindCache-Klassendatei eine Codezeile hinzu:

    public partial class NorthwindCacheSyncAgent 
{   
    partial void OnInitialized()
    {
        this.Customers.SyncDirection = 
            Microsoft.Synchronization.Data.SyncDirection.Bidirectional;
    }
}

    Partial Public Class NorthwindCacheSyncAgent

    Partial Sub OnInitialized()

        Me.Customers.SyncDirection = Microsoft.Synchronization.Data.SyncDirection.Bidirectional

    End Sub

End Class

  3. Öffnen Sie im Code-Editor Form1.

  4. Bearbeiten Sie in der Datei Form1 die Codezeile im SynchronizeButton_Click-Ereignishandler so, dass Upload- und Downloadstatistiken einbezogen werden:

    MessageBox.Show("Changes downloaded: " +
    syncStats.TotalChangesDownloaded.ToString() + 
    Environment.NewLine +
    "Changes uploaded: " + syncStats.TotalChangesUploaded.ToString());

        MessageBox.Show("Changes downloaded: " & _
syncStats.TotalChangesDownloaded.ToString & Environment.NewLine & "Changes uploaded: " & _
syncStats.TotalChangesUploaded.ToString)

So synchronisieren Sie Statistiken und zeigen sie an

  1. Drücken Sie F5.

  2. Aktualisieren Sie im Formular einen Datensatz, und klicken Sie dann auf der Symbolleiste auf die Schaltfläche Speichern.

  3. Klicken Sie auf Jetzt synchronisieren.

  4. Ein Meldungsfeld mit Informationen zu synchronisierten Datensätzen wird angezeigt. Aus den Statistiken geht hervor, dass jeweils eine Zeile hochgeladen und heruntergeladen wurde, obwohl auf dem Server keine Änderungen vorgenommen wurden. Der zusätzliche Download erfolgt, da die Änderungen des Clients wieder an diesen zurückgegeben werden, nachdem sie auf dem Server angewendet wurden. Weitere Informationen dazu finden Sie im Abschnitt "Identifizieren des Clients, der eine Datenänderung vorgenommen hat" unter Vorgehensweise: Verwenden eines benutzerdefinierten Systems zur Änderungsnachverfolgung.

  5. Klicken Sie auf OK, um das Meldungsfeld zu schließen, beenden Sie jedoch nicht die Anwendung.

So synchronisieren Sie die Konfliktauflösung und zeigen sie an

  1. Aktualisieren Sie im Formular einen Datensatz, und klicken Sie dann auf die Schaltfläche Speichern.

  2. Verwenden Sie bei ausgeführter Anwendung Server-Explorer/Datenbank-Explorer (oder ein anderes Tool zur Datenbankverwaltung), um eine Verbindung mit der Serverdatenbank herzustellen.

  3. Aktualisieren Sie zur Veranschaulichung des Standardverhaltens für die Konfliktauflösung in Server-Explorer/Datenbank-Explorer den bereits im Formular aktualisierten Datensatz mit einem anderen Wert, und führen Sie einen Commit für die Änderung aus. (Verlassen Sie die geänderte Zeile.)

  4. Kehren Sie zum Formular zurück, und klicken Sie auf Jetzt synchronisieren.

  5. Überprüfen Sie die Aktualisierung im Anwendungsraster und in der Serverdatenbank. Beachten Sie hierbei, dass die von Ihnen vorgenommene Aktualisierung des Servers die Aktualisierung des Clients überschrieben hat. Informationen zum Ändern dieses Konfliktauflösungsverhaltens finden Sie im nächsten Abschnitt dieses Themas: "Hinzufügen von Code zum Beheben von Synchronisierungskonflikten".

Hinzufügen von Code zum Beheben von Synchronisierungskonflikten

In Sync Framework befindet sich eine Zeile in Konflikt, wenn sie zwischen zwei Synchronisierungen sowohl auf dem Client als auch auf dem Server geändert wurde. Sync Framework stellt mehrere Funktionen bereit, mit denen Konflikte erkannt und aufgelöst werden können. In dieser exemplarischen Vorgehensweise fügen Sie eine grundlegende Behandlung für Konflikte hinzu, bei denen dieselbe Zeile auf dem Client und dem Server aktualisiert wurde. Andere Konfliktarten treten beispielsweise auf, wenn eine Zeile in einer Datenbank gelöscht und in einer anderen Datenbank aktualisiert wird oder Zeilen mit doppelten Primärschlüsseln in beide Datenbanken eingefügt werden. Weitere Informationen zum Ermitteln und Auflösen von Konflikten finden Sie unter Vorgehensweise: Behandeln von Datenkonflikten und Fehlern.

So fügen Sie die Konfliktbehandlung hinzu

  • Fügen Sie Code zur Behandlung des ApplyChangeFailed-Serverereignisses und des ApplyChangeFailed-Clientereignisses hinzu. Diese Ereignisse werden ausgelöst, wenn eine Zeile aufgrund eines Konflikts oder eines Fehlers nicht übernommen werden kann. Mit den Methoden zur Behandlung dieser Ereignisse im Beispielcode wird überprüft, um welchen Konflikt es sich handelt. In ihnen ist angegeben, dass Konflikte zwischen einer Clientaktualisierung und einer Serveraktualisierung aufgelöst werden, indem das Schreiben der Clientänderung in die Serverdatenbank erzwungen wird. Der Synchronisierungsbefehl zum Übernehmen von Aktualisierungen in die Serverdatenbank verwendet Logik, um erkennen zu können, wann eine Änderung erzwungen werden soll. Dieser Befehl ist im Code des nächsten Abschnitts dieses Themas enthalten: "Entfernen von Spalten für die Serverüberwachung aus den Synchronisierungsbefehlen".

    Hinweis

    Der Beispielcode stellt ein grundlegendes Beispiel der Konfliktbehandlung dar. Wie Konflikte behandelt werden, ist von den Erfordernissen Ihrer Anwendung und Geschäftslogik abhängig.

    Das Hinzufügen von Code für C# unterscheidet sich von Visual Basic:

    • Fügen Sie für C# Code zu NorthwindCache.cs und Form1.cs hinzu. Fügen Sie in NorthwindCache.cs am Ende der NorthwindCacheSyncAgent-Klasse folgenden Code hinzu:

      public partial class NorthwindCacheServerSyncProvider
{

    partial void OnInitialized()
    {
        this.ApplyChangeFailed +=
            new System.EventHandler<Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs>
            (NorthwindCacheServerSyncProvider_ApplyChangeFailed);
    }

    private void NorthwindCacheServerSyncProvider_ApplyChangeFailed(object sender,
        Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs e)
    {

    if (e.Conflict.ConflictType ==
        Microsoft.Synchronization.Data.ConflictType.ClientUpdateServerUpdate)
        {

        //Resolve a client update / server update conflict by force writing
        //the client change to the server database.
        System.Windows.Forms.MessageBox.Show("A client update / server update conflict " +
                                                "was detected at the server.");
        e.Action = Microsoft.Synchronization.Data.ApplyAction.RetryWithForceWrite;

        }

    }
}

public partial class NorthwindCacheClientSyncProvider
{

    public void AddHandlers()
    {
        this.ApplyChangeFailed +=
            new System.EventHandler<Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs>
            (NorthwindCacheClientSyncProvider_ApplyChangeFailed);
    }

    private void NorthwindCacheClientSyncProvider_ApplyChangeFailed(object sender,
        Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs e)
    {

        if (e.Conflict.ConflictType ==
            Microsoft.Synchronization.Data.ConflictType.ClientUpdateServerUpdate)
        {

            //Resolve a client update / server update conflict by keeping the 
            //client change.
            e.Action = Microsoft.Synchronization.Data.ApplyAction.Continue;

        }

    }
}

      Bearbeiten Sie in Form1.cs den Code im SynchronizeButton_Click-Ereignishandler so, dass die AddHandlers-Methode aufgerufen wird, die Sie im vorhergehenden Schritt NorthwindCache.cs hinzugefügt haben:

      NorthwindCacheSyncAgent syncAgent = new NorthwindCacheSyncAgent();

NorthwindCacheClientSyncProvider clientSyncProvider =
    (NorthwindCacheClientSyncProvider)syncAgent.LocalProvider;
clientSyncProvider.AddHandlers();

Microsoft.Synchronization.Data.SyncStatistics syncStats = 
    syncAgent.Synchronize();

    • Fügen Sie für Visual Basic den folgenden Code in NorthwindCache.vb am Ende der End Class-Anweisung für die NorthwindCacheSyncAgent-Klasse hinzu.

      Partial Public Class NorthwindCacheServerSyncProvider

    Private Sub NorthwindCacheServerSyncProvider_ApplyChangeFailed( _
        ByVal sender As Object, ByVal e As  _
        Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs) _
        Handles Me.ApplyChangeFailed

        If e.Conflict.ConflictType = _
            Microsoft.Synchronization.Data.ConflictType.ClientUpdateServerUpdate Then

            'Resolve a client update / server update conflict by force writing
            'the client change to the server database.
            MessageBox.Show("A client update / server update conflict was detected at the server.")
            e.Action = Microsoft.Synchronization.Data.ApplyAction.RetryWithForceWrite

        End If

    End Sub

End Class

Partial Public Class NorthwindCacheClientSyncProvider

    Private Sub NorthwindCacheClientSyncProvider_ApplyChangeFailed( _
        ByVal sender As Object, ByVal e As  _
        Microsoft.Synchronization.Data.ApplyChangeFailedEventArgs) _
        Handles Me.ApplyChangeFailed

        If e.Conflict.ConflictType = _
            Microsoft.Synchronization.Data.ConflictType.ClientUpdateServerUpdate Then

            'Resolve a client update / server update conflict by keeping the 
            'client change.
            e.Action = Microsoft.Synchronization.Data.ApplyAction.Continue

        End If

    End Sub

End Class

So synchronisieren Sie die Konfliktauflösung und zeigen sie an

  1. Drücken Sie F5.

  2. Aktualisieren Sie im Formular einen Datensatz, und klicken Sie dann auf die Schaltfläche Speichern.

  3. Aktualisieren Sie zur Veranschaulichung des Standardverhaltens für die Konfliktauflösung in Server-Explorer/Datenbank-Explorer den bereits im Formular aktualisierten Datensatz mit einem anderen Wert, und führen Sie einen Commit für die Änderung aus.

  4. Kehren Sie zum Formular zurück, und klicken Sie auf Jetzt synchronisieren.

  5. Überprüfen Sie die Aktualisierung im Anwendungsraster und in der Serverdatenbank. Beachten Sie hierbei, dass die von Ihnen vorgenommene Aktualisierung des Clients die Aktualisierung des Servers überschrieben hat.

Entfernen von Spalten für die Serverüberwachung aus den Synchronisierungsbefehlen

Wenn der Cache für lokale Datenbanken erstellt wird, werden die Spalten zum Nachverfolgen von Änderungen in der Serverdatenbank auf den Client heruntergeladen. (In dieser exemplarischen Vorgehensweise sind die Spalten CreationDate und LastEditDate enthalten.) Entfernen Sie diese Spalten aus den SQL-Befehlen, die Änderungen auf die Serverdatenbank anwenden, um die bidirektionale Synchronisierung zu unterstützen und die Konvergenz von Daten auf Client und Server sicherzustellen. Sie können die Spalten auch aus den Befehlen entfernen, mit denen Änderungen auf dem Server ausgewählt und für den Client übernommen werden, dies ist jedoch nicht erforderlich. Aufgrund von Einschränkungen bei einigen Schemaänderungen in der Clientdatenbank können die Spalten nicht verworfen werden. Weitere Informationen zu Synchronisierungsbefehlen finden Sie unter Vorgehensweise: Angeben der Synchronisierungsart (Momentaufnahmen-, Nur-Download-, Nur-Upload- oder bidirektionale Synchronisierung).

Hinweis

Bei der Änderungsnachverfolgung von SQL Server werden den Tabellen keine Spalten für die Nachverfolg hinzugefügt. In diesem Fall müssen die Befehle zum Anwenden von Änderungen auf dem Server nicht geändert werden.

So entfernen Sie Spalten für die Serverüberwachung aus Synchronisierungsbefehlen

  • Fügen Sie der NorthwindCache-Klasse (NorthwindCache.vb oder NorthwindCache.cs) den folgenden Code am Ende der End Class-Anweisung für die NorthwindCacheServerSyncProvider-Klasse hinzu. Dieser Code definiert die beiden Befehle neu, die als Eigenschaften im SyncAdapter-Objekt für die Customers-Tabelle festgelegt sind: die InsertCommand-Eigenschaft und die UpdateCommand-Eigenschaft. Die Befehle, die mit dem Dialogfeld Datensynchronisierung konfigurieren generiert wurden, enthielten Verweise auf die CreationDate-Spalte und die LastEditDate-Spalte. Diese Befehle wurden in der OnInitialized-Methode der CustomersSyncAdapter-Klasse neu definiert. Die DeleteCommand-Eigenschaft wird nicht neu definiert, da sie keine Auswirkungen auf die CreationDate-Spalte oder LastEditDate-Spalte hat.

    Die Variablen in den einzelnen SQL-Befehlen werden für den Austausch von Daten und Metadaten zwischen Sync Framework, dem Client und dem Server verwendet. Folgende Sitzungsvariablen werden in den unten aufgeführten Befehlen verwendet:

    • @sync_row_count: Gibt die Anzahl der Zeilen zurück, die vom letzten Vorgang auf dem Server betroffen waren. In SQL Server-Datenbanken stellt @@ROWCOUNT den Wert für diese Variable bereit.

    • @sync_force_write: Dient dazu, die Übernahme einer Änderung zu erzwingen, die wegen eines Konflikts oder eines Fehlers nicht vorgenommen wurde.

    • @sync_last_received_anchor: Dient zum Definieren der Änderungen, die während einer Sitzung synchronisiert werden müssen.

    Weitere Informationen über Sitzungsvariablen finden Sie unter Vorgehensweise: Verwenden von Sitzungsvariablen.

    public partial class CustomersSyncAdapter
{

    partial void OnInitialized()
    {

    //Redefine the insert command so that it does not insert values 
    //into the CreationDate and LastEditDate columns.
    System.Data.SqlClient.SqlCommand insertCommand = new System.Data.SqlClient.SqlCommand();

    insertCommand.CommandText = "INSERT INTO dbo.Customers ([CustomerID], [CompanyName], " +
        "[ContactName], [ContactTitle], [Address], [City], [Region], [PostalCode], " +
        "[Country], [Phone], [Fax] )" +
        "VALUES (@CustomerID, @CompanyName, @ContactName, @ContactTitle, @Address, @City, " +
        "@Region, @PostalCode, @Country, @Phone, @Fax) SET @sync_row_count = @@rowcount";
    insertCommand.CommandType = System.Data.CommandType.Text;
    insertCommand.Parameters.Add("@CustomerID", System.Data.SqlDbType.NChar);
    insertCommand.Parameters.Add("@CompanyName", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@ContactName", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@ContactTitle", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@Address", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@City", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@Region", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@PostalCode", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@Country", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@Phone", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@Fax", System.Data.SqlDbType.NVarChar);
    insertCommand.Parameters.Add("@sync_row_count", System.Data.SqlDbType.Int);
    insertCommand.Parameters["@sync_row_count"].Direction = 
        System.Data.ParameterDirection.Output;

    this.InsertCommand = insertCommand;


    //Redefine the update command so that it does not update values 
    //in the CreationDate and LastEditDate columns.
    System.Data.SqlClient.SqlCommand updateCommand = new System.Data.SqlClient.SqlCommand();

    updateCommand.CommandText = "UPDATE dbo.Customers SET [CompanyName] = @CompanyName, [ContactName] " +
        "= @ContactName, [ContactTitle] = @ContactTitle, [Address] = @Address, [City] " +
        "= @City, [Region] = @Region, [PostalCode] = @PostalCode, [Country] = @Country, " +
        "[Phone] = @Phone, [Fax] = @Fax " +
        "WHERE ([CustomerID] = @CustomerID) AND (@sync_force_write = 1 " +
        "OR ([LastEditDate] <= @sync_last_received_anchor)) SET @sync_row_count = @@rowcount";
    updateCommand.CommandType = System.Data.CommandType.Text;
    updateCommand.Parameters.Add("@CompanyName", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@ContactName", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@ContactTitle", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@Address", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@City", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@Region", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@PostalCode", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@Country", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@Phone", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@Fax", System.Data.SqlDbType.NVarChar);
    updateCommand.Parameters.Add("@CustomerID", System.Data.SqlDbType.NChar);
    updateCommand.Parameters.Add("@sync_force_write", System.Data.SqlDbType.Bit);
    updateCommand.Parameters.Add("@sync_last_received_anchor", System.Data.SqlDbType.DateTime);
    updateCommand.Parameters.Add("@sync_row_count", System.Data.SqlDbType.Int);
    updateCommand.Parameters["@sync_row_count"].Direction = 
        System.Data.ParameterDirection.Output;

    this.UpdateCommand = updateCommand;

    }
}

    Partial Public Class CustomersSyncAdapter
    Private Sub OnInitialized()

        'Redefine the insert command so that it does not insert values 
        'into the CreationDate and LastEditDate columns.
        Dim insertCommand As New System.Data.SqlClient.SqlCommand
        With insertCommand
            .CommandText = "INSERT INTO dbo.Customers ([CustomerID], [CompanyName], " & _
                "[ContactName], [ContactTitle], [Address], [City], [Region], [PostalCode], " & _
                "[Country], [Phone], [Fax] )" & _
                "VALUES (@CustomerID, @CompanyName, @ContactName, @ContactTitle, @Address, @City, " & _
                "@Region, @PostalCode, @Country, @Phone, @Fax) SET @sync_row_count = @@rowcount"
            .CommandType = System.Data.CommandType.Text
            .Parameters.Add("@CustomerID", System.Data.SqlDbType.NChar)
            .Parameters.Add("@CompanyName", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@ContactName", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@ContactTitle", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Address", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@City", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Region", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@PostalCode", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Country", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Phone", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Fax", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@sync_row_count", System.Data.SqlDbType.Int)
            .Parameters("@sync_row_count").Direction = ParameterDirection.Output
        End With

        Me.InsertCommand = insertCommand


        'Redefine the update command so that it does not update values 
        'in the CreationDate and LastEditDate columns.
        Dim updateCommand As New System.Data.SqlClient.SqlCommand
        With updateCommand
            .CommandText = "UPDATE dbo.Customers SET [CompanyName] = @CompanyName, [ContactName] " & _
                "= @ContactName, [ContactTitle] = @ContactTitle, [Address] = @Address, [City] " & _
                "= @City, [Region] = @Region, [PostalCode] = @PostalCode, [Country] = @Country, " & _
                "[Phone] = @Phone, [Fax] = @Fax " & _
                "WHERE ([CustomerID] = @CustomerID) AND (@sync_force_write = 1 " & _
                "OR ([LastEditDate] <= @sync_last_received_anchor)) SET @sync_row_count = @@rowcount"
            .CommandType = System.Data.CommandType.Text
            .Parameters.Add("@CompanyName", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@ContactName", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@ContactTitle", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Address", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@City", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Region", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@PostalCode", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Country", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Phone", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@Fax", System.Data.SqlDbType.NVarChar)
            .Parameters.Add("@CustomerID", System.Data.SqlDbType.NChar)
            .Parameters.Add("@sync_force_write", System.Data.SqlDbType.Bit)
            .Parameters.Add("@sync_last_received_anchor", System.Data.SqlDbType.DateTime)
            .Parameters.Add("@sync_row_count", System.Data.SqlDbType.Int)
            .Parameters("@sync_row_count").Direction = ParameterDirection.Output
        End With

        Me.UpdateCommand = updateCommand

    End Sub

End Class

So synchronisieren Sie die Aktualisierung einer Nachverfolgungsspalte und zeigen sie an

  1. Drücken Sie F5.

  2. Aktualisieren Sie im Formular einen Datensatz, indem Sie einen Wert in der LastEditDate-Spalte ändern, und klicken Sie dann auf die Schaltfläche Speichern.

  3. Kehren Sie zum Formular zurück, und klicken Sie auf Jetzt synchronisieren.

  4. Überprüfen Sie die Aktualisierung im Anwendungsraster und in der Serverdatenbank. Beachten Sie hierbei, dass der Spaltenwert des Servers die Aktualisierung auf dem Client überschrieben hat. Der Aktualisierungsvorgang wird folgendermaßen ausgeführt:

    1. Sync Framework stellt fest, dass eine Zeile auf dem Client geändert wurde.

    2. Während der Synchronisierung wird die Zeile hochgeladen und in die Tabelle in der Serverdatenbank übernommen. Die Spalten für die Nachverfolgung sind jedoch nicht in der Aktualisierungsanweisung enthalten. Sync Framework führt im Grunde eine "Dummyaktualisierung" der Tabelle aus.

    3. Die Zeile wird daraufhin an den Client zurückgegeben. In den Befehlen, die Änderungen auf dem Server auswählen, sind die Spalten für die Nachverfolgung jedoch enthalten. Die auf dem Client vorgenommene Änderung wird daher mit dem Wert vom Server überschrieben.

Zusammenfassung

In dieser exemplarischen Vorgehensweise haben Sie eine bidirektionale Synchronisierung mit grundlegender Konfliktbehandlung konfiguriert und sich mit dem potenziellen Problem von Spalten für die Serverüberwachung in der Clientdatenbank befasst. Mit partiellen Klassen können Sie den Code für den Cache für lokale Datenbanken effektiv auch auf andere Weise erweitern. Beispielsweise können Sie SQL-Befehle zum Auswählen von Änderungen aus der Serverdatenbank neu definieren, sodass Daten beim Herunterladen auf den Client gefiltert werden. Es empfiehlt sich, die Themen zur Vorgehensweise in dieser Dokumentation zu lesen, um einen Einblick in die Möglichkeiten zum Hinzufügen oder Ändern von Synchronisierungscode zu erhalten, damit die Anforderungen Ihrer Anwendungen erfüllt werden. Weitere Informationen finden Sie unter Programmieren von allgemeinen Client- und Serversynchronisierungsaufgaben.

Siehe auch

Konzepte

Programmieren von allgemeinen Client- und Serversynchronisierungsaufgaben
Tools zum Entwickeln von Anwendungen