DataAdapter.AcceptChangesDuringUpdate DataAdapter.AcceptChangesDuringUpdate DataAdapter.AcceptChangesDuringUpdate DataAdapter.AcceptChangesDuringUpdate Property

Definizione

Ottiene o imposta se il metodo AcceptChanges() viene chiamato durante un metodo 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

Valore della proprietà

true se AcceptChanges() viene chiamato durante il metodo Update(DataSet); in caso contrario, false.true if AcceptChanges() is called during an Update(DataSet); otherwise false. Il valore predefinito è true.The default is true.

Esempi

In questo esempio vengono illustrati l'estrazione di righe modificate da un oggetto DataTable e l'uso di SqlDataAdapter per aggiornare l'origine dati e recuperare un nuovo valore per la colonna Identity.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. Impostando la AcceptChangesDuringUpdate SqlDataAdapter proprietà di su false per mantenere il valore di incremento automatico originale, i nuovi dati possono quindi essere Uniti nell'originale DataTable, anche se il nuovo valore Identity non corrisponde all'incremento automatico originale valore in 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

Commenti

Durante una chiamata al Update metodo di un oggetto DataAdapter, il database può restituire i dati all'applicazione ADO.NET come parametri di output o come primo record restituito di un set di risultati.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. ADO.NET può recuperare questi valori e aggiornare le colonne corrispondenti nell'oggetto DataRow da aggiornare.ADO.NET can retrieve these values and update the corresponding columns in the DataRow being updated. Per impostazione predefinita, ADO.NET chiama AcceptChanges il metodo DataRow di dopo l'aggiornamento.By default, ADO.NET calls the AcceptChanges method of the DataRow after the update. Tuttavia, se si desidera eseguire il merge della riga aggiornata in un' DataTablealtra, è consigliabile preserverre il valore originale di una colonna chiave primaria.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. Una colonna chiave primaria, ad esempio, che corrisponde a una colonna di incremento automatico del database, ad esempio una colonna Identity, può contenere nuovi valori assegnati dal database che non corrispondono ai valori originali assegnati in 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. Per impostazione predefinita AcceptChanges , viene chiamato in modo implicito dopo un aggiornamento e i valori originali nella riga, che potrebbero essere AutoIncrement stati assegnati da ADO.NET, vengono persi.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. È possibile mantenere i valori originali in DataRow impedendo ADO.NET la chiamata AcceptChanges di dopo l'esecuzione di un aggiornamento su una riga, impostando la AcceptChangesDuringUpdate proprietà su false, che mantiene i valori originali.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.

Nota

Impostando AcceptChangesDuringUpdate la proprietà false su si applica a tutte le modifiche dei dati, non solo agli inserimenti.Setting the AcceptChangesDuringUpdate property to false applies to all data modifications, not only inserts. Se si desidera modificare o eliminare righe nello stesso aggiornamento e si desidera eliminare la chiamata a AcceptChanges solo per gli inserimenti, anziché impostare AcceptChangesDuringUpdate su false, utilizzare DataAdapterun gestore eventi per l' RowUpdated evento di.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. Nel gestore eventi è StatementType possibile controllare per determinare se la modifica dei dati è un inserimento e se true, RowUpdatedEventArgs impostare la Status proprietà di su 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. Per ulteriori informazioni e un esempio, vedere recupero di valori Identity o Autonumber.For more information and an example, see Retrieving Identity or Autonumber Values.

Si applica a

Vedi anche