Tài liệu Modifying Rows in a DataTable phần 2 docx

// step 3: use the Add method through the Rows property // to add the new DataRow to the DataTable Console.WriteLine"Calling myDataTable.Rows.Add"; myDataTable.Rows.AddmyNewDataRow;

// step 3: use the Add() method through the Rows property

// to add the new DataRow to the DataTable

Console.WriteLine("Calling myDataTable.Rows.Add()");

myDataTable.Rows.Add(myNewDataRow);

Console.WriteLine("myNewDataRow.RowState = " +

myNewDataRow.RowState);

// step 4: use the Update() method to push the new

// row to the database

Console.WriteLine("Calling mySqlDataAdapter.Update()");

mySqlConnection.Open();

int numOfRows = mySqlDataAdapter.Update(myDataTable);

mySqlConnection.Close();

Console.WriteLine("numOfRows = " + numOfRows);

Console.WriteLine("myNewDataRow.RowState = " +

myNewDataRow.RowState);

DisplayDataRow(myNewDataRow, myDataTable);

}

You'll notice I call the Open() and Close() methods of mySqlConnection around the call

to the Update() method You don't have to do this because the Update() method-like the Fill() method-will automatically open and then close mySqlConnection if it is currently closed It is good programming practice, however, to explicitly include the Open() and Close() calls so that you can see exactly what is going on

Note In the ADO.NET disconnected model of data access, you should typically keep the connection to the database open for as short a period as possible Of course, if

you're making a lot of calls to the Update()or the Fill() method over a short time,

you could keep the connection open and then close it when you're finished That way, your code will have better performance You might need to experiment with your own programs to find the right balance

The Update() method is overloaded as follows:

int Update(DataRow[] myDataRows)

int Update(DataSet myDataSet)

int Update(DataTable myDataTable)

int Update(DataRow[] myDataRows, DataTableMapping myDataTableMapping)

int Update(DataSet myDataSet, string dataTableName)

where dataTableName is a string containing the name of the DataTable to update The int

returned by the Update() method is the number of rows successfully updated in the

database

Going back to the previous AddDataRow() method, you'll also notice the inclusion of Console WriteLine() calls that display the RowState property of myNewDataRow The RowState property is set to one of the constants defined in the

System.Data.DataViewRowState enumeration Table 11.10 shows the constants defined

in the DataRowState enumeration

Table 11.10: DataRowState ENUMERATION MEMBERS

CONSTANT DESCRIPTION

Added The DataRow has been added to the DataRowCollection of the DataTable Deleted The DataRow has been removed from the DataTable

Detached The DataRow isn't part of the DataTable

Modified The DataRow has been modified

Unchanged The DataRow hasn't been modified

AddDataRow() calls a method named DisplayDataRow(), which displays the

DataColumn values for the DataRow passed as the first parameter DisplayDataRow() is defined as follows:

public static void DisplayDataRow(

DataRow myDataRow,

DataTable myDataTable)

{

Console.WriteLine("\nIn DisplayDataRow()");

foreach (DataColumn myDataColumn in myDataTable.Columns)

{

Console.WriteLine(myDataColumn + "= " +

myDataRow[myDataColumn]);

}

}

In the previous AddDataRow() method, you saw that it displays the RowState property of myNewDataRow at various points The output from AddDataRow() and its call to

DisplayDataRow() is as follows:

In AddDataRow()

Calling myDataTable.NewRow()

myNewDataRow.RowState = Detached

Calling myDataTable.Rows.Add()

myNewDataRow.RowState = Added

Calling mySqlDataAdapter.Update()

numOfRows = 1

myNewDataRow.RowState = Unchanged

In DisplayDataRow()

CustomerID = J5COM

CompanyName = J5 Company

Address = 1 Main Street

Let's examine this run in detail:

• After myDataTable.NewRow() is called to create myNewDataRow, its RowState

is Detached, which indicates myNewDataRow isn't yet part of myDataTable

• Next, myDataTable.Rows.Add() is called to add myNewDataRow to

myDataTable This causes the RowState of myNewDataRow to change to Added, which indicates myNewDataRow is now part of myDataTable

• Finally, mySqlDataAdapter.Update() is called to push the new row to the database

This causes the RowState of myNewDataRow to change to Unchanged

Behind the scenes, the Update() method runs the INSERT statement in the

mySqlDataAdapter InsertCommand property to add the new row to the Customers table The int returned by the Update() statement is the number of rows affected by the method call In this example, one is returned since one row was added

Modifying a DataRow in a DataTable

To modify a DataRow in a DataTable, you use the following steps:

1 Set the PrimaryKey property of your DataTable You need to set this to find the DataRow in the next step

2 Use the Find() method to locate the DataRow that you want to modify in your DataTable You locate the DataRow using the value of its primary key column

3 Change the DataColumn values for your DataRow

4 Use the Update() method of your DataAdapter object to push the modified row to the database

The following method, named ModifyDataRow(), uses these steps to modify the row that was previously added by the AddDataRow() method:

public static void ModifyDataRow(

DataTable myDataTable,

SqlDataAdapter mySqlDataAdapter,

SqlConnection mySqlConnection

)

{

Console.WriteLine("\nIn ModifyDataRow()");

// step 1: set the PrimaryKey property of the DataTable

myDataTable.PrimaryKey =

new DataColumn[]

{

myDataTable.Columns["CustomerID"]

};

// step 2: use the Find() method to locate the DataRow

// in the DataTable using the primary key value

DataRow myEditDataRow = myDataTable.Rows.Find("J5COM");

// step 3: change the DataColumn values of the DataRow

myEditDataRow["CompanyName"] = "Widgets Inc.";

myEditDataRow["Address"] = "1 Any Street";

Console.WriteLine("myEditDataRow.RowState = " +

myEditDataRow.RowState);

Console.WriteLine("myEditDataRow[\" CustomerID\", " +

"DataRowVersion.Original] = " +

myEditDataRow["CustomerID", DataRowVersion.Original]); Console.WriteLine("myEditDataRow[\" CompanyName\", " + "DataRowVersion.Original] = " +

myEditDataRow["CompanyName", DataRowVersion.Original]); Console.WriteLine("myEditDataRow[\" Address\", " +

"DataRowVersion.Original] = " +

myEditDataRow["Address", DataRowVersion.Original]);

Console.WriteLine("myEditDataRow[\" CompanyName\", " + "DataRowVersion.Current] = " +

myEditDataRow["CompanyName", DataRowVersion.Current]); Console.WriteLine("myEditDataRow[\" Address\", " +

"DataRowVersion.Current] = " +

myEditDataRow["Address", DataRowVersion.Current]);

// step 4: use the Update() method to push the modified

// row to the database

Console.WriteLine("Calling mySqlDataAdapter.Update()");

mySqlConnection.Open();

int numOfRows = mySqlDataAdapter.Update(myDataTable); mySqlConnection.Close();

Console.WriteLine("numOfRows = " + numOfRows);

Console.WriteLine("myEditDataRow.RowState = " +

myEditDataRow.RowState);

DisplayDataRow(myEditDataRow, myDataTable);

}

Setting the primary key in step 1 doesn't have to be done inside the ModifyDataRow() method You could, for example, set the primary key immediately after calling the Fill() method in the Main() method of the AddModifyAndRemoveDataRows.cs program The reason I set the primary key in ModifyDataRow() is that you can see all the steps together

in this method

Notice in step 3 of this method the original values for the CustomerID, CompanyName, and Address DataColumn objects are displayed using the DataRowVersion.Original constant These are the DataColumn values before they are changed The current values for the CompanyName and Address DataColumn objects are also displayed using the DataRowVersion.Current constant These are the DataColumn values after they are

changed

The output from ModifyDataRow() and its call to DisplayDataRow() is as follows:

In ModifyDataRow()

myEditDataRow.RowState = Modified

myEditDataRow["CustomerID", DataRowVersion.Original] = J5COM

myEditDataRow["CompanyName", DataRowVersion.Original] = J5 Company

myEditDataRow["Address", DataRowVersion.Original] = 1 Main Street

myEditDataRow["CompanyName", DataRowVersion.Current] = Widgets Inc

myEditDataRow["Address", DataRowVersion.Current] = 1 Any Street

Calling mySqlDataAdapter.Update()

numOfRows = 1

myEditDataRow.RowState = Unchanged

In DisplayDataRow()

CustomerID = J5COM

CompanyName = Widgets Inc

Address = 1 Any Street

Notice that the CompanyName and Address DataColumn objects of myEditDataRow are changed The RowState property of myEditDataRow changes to Modified after its

CompanyName and Address are changed, and then to Unchanged after

mySqlDataAdapter.Update() is called

Marking Your Modifications

You can use the BeginEdit() method to mark the beginning of a modification to a DataRow For example:

myEditDataRow.BeginEdit();

myEditDataRow["CompanyName"] = "Widgets Inc.";

myEditDataRow["Address"] = "1 Any Street";

You then use either the EndEdit() or CancelEdit() methods to mark the end of the modification to the DataRow EndEdit() commits the modification; CancelEdit() rejects the modification and restores the DataRow to its original state before the edit began

The following example calls the EndEdit() method of myEditDataRow to commit the changes made in the previous example:

myEditDataRow.EndEdit();

Removing a DataRow from a DataTable

To remove a DataRow from a DataTable, you use the following steps:

1 Set the PrimaryKey property for your DataTable object

2 Use the Find() method to locate your DataRow

3 Use the Delete() method to remove your DataRow

4 Use the Update() method to push the delete to the database

The following method, named RemoveDataRow(), uses these steps to remove the DataRow that was previously modified by the ModifyDataRow() method:

public static void RemoveDataRow(

DataTable myDataTable,

SqlDataAdapter mySqlDataAdapter,

SqlConnection mySqlConnection

)

{

Console.WriteLine("\nIn RemoveDataRow()");

// step 1: set the PrimaryKey property of the DataTable

myDataTable.PrimaryKey =

new DataColumn[]

{

myDataTable.Columns["CustomerID"]

};

// step 2: use the Find() method to locate the DataRow

DataRow myRemoveDataRow = myDataTable.Rows.Find("J5COM");

// step 3: use the Delete() method to remove the DataRow

Console.WriteLine("Calling myRemoveDataRow.Delete()");

myRemoveDataRow.Delete();

Console.WriteLine("myRemoveDataRow.RowState = " +

myRemoveDataRow.RowState);

// step 4: use the Update() method to remove the deleted

// row from the database

Console.WriteLine("Calling mySqlDataAdapter.Update()");

mySqlConnection.Open();

int numOfRows = mySqlDataAdapter.Update(myDataTable);

mySqlConnection.Close();

Console.WriteLine("numOfRows = " + numOfRows);

Console.WriteLine("myRemoveDataRow.RowState = " +

myRemoveDataRow.RowState);

}

The output from RemoveDataRow() is as follows:

In RemoveDataRow()

Calling myRemoveDataRow.Delete()

myRemoveDataRow.RowState = Deleted

Calling mySqlDataAdapter.Update()

numOfRows = 1

myRemoveDataRow.RowState = Detached

Notice that the RowState property of myRemoveDataRow is set to Deleted after

myRemoveData Delete() is called, and then to Detached after

mySqlDataAdapter.Update() is called-meaning that myRemoveDataRow is no longer part of the DataTable

Note You'll find a complete program named AddModifyAndRemoveDataRows.cs in the ch11 directory that illustrates the use of the AddDataRow(), ModifyDataRow(), and RemoveDataRow() methods This program listing is omitted from this book for

brevity