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.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.