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

Définition

Obtient ou définit si AcceptChanges() est appelé pendant un 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

Valeur de propriété

true si AcceptChanges() est appelé pendant un Update(DataSet) ; sinon, false.true if AcceptChanges() is called during an Update(DataSet); otherwise false. La valeur par défaut est true.The default is true.

Exemples

Cet exemple illustre l'extraction des lignes modifiées d'un objet DataTable et l'utilisation d'un objet SqlDataAdapter pour mettre à jour la source de données et récupérer une nouvelle valeur de colonne d'identité.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. En affectant AcceptChangesDuringUpdate à la propriété SqlDataAdapter de false la valeur pour conserver la valeur d’incrément automatique d’origine, les nouvelles données peuvent ensuite être fusionnées dans le d’origine DataTable, même si la nouvelle valeur d’identité ne correspond pas à l’incrément automatique d’origine. valeur dans le 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

Remarques

Pendant un appel à la Update méthode d’un DataAdapter, la base de données peut renvoyer des données à votre application ADO.net en tant que paramètres de sortie ou en tant que premier enregistrement retourné d’un jeu de résultats.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 peut récupérer ces valeurs et mettre à jour les colonnes correspondantes dans l'objet DataRow en cours de mise à jour.ADO.NET can retrieve these values and update the corresponding columns in the DataRow being updated. Par défaut, ADO.NET appelle la AcceptChanges méthode DataRow du après la mise à jour.By default, ADO.NET calls the AcceptChanges method of the DataRow after the update. Toutefois, si vous souhaitez fusionner la ligne mise à jour dans DataTableune autre, vous souhaiterez peut-être préserver la valeur d’origine d’une colonne de clé primaire.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. Par exemple, une colonne de clé primaire qui correspond à une colonne à incrémentation automatique dans la base de données, telle qu’une colonne d’identité, peut contenir de nouvelles valeurs qui sont assignées par la base de DataRowdonnées qui ne correspondent pas aux valeurs d’origine assignées dans le.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. Par défaut, AcceptChanges est appelé implicitement après une mise à jour, et les valeurs d’origine de la ligne, qui AutoIncrement peuvent avoir des valeurs affectées par ADO.net, sont perdues.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. Vous pouvez conserver les valeurs d’origine dans DataRow le en ADO.NET empêchant AcceptChanges d’appeler après avoir effectué une mise à jour sur une ligne AcceptChangesDuringUpdate , en falseaffectant à la propriété la valeur, ce qui permet de conserver les valeurs d’origine.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.

Notes

L’affectation AcceptChangesDuringUpdate de la false valeur à la propriété s’applique à toutes les modifications de données, et non seulement aux insertions.Setting the AcceptChangesDuringUpdate property to false applies to all data modifications, not only inserts. Si vous souhaitez modifier ou supprimer des lignes dans la même mise à jour, et si vous souhaitez supprimer l’appel AcceptChanges à uniquement pour les insertions, au AcceptChangesDuringUpdate lieu falsede définir sur, utilisez DataAdapterun gestionnaire RowUpdated d’événements pour l’événement de.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. Dans le gestionnaire d’événements, vous pouvez vérifier StatementType le pour déterminer si la modification des données est une insertion et true, si, Status RowUpdatedEventArgs affecter la valeur à SkipCurrentRowla propriété de.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. Pour plus d’informations et pour obtenir un exemple, consultez extraction des valeurs d’identité ou de numérotation NuméroAuto.For more information and an example, see Retrieving Identity or Autonumber Values.

S’applique à

Voir aussi