Behandeln von DataAdapter-Ereignissen

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

RowUpdating wird ausgelöst, bevor ein Update einer Zeile des DataSet-Objekts in der Datenquelle verarbeitet wurde. RowUpdated wird ausgelöst, nachdem ein Update einer Zeile des DataSet-Objekts in der Datenquelle verarbeitet wurde. Folglich können Sie mit dem RowUpdating-Ereignis das Verhalten von Updates ändern, bevor sie vorgenommen werden, zusätzliche Behandlungsoptionen beim Auftreten eines Updates anbieten, einen Verweis auf eine aktualisierte Zeile beibehalten, das aktuelle Update abbrechen und es für die spätere Verarbeitung in einem Stapelverarbeitungsprozess einplanen usw. RowUpdated ist hilfreich bei der Reaktion auf Fehler und Ausnahmen, die während des Updates 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 des Updates 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 Updatestypen, 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 des Updates 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 das Updates 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 in der DataSet-Klasse Fehlerinformationen hinzu, unterdrückt die Ausnahme und setzt die Verarbeitung 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 FillErrorEventArgs-Ereignis übergebenen FillError 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 FillError-Ereignis DataAdapter 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.  
    myRow.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.  
    myRow.RowError =
       "OverflowException Encountered. Value from data source: " +  
       args.Values[2];  
    args.Continue = true;  
  }  
}  

Weitere Informationen

• "DataAdapters" und "DataReaders"
• Behandeln von DataSet-Ereignissen
• Behandeln von DataTable-Ereignissen
• Ereignisse
• Übersicht über ADO.NET