Behandeln einer Parallelitätsausnahme in .NET Framework-Datenbankanwendungen

Parallelitätsausnahmen (System.Data.DBConcurrencyException) werden ausgelöst, wenn zwei Benutzer versuchen, dieselben Daten in einer Datenbank gleichzeitig zu ändern. In dieser exemplarischen Vorgehensweise erstellen Sie eine Windows-Anwendung, die veranschaulicht, wie Sie eine DBConcurrencyException abfangen, die Zeile lokalisieren, die den Fehler verursacht hat, und eine Strategie erlernen, wie Sie damit umgehen können.

Diese Schritt-für-Schritt-Anleitung führt Sie durch den folgenden Prozess:

1. Erstellen Sie ein neues Windows Forms App (.NET Framework) -Projekt.

2. Erstellen Sie ein neues Dataset basierend auf der Tabelle "Northwind Customers".

3. Erstellen Sie ein Formular mit einer DataGridView, um die Daten anzuzeigen.

4. Füllen Sie ein Dataset mit Daten aus der Tabelle "Kunden" in der Northwind-Datenbank aus.

5. Verwenden Sie das Feature "Tabellendaten anzeigen " im Server-Explorer , um auf die Daten der Kundentabelle zuzugreifen und einen Datensatz zu ändern.

6. Ändern Sie denselben Datensatz in einen anderen Wert, aktualisieren Sie das Dataset, und versuchen Sie, die Änderungen in die Datenbank zu schreiben, wodurch ein Parallelitätsfehler ausgelöst wird.

7. Erfassen Sie den Fehler, und zeigen Sie dann die verschiedenen Versionen des Datensatzes an, sodass der Benutzer ermitteln kann, ob die Datenbank fortgesetzt und aktualisiert werden soll, oder brechen Sie die Aktualisierung ab.

Voraussetzungen

In dieser exemplarischen Vorgehensweise wird SQL Server Express LocalDB und die Northwind-Beispieldatenbank verwendet.

1. Wenn Sie nicht über SQL Server Express LocalDB verfügen, installieren Sie sie entweder über die SQL Server Express-Downloadseite oder über das Visual Studio-Installationsprogramm. Im Visual Studio Installerkönnen Sie SQL Server Express LocalDB als Teil der Datenspeicher und Verarbeitung Workload oder als einzelne Komponente installieren.

2. Installieren Sie die Northwind-Beispieldatenbank, indem Sie die folgenden Schritte ausführen:

   1. Öffnen Sie in Visual Studio das fenster SQL Server-Objekt-Explorer. (SQL Server-Objekt-Explorer wird als Teil der Datenspeicherungs- und Verarbeitungsauslastung im Visual Studio Installer installiert.) Erweitern Sie den SQL Server-Knoten . Klicken Sie mit der rechten Maustaste auf Ihre LocalDB-Instanz, und wählen Sie neue Abfrageaus.

      Ein Abfrage-Editor-Fenster wird geöffnet.

   2. Kopieren Sie das Northwind-Transact-SQL Skript in die Zwischenablage. Dieses T-SQL-Skript erstellt die Northwind-Datenbank von Grund auf neu und füllt sie mit Daten auf.

   3. Fügen Sie das T-SQL-Skript in den Abfrage-Editor ein, und wählen Sie dann die Schaltfläche Ausführen aus.

      Nach kurzer Zeit wird die Ausführung der Abfrage abgeschlossen, und die Northwind-Datenbank wird erstellt.

Erstellen eines neuen Projekts

Erstellen Sie zunächst eine neue Windows Forms-Anwendung:

1. Wählen Sie in Visual Studio im Menü "Datei" die Option "Neues Projekt"> aus.

2. Erweitern Sie entweder Visual C# oder Visual Basic im linken Bereich, und wählen Sie dann Windows Desktop aus.

3. Wählen Sie im mittleren Bereich den Projekttyp "Windows Forms-App " aus.

4. Benennen Sie das Projekt "ConcurrencyWalkthrough", und wählen Sie dann "OK" aus.

   Das Projekt ConcurrencyWalkthrough wird erstellt und dem Projektmappen-Explorer hinzugefügt, woraufhin ein neues Formular im Designer geöffnet wird.

Erstellen des Northwind-Datasets

Erstellen Sie als Nächstes ein Dataset mit dem Namen "NorthwindDataSet":

1. Wählen Sie im Menü "Daten " die Option "Neue Datenquelle hinzufügen" aus.

   Der Assistent zum Konfigurieren von Datenquellen wird geöffnet.

2. Wählen Sie auf dem Bildschirm " Datenquellentyp auswählen " die Option "Datenbank" aus.

   

3. Wählen Sie eine Verbindung mit der Northwind-Beispieldatenbank aus der Liste der verfügbaren Verbindungen aus. Wenn die Verbindung in der Liste der Verbindungen nicht verfügbar ist, wählen Sie "Neue Verbindung" aus.

   Hinweis

   Wenn Sie eine Verbindung mit einer lokalen Datenbankdatei herstellen, wählen Sie "Nein " aus, wenn Sie gefragt werden, ob Sie die Datei zu Ihrem Projekt hinzufügen möchten.

4. Wählen Sie auf dem Bildschirm "Verbindungszeichenfolge in der Anwendungskonfigurationsdatei speichern" die Option "Weiter" aus.

5. Erweitern Sie den Knoten "Tabellen ", und wählen Sie die Tabelle " Kunden " aus. Der Standardname für das Dataset sollte NorthwindDataSet sein.

6. Wählen Sie "Fertig stellen" aus, um das Dataset dem Projekt hinzuzufügen.

Erstellen eines datengebundenen DataGridView-Steuerelements

In diesem Abschnitt erstellen Sie ein System.Windows.Forms.DataGridView Element, indem Sie das Element "Kunden " aus dem Fenster "Datenquellen " auf Ihr Windows Form-Formular ziehen.

1. Um das Fenster "Datenquellen " zu öffnen, wählen Sie im Menü "Daten " die Option "Datenquellen anzeigen" aus.

2. Erweitern Sie im Fenster "Datenquellen " den Knoten "NorthwindDataSet ", und wählen Sie dann die Tabelle " Customers " aus.

3. Wählen Sie den Abwärtspfeil auf dem Tabellenknoten und dann DataGridView in der Dropdownliste aus.

4. Ziehen Sie die Tabelle auf einen leeren Bereich des Formulars.

   Ein DataGridView Steuerelement mit dem Namen CustomersDataGridView und ein BindingNavigator Steuerelement namens CustomersBindingNavigator werden dem Formular hinzugefügt, das an das BindingSource gebunden ist. Dies ist wiederum an die Tabelle "Customers" im NorthwindDataSet gebunden.

Testen des Formulars

Sie können nun das Formular testen, um sicherzustellen, dass es sich bis zu diesem Punkt wie erwartet verhält:

1. Wählen Sie F5 aus, um die Anwendung auszuführen.

   Das Formular wird mit einem DataGridView Steuerelement angezeigt, das mit Daten aus der Tabelle "Kunden" gefüllt ist.

2. Klicken Sie im Menü Debuggen auf Stop Debugging (Debuggen beenden).

Behandeln von Parallelitätsfehlern

Die Behandlung von Fehlern hängt von den spezifischen Geschäftsregeln ab, die Ihre Anwendung regeln. Für diesen Walkthrough verwenden wir die folgende Strategie als Beispiel für die Behandlung eines Parallelitätsfehlers.

Die Anwendung stellt dem Benutzer drei Versionen des Datensatzes vor:

• Der aktuelle Datensatz in der Datenbank

• Der ursprüngliche Datensatz, der in das Dataset geladen wird

• Die vorgeschlagenen Änderungen im Dataset

Der Benutzer kann dann entweder die Datenbank mit der vorgeschlagenen Version überschreiben oder das Update abbrechen und das Dataset mit den neuen Werten aus der Datenbank aktualisieren.

So aktivieren Sie das Handling von Parallelitätsfehlern

1. Erstellen Sie einen benutzerdefinierten Fehlerhandler.

2. Zeigen Sie dem Benutzer Auswahlmöglichkeiten an.

3. Verarbeiten sie die Antwort des Benutzers.

4. Senden Sie das Update erneut, oder setzen Sie die Daten im Dataset zurück.

Hinzufügen von Code zur Behandlung der Parallelitäts ausnahme

Wenn Sie versuchen, eine Aktualisierung durchzuführen und eine Ausnahme ausgelöst wird, möchten Sie im Allgemeinen etwas mit den Informationen ausführen, die von der ausgelösten Ausnahme bereitgestellt werden. In diesem Abschnitt fügen Sie Code hinzu, der versucht, die Datenbank zu aktualisieren. Sie behandeln auch jede DBConcurrencyException, die ausgelöst werden kann, sowie alle anderen Ausnahmen.

1. Fügen Sie den folgenden Code unter der Form1_Load Methode hinzu:

   • C#
   • VB

   private void UpdateDatabase()
   {
       try
       {
           this.customersTableAdapter.Update(this.northwindDataSet.Customers);
           MessageBox.Show("Update successful");
       }
       catch (DBConcurrencyException dbcx)
       {
           DialogResult response = MessageBox.Show(CreateMessage((NorthwindDataSet.CustomersRow)
               (dbcx.Row)), "Concurrency Exception", MessageBoxButtons.YesNo);
   
           ProcessDialogResult(response);
       }
       catch (Exception ex)
       {
           MessageBox.Show("An error was thrown while attempting to update the database.");
       }
   }
   

2. Ersetzen Sie die CustomersBindingNavigatorSaveItem_Click Methode, um die UpdateDatabase Methode aufzurufen, damit sie wie folgt aussieht:

   • C#
   • VB

   private void customersBindingNavigatorSaveItem_Click(object sender, EventArgs e)
   {
       UpdateDatabase();
   }
   

Anzeigen von Auswahlmöglichkeiten für den Benutzer

Der Code, den Sie gerade geschrieben haben, ruft die CreateMessage Prozedur auf, um Fehlerinformationen für den Benutzer anzuzeigen. Für diese exemplarische Vorgehensweise verwenden Sie ein Meldungsfeld, um die verschiedenen Versionen des Datensatzes für den Benutzer anzuzeigen. Dadurch kann der Benutzer auswählen, ob der Datensatz mit den Änderungen überschrieben oder die Bearbeitung abgebrochen werden soll. Sobald der Benutzer eine Option (klickt auf eine Schaltfläche) im Meldungsfeld auswählt, wird die Antwort an die ProcessDialogResult Methode übergeben.

Erstellen Sie die Nachricht, indem Sie dem Code-Editor den folgenden Code hinzufügen. Geben Sie diesen Code unter der UpdateDatabase Methode ein:

private string CreateMessage(NorthwindDataSet.CustomersRow cr)
{
    return
        "Database: " + GetRowData(GetCurrentRowInDB(cr), DataRowVersion.Default) + "\n" +
        "Original: " + GetRowData(cr, DataRowVersion.Original) + "\n" +
        "Proposed: " + GetRowData(cr, DataRowVersion.Current) + "\n" +
        "Do you still want to update the database with the proposed value?";
}


//--------------------------------------------------------------------------
// This method loads a temporary table with current records from the database
// and returns the current values from the row that caused the exception.
//--------------------------------------------------------------------------
private NorthwindDataSet.CustomersDataTable tempCustomersDataTable = 
    new NorthwindDataSet.CustomersDataTable();

private NorthwindDataSet.CustomersRow GetCurrentRowInDB(NorthwindDataSet.CustomersRow RowWithError)
{
    this.customersTableAdapter.Fill(tempCustomersDataTable);

    NorthwindDataSet.CustomersRow currentRowInDb = 
        tempCustomersDataTable.FindByCustomerID(RowWithError.CustomerID);

    return currentRowInDb;
}


//--------------------------------------------------------------------------
// This method takes a CustomersRow and RowVersion 
// and returns a string of column values to display to the user.
//--------------------------------------------------------------------------
private string GetRowData(NorthwindDataSet.CustomersRow custRow, DataRowVersion RowVersion)
{
    string rowData = "";

    for (int i = 0; i < custRow.ItemArray.Length ; i++ )
    {
        rowData = rowData + custRow[i, RowVersion].ToString() + " ";
    }
    return rowData;
}

Private Function CreateMessage(ByVal cr As NorthwindDataSet.CustomersRow) As String
    Return "Database: " & GetRowData(GetCurrentRowInDB(cr), 
                                     Data.DataRowVersion.Default) & vbCrLf &
           "Original: " & GetRowData(cr, Data.DataRowVersion.Original) & vbCrLf &
           "Proposed: " & GetRowData(cr, Data.DataRowVersion.Current) & vbCrLf &
           "Do you still want to update the database with the proposed value?"
End Function


'--------------------------------------------------------------------------
' This method loads a temporary table with current records from the database
' and returns the current values from the row that caused the exception.
'--------------------------------------------------------------------------
Private TempCustomersDataTable As New NorthwindDataSet.CustomersDataTable

Private Function GetCurrentRowInDB(
    ByVal RowWithError As NorthwindDataSet.CustomersRow
    ) As NorthwindDataSet.CustomersRow

    Me.CustomersTableAdapter.Fill(TempCustomersDataTable)

    Dim currentRowInDb As NorthwindDataSet.CustomersRow =
        TempCustomersDataTable.FindByCustomerID(RowWithError.CustomerID)

    Return currentRowInDb
End Function


'--------------------------------------------------------------------------
' This method takes a CustomersRow and RowVersion 
' and returns a string of column values to display to the user.
'--------------------------------------------------------------------------
Private Function GetRowData(ByVal custRow As NorthwindDataSet.CustomersRow,
    ByVal RowVersion As Data.DataRowVersion) As String

    Dim rowData As String = ""

    For i As Integer = 0 To custRow.ItemArray.Length - 1
        rowData &= custRow.Item(i, RowVersion).ToString() & " "
    Next

    Return rowData
End Function

Verarbeiten der Antwort des Benutzers

Außerdem benötigen Sie Code, um die Antwort des Benutzers auf das Meldungsfeld zu verarbeiten. Die Optionen sind entweder das Überschreiben des aktuellen Datensatzes in der Datenbank mit der vorgeschlagenen Änderung, oder verlassen Sie die lokalen Änderungen, und aktualisieren Sie die Datentabelle mit dem Datensatz, der sich derzeit in der Datenbank befindet. Wenn der Benutzer "Ja" auswäht, wird die Merge Methode aufgerufen, wobei das Argument "preserveChanges " auf "true" festgelegt ist. Dies bewirkt, dass der Aktualisierungsversuch erfolgreich ist, da die ursprüngliche Version des Datensatzes jetzt mit dem Datensatz in der Datenbank übereinstimmt.

Fügen Sie den folgenden Code unterhalb des Codes hinzu, der im vorherigen Abschnitt hinzugefügt wurde:

// This method takes the DialogResult selected by the user and updates the database 
// with the new values or cancels the update and resets the Customers table 
// (in the dataset) with the values currently in the database.

private void ProcessDialogResult(DialogResult response)
{
    switch (response)
    {
        case DialogResult.Yes:
            northwindDataSet.Merge(tempCustomersDataTable, true, MissingSchemaAction.Ignore);
            UpdateDatabase();
            break;

        case DialogResult.No:
            northwindDataSet.Merge(tempCustomersDataTable);
            MessageBox.Show("Update cancelled");
            break;
    }
}

' This method takes the DialogResult selected by the user and updates the database 
' with the new values or cancels the update and resets the Customers table 
' (in the dataset) with the values currently in the database.

Private Sub ProcessDialogResult(ByVal response As Windows.Forms.DialogResult)

    Select Case response

        Case Windows.Forms.DialogResult.Yes
            NorthwindDataSet.Customers.Merge(TempCustomersDataTable, True)
            UpdateDatabase()

        Case Windows.Forms.DialogResult.No
            NorthwindDataSet.Customers.Merge(TempCustomersDataTable)
            MsgBox("Update cancelled")
    End Select
End Sub

Testen des Formularverhaltens

Sie können das Formular jetzt testen, um sicherzustellen, dass es sich wie erwartet verhält. Um eine Parallelitätsverletzung zu simulieren, ändern Sie daten in der Datenbank nach dem Ausfüllen des NorthwindDataSet.

1. Wählen Sie F5 aus, um die Anwendung auszuführen.

2. Nachdem das Formular angezeigt wurde, lassen Sie es ausgeführt, und wechseln Sie zur Visual Studio-IDE.

3. Wählen Sie im Menü "Ansicht " die Option "Server-Explorer" aus.

4. Erweitern Sie im Server-Explorer die Verbindung, die Ihre Anwendung verwendet, und erweitern Sie dann den Knoten "Tabellen ".

5. Klicken Sie mit der rechten Maustaste auf die Tabelle "Kunden ", und wählen Sie dann " Tabellendaten anzeigen" aus.

6. Ändern Sie im ersten Datensatz (ALFKI) ContactName in Maria Anders2.

   Hinweis

   Navigieren Sie zu einer anderen Zeile, um die Änderung zu übernehmen.

7. Wechseln Sie zum aktiven Formular von ConcurrencyWalkthrough.

8. Ändern Sie im ersten Datensatz im Formular (ALFKI) "ContactName " in "Maria Anders1".

9. Wählen Sie die Schaltfläche Speichern aus.

   Der Parallelitätsfehler wird ausgelöst, und das Meldungsfeld wird angezeigt.

   Wenn Sie "Nein" auswählen, wird die Aktualisierung abgebrochen und das Dataset mit den Werten aktualisiert, die sich derzeit in der Datenbank befinden. Wenn Sie "Ja " auswählen, wird der vorgeschlagene Wert in die Datenbank geschrieben.

Verwandte Inhalte

• Daten wieder in der Datenbank speichern