Hantera DataTable-händelser

Objektet DataTable innehåller en serie händelser som kan bearbetas av ett program. I följande tabell beskrivs DataTable händelser.

Händelse	beskrivning
Initialized	Inträffar efter att EndInit metoden för en DataTable anropas. Den här händelsen är främst avsedd att stödja designtidsscenarier.
ColumnChanged	Inträffar när ett värde har ändrats i en DataColumn.
ColumnChanging	Inträffar när ett värde har skickats för en DataColumn.
RowChanged	Inträffar efter att ett DataColumn värde eller RowState en DataRow i har DataTable ändrats.
RowChanging	Inträffar när en ändring har skickats för ett DataColumn värde eller RowState en DataRow i DataTable.
RowDeleted	Inträffar efter att DataTable en DataRow i har markerats som Deleted.
RowDeleting	Inträffar innan en DataRow i DataTable markeras som Deleted.
TableCleared	Inträffar efter att ett anrop till Clear metoden för DataTable har rensat varje DataRow.
TableClearing	Inträffar efter att Clear metoden anropats men innan åtgärden påbörjas Clear .
TableNewRow	Inträffar när en ny DataRow skapas av ett anrop till NewRow metoden för DataTable.
Disposed	Inträffar när DataTable är Disposed. Ärvd från MarshalByValueComponent.

Kommentar

De flesta åtgärder som lägger till eller tar bort rader genererar ColumnChanged inte händelserna och ColumnChanging . Metoden genererar dock ReadXml och ColumnChanging händelser, såvida inte XmlReadMode är inställt på DiffGram eller är inställt på Auto när XML-dokumentet som läss är en DiffGram.ColumnChanged

Varning

Skadade data kan inträffa om data ändras i en DataSet från vilken händelsen RowChanged genereras. Inget undantag utlöses om sådana data skadas.

Ytterligare relaterade händelser

Egenskapen Constraints innehåller en ConstraintCollection instans. Klassen ConstraintCollection exponerar en CollectionChanged händelse. Den här händelsen utlöses när en begränsning läggs till, ändras eller tas bort från ConstraintCollection.

Egenskapen Columns innehåller en DataColumnCollection instans. Klassen DataColumnCollection exponerar en CollectionChanged händelse. Den här händelsen utlöses när en DataColumn läggs till, ändras eller tas bort från DataColumnCollection. Ändringar som gör att händelsen utlöses inkluderar ändringar i en kolumns namn, typ, uttryck eller ordningstal.

Egenskapen Tables för en innehåller en DataSet DataTableCollection instans. Klassen DataTableCollection exponerar både en CollectionChanged händelse och en CollectionChanging händelse. Dessa händelser utlöses när en DataTable läggs till i eller tas bort från DataSet.

DataRows Ändringar i kan också utlösa händelser för en associerad DataView. Klassen DataView exponerar en ListChanged händelse som utlöses när ett DataColumn värde ändras eller när vyns sammansättning eller sorteringsordning ändras. Klassen DataRowView exponerar en PropertyChanged händelse som utlöses när ett associerat DataColumn värde ändras.

Åtgärdssekvens

Här är sekvensen med åtgärder som inträffar när en DataRow läggs till, ändras eller tas bort:

1. Skapa den föreslagna posten och tillämpa eventuella ändringar.

2. Kontrollera begränsningar för icke-uttryckskolumner.

3. RowChanging Höj händelserna eller RowDeleting efter behov.

4. Ange den föreslagna posten som aktuell post.

5. Uppdatera eventuella associerade index.

6. Skapa ListChanged händelser för associerade DataView objekt och PropertyChanged händelser för associerade DataRowView objekt.

7. Utvärdera alla uttryckskolumner, men vänta med att kontrollera eventuella begränsningar för dessa kolumner.

8. Skapa ListChanged händelser för associerade DataView objekt och PropertyChanged händelser för associerade DataRowView objekt som påverkas av utvärderingar av uttryckskolumnen.

9. Höjning RowChanged eller RowDeleted händelser enligt vad som är tillämpligt.

10. Kontrollera begränsningar för uttryckskolumner.

Kommentar

Ändringar i uttryckskolumner genererar DataTable aldrig händelser. Ändringar i uttryckskolumner genererar DataView bara och DataRowView händelser. Uttryckskolumner kan ha beroenden för flera andra kolumner och kan utvärderas flera gånger under en enda DataRow åtgärd. Varje uttrycksutvärdering genererar händelser och en enda DataRow åtgärd kan generera flera ListChanged PropertyChanged och händelser när uttryckskolumner påverkas, eventuellt inklusive flera händelser för samma uttryckskolumn.

Varning

Kasta inte en NullReferenceException i RowChanged händelsehanteraren. Om en NullReferenceException genereras inom RowChanged en händelse kommer DataTableden DataTable att skadas.

Exempel

I följande exempel visas hur du skapar händelsehanterare för RowChangedhändelserna , RowChanging, , RowDeleted, ColumnChangedRowDeleting, ColumnChanging, TableNewRow, TableClearedoch TableClearing . Varje händelsehanterare visar utdata i konsolfönstret när den utlöses.

static void DataTableEvents()
{
    DataTable table = new("Customers");
    // Add two columns, id and name.
    table.Columns.Add("id", typeof(int));
    table.Columns.Add("name", typeof(string));

    // Set the primary key.
    table.Columns["id"].Unique = true;
    table.PrimaryKey = new DataColumn[] { table.Columns["id"] };

    // Add a RowChanged event handler.
    table.RowChanged += Row_Changed;

    // Add a RowChanging event handler.
    table.RowChanging += Row_Changing;

    // Add a RowDeleted event handler.
    table.RowDeleted += Row_Deleted;

    // Add a RowDeleting event handler.
    table.RowDeleting += Row_Deleting;

    // Add a ColumnChanged event handler.
    table.ColumnChanged +=
        Column_Changed;

    // Add a ColumnChanging event handler.
    table.ColumnChanging +=
        Column_Changing;

    // Add a TableNewRow event handler.
    table.TableNewRow +=
        Table_NewRow;

    // Add a TableCleared event handler.
    table.TableCleared +=
        Table_Cleared;

    // Add a TableClearing event handler.
    table.TableClearing +=
        Table_Clearing;

    // Add a customer.
    DataRow row = table.NewRow();
    row["id"] = 1;
    row["name"] = "Customer1";
    table.Rows.Add(row);

    table.AcceptChanges();

    // Change the customer name.
    table.Rows[0]["name"] = "ChangedCustomer1";

    // Delete the row.
    table.Rows[0].Delete();

    // Clear the table.
    table.Clear();
}

static void Row_Changed(object sender, DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Changed Event: name={0}; action={1}",
        e.Row["name"], e.Action);

static void Row_Changing(object sender, DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Changing Event: name={0}; action={1}",
        e.Row["name"], e.Action);

static void Row_Deleted(object sender, DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Deleted Event: name={0}; action={1}",
        e.Row["name", DataRowVersion.Original], e.Action);

static void Row_Deleting(object sender,
DataRowChangeEventArgs e) =>
    Console.WriteLine("Row_Deleting Event: name={0}; action={1}",
        e.Row["name"], e.Action);

static void Column_Changed(object sender, DataColumnChangeEventArgs e) =>
    Console.WriteLine("Column_Changed Event: ColumnName={0}; RowState={1}",
        e.Column.ColumnName, e.Row.RowState);

static void Column_Changing(object sender, DataColumnChangeEventArgs e) =>
    Console.WriteLine("Column_Changing Event: ColumnName={0}; RowState={1}",
        e.Column.ColumnName, e.Row.RowState);

static void Table_NewRow(object sender,
    DataTableNewRowEventArgs e) =>
    Console.WriteLine("Table_NewRow Event: RowState={0}",
        e.Row.RowState.ToString());

static void Table_Cleared(object sender, DataTableClearEventArgs e) =>
    Console.WriteLine("Table_Cleared Event: TableName={0}; Rows={1}",
        e.TableName, e.Table.Rows.Count.ToString());

static void Table_Clearing(object sender, DataTableClearEventArgs e) =>
    Console.WriteLine("Table_Clearing Event: TableName={0}; Rows={1}",
        e.TableName, e.Table.Rows.Count.ToString());

Private Sub DataTableEvents()

    Dim table As New DataTable("Customers")
    ' Add two columns, id and name.
    table.Columns.Add("id", Type.GetType("System.Int32"))
    table.Columns.Add("name", Type.GetType("System.String"))

    ' Set the primary key.
    table.Columns("id").Unique = True
    table.PrimaryKey = New DataColumn() {table.Columns("id")}

    ' Add a RowChanged event handler.
    AddHandler table.RowChanged, _
           New DataRowChangeEventHandler(AddressOf Row_Changed)

    ' Add a RowChanging event handler.
    AddHandler table.RowChanging, _
           New DataRowChangeEventHandler(AddressOf Row_Changing)

    ' Add a RowDeleted event handler.
    AddHandler table.RowDeleted, New _
           DataRowChangeEventHandler(AddressOf Row_Deleted)

    ' Add a RowDeleting event handler.
    AddHandler table.RowDeleting, New _
           DataRowChangeEventHandler(AddressOf Row_Deleting)

    ' Add a ColumnChanged event handler.
    AddHandler table.ColumnChanged, _
           New DataColumnChangeEventHandler(AddressOf Column_Changed)

    ' Add a ColumnChanging event handler for the table.
    AddHandler table.ColumnChanging, New _
           DataColumnChangeEventHandler(AddressOf Column_Changing)

    ' Add a TableNewRow event handler.
    AddHandler table.TableNewRow, New _
           DataTableNewRowEventHandler(AddressOf Table_NewRow)

    ' Add a TableCleared event handler.
    AddHandler table.TableCleared, New _
           DataTableClearEventHandler(AddressOf Table_Cleared)

    ' Add a TableClearing event handler.
    AddHandler table.TableClearing, New _
           DataTableClearEventHandler(AddressOf Table_Clearing)

    ' Add a customer.
    Dim row As DataRow = table.NewRow()
    row("id") = 1
    row("name") = "Customer1"
    table.Rows.Add(row)

    table.AcceptChanges()

    ' Change the customer name.
    table.Rows(0).Item("name") = "ChangedCustomer1"

    ' Delete the row.
    table.Rows(0).Delete()

    ' Clear the table.
    table.Clear()
End Sub


Private Sub Row_Changed(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Changed Event: name={0}; action={1}", _
     e.Row("name"), e.Action)
End Sub

Private Sub Row_Changing(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Changing Event: name={0}; action={1}", _
     e.Row("name"), e.Action)
End Sub

Private Sub Row_Deleted(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Deleted Event: name={0}; action={1}", _
     e.Row("name", DataRowVersion.Original), e.Action)
End Sub

Private Sub Row_Deleting(ByVal sender As Object, _
    ByVal e As DataRowChangeEventArgs)
    Console.WriteLine("Row_Deleting Event: name={0}; action={1}", _
       e.Row("name"), e.Action)
End Sub

Private Sub Column_Changed(ByVal sender As Object, _
    ByVal e As DataColumnChangeEventArgs)
    Console.WriteLine("Column_Changed Event: ColumnName={0}; RowState={1}", _
       e.Column.ColumnName, e.Row.RowState)
End Sub

Private Sub Column_Changing(ByVal sender As Object, _
    ByVal e As DataColumnChangeEventArgs)
    Console.WriteLine("Column_Changing Event: ColumnName={0}; RowState={1}", _
       e.Column.ColumnName, e.Row.RowState)
End Sub

Private Sub Table_NewRow(ByVal sender As Object, _
ByVal e As DataTableNewRowEventArgs)
    Console.WriteLine("Table_NewRow Event: RowState={0}", _
       e.Row.RowState.ToString())
End Sub

Private Sub Table_Cleared(ByVal sender As Object, _
    ByVal e As DataTableClearEventArgs)
    Console.WriteLine("Table_Cleared Event: TableName={0}; Rows={1}", _
       e.TableName, e.Table.Rows.Count.ToString())
End Sub

Private Sub Table_Clearing(ByVal sender As Object, _
    ByVal e As DataTableClearEventArgs)
    Console.WriteLine("Table_Clearing Event: TableName={0}; Rows={1}", _
       e.TableName, e.Table.Rows.Count.ToString())
End Sub

Se även

• Manipulera data i en datatabell
• Hantera DataAdapter-händelser
• Hantera datauppsättningshändelser
• översikt över ADO.NET