DataAdapter.AcceptChangesDuringUpdate Propriedade

Definição

Obtém ou define se AcceptChanges() é chamado durante um Update(DataSet).Gets or sets whether AcceptChanges() is called during a Update(DataSet).

public:
 property bool AcceptChangesDuringUpdate { bool get(); void set(bool value); };
public bool AcceptChangesDuringUpdate { get; set; }
member this.AcceptChangesDuringUpdate : bool with get, set
Public Property AcceptChangesDuringUpdate As Boolean

Valor da propriedade

Boolean

true se AcceptChanges() é chamado durante um Update(DataSet); caso contrário, false.true if AcceptChanges() is called during an Update(DataSet); otherwise false. O padrão é true.The default is true.

Exemplos

Este exemplo demonstra como extrair linhas alteradas de um DataTable e como usar um SqlDataAdapter para atualizar a fonte de dados e recuperar um novo valor de coluna de identidade.This example demonstrates extracting changed rows from a DataTable and using a SqlDataAdapter to update the data source and retrieve a new identity column value. Ao definir a AcceptChangesDuringUpdate propriedade de SqlDataAdapter como false para preservar o valor de incremento automático original, os novos dados podem ser mesclados no original DataTable , mesmo se o novo valor de identidade não corresponder ao valor de incremento automático original no DataTable .By setting the AcceptChangesDuringUpdate property of the SqlDataAdapter to false to preserve the original auto increment value, the new data can then be merged into the original DataTable, even if the new identity value does not match the original auto increment value in the DataTable.

private static void MergeIdentityColumns(string connectionString)
{
    using (SqlConnection connection =
               new SqlConnection(connectionString))
    {
        // Create the DataAdapter
        SqlDataAdapter adapter =
            new SqlDataAdapter(
            "SELECT ShipperID, CompanyName FROM dbo.Shippers",
            connection);

        //Add the InsertCommand to retrieve new identity value.
        adapter.InsertCommand = new SqlCommand(
            "INSERT INTO dbo.Shippers (CompanyName) " +
            "VALUES (@CompanyName); " +
            "SELECT ShipperID, CompanyName FROM dbo.Shippers " +
            "WHERE ShipperID = SCOPE_IDENTITY();", connection);

        // Set AcceptChangesDuringUpdate to false
        adapter.AcceptChangesDuringUpdate = false;

        // Add the parameter for the inserted value.
        adapter.InsertCommand.Parameters.Add(
           new SqlParameter("@CompanyName", SqlDbType.NVarChar, 40,
           "CompanyName"));
        adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.Both;

        // MissingSchemaAction adds any missing schema to
        // the DataTable, including auto increment columns
        adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;

        // Fill a DataTable.
        DataTable shipper = new DataTable();
        adapter.Fill(shipper);

        // Add a new shipper row.
        DataRow newRow = shipper.NewRow();
        newRow["CompanyName"] = "New Shipper";
        shipper.Rows.Add(newRow);

        // Add changed rows to a new DataTable. This
        // DataTable will be used to update the data source.
        DataTable dataChanges = shipper.GetChanges();

        adapter.Update(dataChanges);
        connection.Close();

        Console.WriteLine("Rows after merge.");
        foreach (DataRow rowBefore in shipper.Rows)
        {
            {
                Console.WriteLine("{0}: {1}", rowBefore[0], rowBefore[1]);
            }
        }

        // Merge the two DataTables to get new values.
        shipper.Merge(dataChanges);

        // Commit the changes.
        shipper.AcceptChanges();

        Console.WriteLine("Rows after merge.");
        foreach (DataRow rowAfter in shipper.Rows)
        {
            {
                Console.WriteLine("{0}: {1}", rowAfter[0], rowAfter[1]);
            }
        }
    }
}
Private Sub MergeIdentityColumns(ByVal connectionString As String)

    Using connection As SqlConnection = New SqlConnection( _
       connectionString)

        ' Create the DataAdapter
        Dim adapter As SqlDataAdapter = New SqlDataAdapter( _
          "SELECT ShipperID, CompanyName FROM dbo.Shippers", connection)

        ' Add the InsertCommand to retrieve new identity value.
        adapter.InsertCommand = New SqlCommand( _
            "INSERT INTO dbo.Shippers (CompanyName) " & _
            "VALUES (@CompanyName); " & _
            "SELECT ShipperID, CompanyName FROM dbo.Shippers " & _
            "WHERE ShipperID = SCOPE_IDENTITY();", _
            connection)

        ' Set AcceptChangesDuringUpdate to false.
        adapter.AcceptChangesDuringUpdate = False

        ' Add the parameter for the inserted value.
        adapter.InsertCommand.Parameters.Add( _
           New SqlParameter("@CompanyName", SqlDbType.NVarChar, 40, _
           "CompanyName"))
        adapter.InsertCommand.UpdatedRowSource = _
           UpdateRowSource.FirstReturnedRecord

        ' MissingSchemaAction adds any missing schema to 
        ' the DataTable, including auto increment columns
        adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey

        ' Fill a DataTable.
        Dim shipper As New DataTable
        adapter.Fill(shipper)

        ' Add a new shipper row. 
        Dim newRow As DataRow = shipper.NewRow()
        newRow("CompanyName") = "New Shipper"
        shipper.Rows.Add(newRow)

        ' Add changed rows to a new DataTable. This
        ' DataTable will be used to update the data source.
        Dim dataChanges As DataTable = shipper.GetChanges()

        ' Update the data source with the modified records.
        adapter.Update(dataChanges)

        Console.WriteLine("Rows before merge.")
        Dim rowBefore As DataRow
        For Each rowBefore In shipper.Rows
            Console.WriteLine("{0}: {1}", rowBefore(0), rowBefore(1))
        Next

        ' Merge the two DataTables to get new values.
        shipper.Merge(dataChanges)

        ' Commit the changes.
        shipper.AcceptChanges()

        Console.WriteLine("Rows after merge.")
        Dim rowAfter As DataRow
        For Each rowAfter In shipper.Rows
            Console.WriteLine("{0}: {1}", rowAfter(0), rowAfter(1))
        Next
    End Using
End Sub

Comentários

Durante uma chamada para o Update método de a DataAdapter , o banco de dados pode enviar de volta para o aplicativo ADO.net como parâmetros de saída ou como o primeiro registro retornado de um conjunto de resultados.During a call to the Update method of a DataAdapter, the database can send data back to your ADO.NET application as output parameters or as the first returned record of a result set. O ADO.NET pode recuperar esses valores e atualizar as colunas correspondentes no DataRow que está sendo atualizado.ADO.NET can retrieve these values and update the corresponding columns in the DataRow being updated. Por padrão, ADO.NET chama o AcceptChanges método do DataRow após a atualização.By default, ADO.NET calls the AcceptChanges method of the DataRow after the update. No entanto, se você quiser mesclar a linha atualizada de volta em outra, convém DataTable preserverar o valor original de uma coluna de chave primária.However, if you want to merge the updated row back into another DataTable, you may want to preserver the original value of a primary key column. Por exemplo, uma coluna de chave primária correspondente a uma coluna de incremento automaticamente no banco de dados, como uma coluna de identidade, pode conter novos valores que são atribuídos pelo banco de dados que não correspondem aos valores originais atribuídos no DataRow .For example, a primary key column corresponding to an automatically incrementing column in the database, such as an identity column, can contain new values that are assigned by the database that do not match the original values assigned in the DataRow. Por padrão, AcceptChanges o é chamado implicitamente após uma atualização, e os valores originais na linha, que podem ter sido AutoIncrement valores atribuídos por ADO.net, são perdidos.By default, AcceptChanges is called implicitly after an update, and the original values in the row, which may have been AutoIncrement values assigned by ADO.NET, are lost. Você pode preservar os valores originais no DataRow , impedindo ADO.NET a chamada AcceptChanges após a execução de uma atualização em uma linha, definindo a AcceptChangesDuringUpdate propriedade como false , que preserva os valores originais.You can preserve the original values in the DataRow by preventing ADO.NET from calling AcceptChanges after it performs an update on a row, by setting the AcceptChangesDuringUpdate property to false, which preserves the original values.

Observação

Definir a AcceptChangesDuringUpdate propriedade como false se aplica a todas as modificações de dados, não apenas inserções.Setting the AcceptChangesDuringUpdate property to false applies to all data modifications, not only inserts. Se você quiser editar ou excluir linhas na mesma atualização e se quiser suprimir a chamada para AcceptChanges apenas para inserções, em vez de definir AcceptChangesDuringUpdate como false , use um manipulador de eventos para o RowUpdated evento do DataAdapter .If you want to edit or delete rows in the same update, and if you want to suppress the call to AcceptChanges only for inserts, then instead of setting AcceptChangesDuringUpdate to false, use an event handler for the RowUpdated event of the DataAdapter. No manipulador de eventos, você pode verificar o StatementType para determinar se a modificação de dados é uma inserção, e se true , definir a Status propriedade de RowUpdatedEventArgs como SkipCurrentRow .In the event handler, you can check the StatementType to determine if the data modification is an insert, and if true, set the Status property of the RowUpdatedEventArgs to SkipCurrentRow. Para obter mais informações e um exemplo, consulte recuperando identidade ou valores de numeração automática.For more information and an example, see Retrieving Identity or Autonumber Values.

Aplica-se a