Umgang mit 'DataAdapter'-Ereignissen (ADO.NET)

Aktualisiert: November 2007

Der ADO.NET-DataAdapter macht drei Ereignisse verfügbar, mit denen Sie auf Änderungen der Daten der Datenquelle reagieren können. In der folgenden Tabelle finden Sie eine Beschreibung dieser DataAdapter-Ereignisse.

RowUpdating und RowUpdated

Das RowUpdating-Ereignis wird ausgelöst, bevor der Aktualisierungsvorgang für die Zeile im DataSet an der Datenquelle verarbeitet wurde. Das RowUpdated-Ereignis wird ausgelöst, nachdem die Aktualisierung der Zeile aus dem DataSet an der Datenquelle abgeschlossen wurde. Folglich können Sie mit dem RowUpdating-Ereignis das Verhalten von Aktualisierungen ändern, bevor sie vorgenommen werden, zusätzliche Behandlungsoptionen beim Auftreten einer Aktualisierung anbieten, einen Verweis auf eine aktualisierte Zeile beibehalten, die aktuelle Aktualisierung abbrechen und sie für die spätere Verarbeitung in einem Stapelverarbeitungsprozess einplanen usw. Das RowUpdated-Ereignis kann für das Reagieren auf Fehler und Ausnahmen eingesetzt werden, die bei der Aktualisierung auftreten. Sie können dem DataSet Fehlerinformationen, eine Wiederholungslogik u. a. m. hinzufügen.

Die Argumente RowUpdatingEventArgs und RowUpdatedEventArgs, die an die Ereignisse RowUpdating und RowUpdated übergeben werden, enthalten Folgendes: eine Command-Eigenschaft, die auf das Command-Objekt verweist, das zur Ausführung der Aktualisierung verwendet wird, eine Row-Eigenschaft, die auf das DataRow-Objekt verweist, dass die aktualisierten Informationen enthält, eine StatementType-Eigenschaft zur Angabe der auszuführenden Aktualisierungstypen, die TableMapping, sofern zutreffend, und den Status des Vorgangs.

Mit der Status-Eigenschaft können Sie ermitteln, ob während des Vorgangs ein Fehler aufgetreten ist, und gegebenenfalls die Aktionen für die aktuellen und die resultierenden Zeilen steuern. Wenn das Ereignis eintritt, entspricht die Status-Eigenschaft entweder Continue oder ErrorsOccurred. In der folgenden Tabelle sind die Werte dargestellt, die Sie für die Status-Eigenschaft festlegen können, um nachfolgende Aktionen während der Aktualisierung zu steuern.

Durch das Festlegen der Status-Eigenschaft auf ErrorsOccurred wird eine Ausnahme ausgelöst. Welche Ausnahme ausgelöst wird, können Sie steuern, indem Sie für die Errors-Eigenschaft die gewünschte Ausnahme angeben. Wenn Sie einen der anderen Werte für Status verwenden, wird keine Ausnahme ausgelöst.

Sie können auch die ContinueUpdateOnError-Eigenschaft verwenden, um Fehler für aktualisierte Zeilen zu behandeln. Wenn für DataAdapter.ContinueUpdateOnError der Wert true angegeben ist und die Aktualisierung einer Zeile eine Ausnahme auslöst, wird der Text der Ausnahme in die RowError-Information der entsprechenden Zeile aufgenommen. Die Verarbeitung wird fortgesetzt, ohne dass eine Ausnahme ausgelöst wird. Auf diese Weise können Sie auf Fehler reagieren, wenn Update abgeschlossen wurde. Dagegen können Sie beim RowUpdated-Ereignis auf den Fehler reagieren, sobald er festgestellt wird.

Im folgenden Codebeispiel wird dargestellt, wie Ereignishandler hinzugefügt und entfernt werden. Der RowUpdating-Ereignishandler schreibt ein Protokoll aller gelöschten Datensätze und versieht die Löschvorgangaufzeichnungen jeweils mit einem Timestamp. Der RowUpdated-Ereignishandler fügt der RowError-Eigenschaft der Zeile im DataSet Fehlerinformationen hinzu, unterdrückt die Ausnahme und setzt den Verarbeitungsvorgang fort (entspricht dem Verhalten von ContinueUpdateOnError = true).

' Assumes that connection is a valid SqlConnection object.
Dim custAdapter As SqlDataAdapter = New SqlDataAdapter( _
  "SELECT CustomerID, CompanyName FROM Customers", connection)

' Add handlers.
AddHandler custAdapter.RowUpdating, New SqlRowUpdatingEventHandler( _
  AddressOf OnRowUpdating)
AddHandler custAdapter.RowUpdated, New SqlRowUpdatedEventHandler(
  AddressOf OnRowUpdated)

' Set DataAdapter command properties, fill DataSet, and modify DataSet.

custAdapter.Update(custDS, "Customers")

' Remove handlers.
RemoveHandler custAdapter.RowUpdating, _
  New SqlRowUpdatingEventHandler(AddressOf OnRowUpdating)
RemoveHandler custAdapter.RowUpdated, _
  New SqlRowUpdatedEventHandler(AddressOf OnRowUpdated)

Private Shared Sub OnRowUpdating(sender As Object, _
  args As SqlRowUpdatingEventArgs)
  If args.StatementType = StatementType.Delete Then
    Dim tw As System.IO.TextWriter = _
  System.IO.File.AppendText("Deletes.log")
    tw.WriteLine( _
      "{0}: Customer {1} Deleted.", DateTime.Now, args.Row(_
      "CustomerID", DataRowVersion.Original))
    tw.Close()
  End If
End Sub

Private Shared Sub OnRowUpdated( _
  sender As Object, args As SqlRowUpdatedEventArgs)
  If args.Status = UpdateStatus.ErrorsOccurred
    args.Status = UpdateStatus.SkipCurrentRow
    args.Row.RowError = args.Errors.Message
  End If
End Sub

// Assumes that connection is a valid SqlConnection object.
SqlDataAdapter custAdapter = new SqlDataAdapter(
  "SELECT CustomerID, CompanyName FROM Customers", connection);

// Add handlers.
custAdapter.RowUpdating += new SqlRowUpdatingEventHandler(OnRowUpdating);
custAdapter.RowUpdated += new SqlRowUpdatedEventHandler(OnRowUpdated);

// Set DataAdapter command properties, fill DataSet, modify DataSet.

custAdapter.Update(custDS, "Customers");

// Remove handlers.
custAdapter.RowUpdating -= new SqlRowUpdatingEventHandler(OnRowUpdating);
custAdapter.RowUpdated -= new SqlRowUpdatedEventHandler(OnRowUpdated);

protected static void OnRowUpdating(
  object sender, SqlRowUpdatingEventArgs args)
{
  if (args.StatementType == StatementType.Delete)
  {
    System.IO.TextWriter tw = System.IO.File.AppendText("Deletes.log");
    tw.WriteLine(
      "{0}: Customer {1} Deleted.", DateTime.Now, 
       args.Row["CustomerID", DataRowVersion.Original]);
    tw.Close();
  }
}

protected static void OnRowUpdated(
  object sender, SqlRowUpdatedEventArgs args)
{
  if (args.Status == UpdateStatus.ErrorsOccurred)
  {
    args.Row.RowError = args.Errors.Message;
    args.Status = UpdateStatus.SkipCurrentRow;
  }
}

FillError

Der DataAdapter gibt das FillError-Ereignis aus, wenn während des Fill-Vorgangs ein Fehler auftritt.Dieser Fehlertyp tritt auf, wenn die Daten in der hinzugefügten Zeile nicht ohne Präzisionsverlust in einen .NET Framework-Typ konvertiert werden konnten.

Wenn während eines Fill-Vorgangs ein Fehler auftritt, wird der DataTable die aktuelle Zeile nicht hinzugefügt. Mit dem FillError-Ereignis können Sie den Fehler auflösen und die Zeile hinzufügen oder die betreffende Zeile ignorieren und den Fill-Vorgang fortsetzen.

Die an das FillError-Ereignis übergebenen FillErrorEventArgs können mehrere Eigenschaften enthalten, mit denen Sie auf Fehler reagieren und diese auflösen können. In der folgenden Tabelle werden die Eigenschaften des FillErrorEventArgs-Objekts dargestellt.

Im folgenden Codebeispiel wird ein Ereignishandler für das DataAdapter-Ereignis FillError hinzugefügt. Im FillError-Ereigniscode bestimmt das Beispiel, ob die Möglichkeit von Präzisionsverlust besteht, und bietet die Chance, auf die Ausnahme zu reagieren.

AddHandler adapter.FillError, New FillErrorEventHandler( _
  AddressOf FillError)

Dim dataSet As DataSet = New DataSet
adapter.Fill(dataSet, "ThisTable")

Private Shared Sub FillError(sender As Object, _
  args As FillErrorEventArgs)
  If args.Errors.GetType() Is Type.GetType("System.OverflowException") Then
    ' Code to handle precision loss.
    ' Add a row to table using the values from the first two columns.
    DataRow myRow = args.DataTable.Rows.Add(New Object() _
      {args.Values(0), args.Values(1), DBNull.Value})
    ' Set the RowError containing the value for the third column.
    args.RowError = _
      "OverflowException encountered. Value from data source: " & _
      args.Values(2)
    args.Continue = True
  End If
End Sub

adapter.FillError += new FillErrorEventHandler(FillError);

DataSet dataSet = new DataSet();
adapter.Fill(dataSet, "ThisTable");

protected static void FillError(object sender, FillErrorEventArgs args)
{
  if (args.Errors.GetType() == typeof(System.OverflowException))
  {
    // Code to handle precision loss.
    //Add a row to table using the values from the first two columns.
    DataRow myRow = args.DataTable.Rows.Add(new object[]
       {args.Values[0], args.Values[1], DBNull.Value});
    //Set the RowError containing the value for the third column.
    args.RowError = 
       "OverflowException Encountered. Value from data source: " +
       args.Values[2];
    args.Continue = true;
  }
}

Siehe auch

Konzepte

Behandeln von 'DataSet'-Ereignissen (ADO.NET)

Behandlung von 'DataTable'-Ereignissen (ADO.NET)

Weitere Ressourcen

'DataAdapters' und 'DataReaders' (ADO.NET)

Behandeln und Auslösen von Ereignissen