Visual C++ .NET Databases: Data Records

	Databases Fundamentals: Data Records

Tables Records

Introduction to Records

In our description of tables, we saw that a table was made of one or various columns that represent categories of data. After creating such a table and its columns that represent the categories, you (actually the user) can enter values in the table to make it a valuable list. Filling up a table with values is referred to as data entry.

Data entry is performed by entering a value under the column headers. The group of values that correspond to the same entry or the same line under the columns is called a record. This also means that the records are entered one line, also called a row, at a time. Here is a table filled with various records:

A record on a table is represented as a row (horizontal) of data. To support the various records that belong to a table, the DataTable class is equipped with a property called Rows. The DataTable::Rows property is in fact an object of the DataRowCollection class. The DataRowCollection class provides the necessary properties and methods you can use to create and manage records of a table. A row itself is an object based on the DataRow class.

This lesson is done in two parts: the explanation of database topics and the Practical Learning sections intended to apply the concepts. The explanation sections are as complete as possible so you don't have to follow the Practical Learning exercises. But if you want to perform the assignments in the Practical Learning sections, you must be familiar with the list view control.

Practical Learning: Introducing Data Records

Start Microsoft Visual Studio .NET and create a new Windows Forms Application named PeopleInMyLife4
In the Toolbox, click the Data button.
To create a DataSet, click DataSet and click the form
In the Add Dataset dialog box, click the Untyped Dataset radio button and click OK
While the DataSet control is still selected, in the Properties window, click (Name) and type dsPeople
Still in the Properties window, set the DataSetName to People
Right-click the form and click View Code

In the top section of the file, under the other using namespace lines, type:

using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::IO;
using namespace System::Xml;

In the class of the form, declare a String variable named strFilename

private:
		/// <summary>
		/// Required designer variable.
		/// </summary>
		System::ComponentModel::Container * components;
		String *strFilename;

Return to the form and double-click its body

Implement its Load event as follows:

private: System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 // This is the file that will hold the records
	 strFilename = S"PeopleInMyLife.xml";

	 // If that file exists already, open it
	 if( File::Exists(strFilename) )
		 this->dsPeople->ReadXml(strFilename);
	 else // If it doesn't exist already, then create it
		 this->dsPeople->WriteXml(strFilename);
}

Return to the form.
As done for the lesson on columns, under the form, click dsPeople if necessary. In the Properties window, click the Tables field to reveal its ellipsis button
Click the ellipsis button
In the Tables Collection Editor, click the Add button and change its properties as follows:
(Name): tblPersons
TableName: Persons

Click the Columns field to reveal its ellipsis button

and click its ellipsis button

. In the Columns Collection Editor, click the Add button and, from what we learned about tables and columns, create the columns as follows:

Table	Column (Name)	ColumnName	Data Type
Persons	colFullName	FullName
Persons	colFriendlyName	FriendlyName
Persons	colGender	Gender
Persons	colRelationshipType	TypeOfRelationship
Persons	colKnownSince	KnownSince
Persons	colCurrentResidence	CurrentResidence
Persons	colPhoneNumber	PhoneNumber
Persons	colLastUpdate	LastUpdate	System.DateTime
Persons	colNotifyIfEmergency	NotifyIfEmergency	System.Boolean

Click Close twice

Design the form as follows:

Control	Name	Text	Other Properties
ListView	lvwPeople		AllowColumnReorder: True Anchor: Top, Bottom, Left, Right FullRowSelect: True GridLines: True
Button	btnClose	Close	Anchor: Bottom, Right

Double-click the Close button and implement its Click event as follows:

private: System::Void btnClose_Click(System::Object *  sender, System::EventArgs *  e)
 {
	 Close();
}

Return to the form.
Change the list view's View property to Details and click the ellipsis button of its Columns property

Click Add and create the columns as follows:

Column (Name)	Text	TextAlign	Width
FullName	Full Name		120
FriendlyName	Friendly Name		80
Gender	Gender	Center
Relationship	Relationship		80
KnownSince	Known Since		100
CurrentResidence	Current Residence		100
PhoneNumber	Phone #		80
LastUpdate	Last Update	Right	80
NotifyIfEmergency	Notify?	Center

Click OK

Introduction to Data Entry

To allow the user to perform data entry, you must create an appropriate object meant for this task. You have various options. You can use various controls on the same view or provide a data sheet type of view such as the one available from the DataGrid control. In all cases, when the user performs data entry, by default, it is by entering one record at a time. Any time while the user is performing an operation on a record, the record has a status that can be identify by the DataRow::RowState property which is a value based on the DataRowState enumerator.

A record on a table is represented as a row of data. To support the various records that belong to a table, the DataTable class is equipped with the Rows property which is an object of type DataRowCollection with each record an object of type DataRow.

Before adding a new record to a table, you must let the table know. This is done by calling the DataTable::NewRow() method. Its syntax is:

public: DataRow* NewRow();

The DataTable::NewRow() method returns a DataRow object. Here is an example:

System::Void btnNewDirector_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *rowDirector = this->dtDirectors->NewRow();
}

Practical Learning: Introducing Data Entry

In the Windows Forms section of the Toolbox, click ContextMenu and click the form

On the form, click ContextMenu and click Type Here. Create the following menu items:

Text	(Name)	Shortcut
New Person	mnuNewPerson	CtrlN
Edit Details	mnuEditDetails	CtrlE
Delete Person	mnuDelete	Del
Remove all People	mnuRemoveAll	ShiftDel

On the form, click the list view. In the Properties window, set its ContextMenu to contextMenu1
To create a new form, on the main menu, click Project -> Add New Item...
In the Templates list, click Windows Form. Set the Name to NewPerson and click Open

Design the form as follows:

Control	Name	Text	Other Properties
Label		Full Name:
TextBox	txtFullName		Modifiers: Public
Button	btnCreate	Create	DialogResult: OK Modifiers: Public
Label		Friendly Name:
TextBox	txtFriendlyName		Modifiers: Public
Button	btnClose	Close	DialogResult: Cancel
Label		Gender:
ComboBox	cboGenders	Unknown	Modifiers: Public Items: Female, Male, Unknown
Relationship	cboRelationships	Undefined	Modifiers: Public Items: Friend, Wife, Husband, Son, Daughter, Father, Mother, Brother, Sister, Uncle, Aunt, Cousin, Nephew, Niece, Classmate, Co-Worker, Boss, Employee, Business Partner Sorted: True
Label		Known Since:
TextBox	txtKnownSince		Modifiers: Public
Label		Current Residence:
TextBox	txtCurrentResidence		Modifiers: Public
Label		Phone Number:
TextBox	txtPhoneNumber		Modifiers: Public
Label		Last Update:
DateTimePicker	dtpLastUpdate		Modifiers: Public Format: Custom CustomFormat: dddd dd MMM yyyy
CheckBox	chkNotify	Notify in case of emergency?	Modifiers: Public

In the Class View, expand everything. Right-click Form1 -> Add -> Add Function
Set the Return Type to void, the Function Name to RefreshPeople and the Access to private
Press Enter
In the top section of the file, under the other using namespace lines, type using namespace System::Globalization;

Implement the method as follows:

void RefreshPeople(void)
{
	 if( File::Exists(strFilename) )
	 {
		 this->lvwPeople->Items->Clear();
		 XmlDocument *xmlPeople = new XmlDocument();
		 xmlPeople ->Load(strFilename);

		 XmlElement *nodRoot = xmlPeople->DocumentElement;
		 XmlNodeList *nodFullNames = nodRoot->GetElementsByTagName(S"FullName");
		 XmlNodeList *nodFriendlyNames = nodRoot->GetElementsByTagName(S"FriendlyName");
		 XmlNodeList *nodGenders = nodRoot->GetElementsByTagName(S"Gender");
	XmlNodeList *nodRelationships  = nodRoot->GetElementsByTagName(S"TypeOfRelationship");
		 XmlNodeList *nodKnownDates  = nodRoot->GetElementsByTagName(S"KnownSince");
		 XmlNodeList *nodResidences = nodRoot->GetElementsByTagName(S"CurrentResidence");
		 XmlNodeList *nodPhoneNumbers = nodRoot->GetElementsByTagName(S"PhoneNumber");
		 XmlNodeList *nodLastUpdates = nodRoot->GetElementsByTagName(S"LastUpdate");
	 XmlNodeList *nodNotifications = nodRoot->GetElementsByTagName(S"NotifyIfEmergency");

		 for(int i = 0; i < nodFullNames->Count; i++)
		 {
		 DateTime dteLastUpdate = nodLastUpdates->ItemOf[i]->InnerText->ToDateTime(0);
	 String *strLastUpdate = dteLastUpdate.ToString(S"d", DateTimeFormatInfo::InvariantInfo);

		 ListViewItem *lviPeople = new ListViewItem(nodFullNames->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(nodFriendlyNames->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(nodGenders->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(nodRelationships->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(nodKnownDates->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(nodResidences->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(nodPhoneNumbers->ItemOf[i]->InnerText);
			 lviPeople->SubItems->Add(strLastUpdate);
			 lviPeople->SubItems->Add(nodNotifications->ItemOf[i]->InnerText);
			 this->lvwPeople->Items->Add(lviPeople);
		 }
	 }
}

In the Types combo box above the Code Editor, make sure Form1 is selected. In the Members combo box, select Form1_Load

Change the Load event as follows:

private: System::Void Form1_Load(System::Object *  sender, System::EventArgs *  e)
{
	 // This is the file that will hold the records
	 strFilename = S"PeopleInMyLife.xml";

	 // If that file exists already, open it
	 if( File::Exists(strFilename) )
	 {
		 this->dsPeople->ReadXml(strFilename);
		 RefreshPeople();
	 }
	 else // If it doesn't exist already, then create it
		 this->dsPeople->WriteXml(strFilename);
}

Save all

Data Entry

Adding a Value Based on the Column Index

When you call the DataTable::NewRow() method, the record's status is DataRowState::Detached. After calling the DataTable::NewRow() method, you can specify the value that the column would carry. To do this, you must specify the table's column whose value you want to provide. You can locate a column based on an index as we mentioned already that the columns of a table are stored in the DataTable::Columns property which is based on the DataColumnCollection class. Each column can be identified by its index. Using this index, to assign a new value to the column, use the following version of the DataRow::Item property:

public: __property void set_Item(int* columnIndex);

Here is an example:

System::Void btnNewActor_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *rowActor = this->dtActors->NewRow();

	 rowActor->Item[0] = S"Martin Balsam";
}

When the record has been added to the table, the record has a status of DataRowState::Added. The above version of the DataRowCollection::Add() method allows you to add a value for one column. To complete a record, you would have to create a value for each column.

Practical Learning: Adding a Value Based on the Column Index

Display the first form and click contextMenu1. On the form, click Context Menu and double-click New Person
In the top section of the file, under the #pragma line, type #include "NewPerson.h"

To create a record using the column's indices, implement the event as follows:

private: System::Void mnuNewPerson_Click(System::Object *  sender, System::EventArgs *  e)
{
	 NewPerson *dlgPerson = new NewPerson();

	 if( dlgPerson->ShowDialog() == DialogResult::OK )
	 {
		 DataRow *rowPerson = this->tblPersons->NewRow();
		 rowPerson->Item[0] = dlgPerson->txtFullName->Text;
		 rowPerson->Item[1] = dlgPerson->txtFriendlyName->Text;
		 rowPerson->Item[2] = dlgPerson->cboGenders->Text;
		 rowPerson->Item[3] = dlgPerson->cboRelationships->Text;
		 rowPerson->Item[4] = dlgPerson->txtKnownSince->Text;
		 rowPerson->Item[5] = dlgPerson->txtResidence->Text;
		 rowPerson->Item[6] = dlgPerson->txtPhoneNumber->Text;
		 rowPerson->Item[7] = dlgPerson->dtpLastUpdate->Value.ToString(S"d");
		 rowPerson->Item[8] = dlgPerson->chkNotify->Checked.ToString();
		 this->tblPersons->Rows->Add(rowPerson);

		 this->dsPeople->WriteXml(S"PeopleInMyLife.xml");
		 RefreshPeople();
	 }
}

Execute the application to test it and try creating a few persons
Close the form(s) and preview the XML file in your browser
Return to your programming environment

Adding a Value Based on the Column Variable Name

If you prefer to use the variable name of a column when adding the value, you can use the following version of the property:

public: __property void set_Item(DataColumn* name);

Here is an example of using this version of the property:

System::Void btnNewCategory_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *rowCategory = this->dtVideoCategories->NewRow();

	 rowCategory->Item[this->colCategory] = S"Documentary";			 
}

Practical Learning: Adding a Value Based on the Column Variable Name

Display the form and add a new Button
Set its properties as follows:
(Name): btnNewPerson
Text: New Person
Anchor: Bottom, Left

Double-click the new button and implement its Click event as follows:

private: System::Void btnNewPerson_Click(System::Object *  sender, System::EventArgs *  e)
{
	 NewPerson *dlgPerson = new NewPerson();

	 if( dlgPerson->ShowDialog() == DialogResult::OK )
	 {
		 DataRow *rowPerson = this->tblPersons->NewRow();
		 rowPerson->Item[colFullName] = dlgPerson->txtFullName->Text;
		 rowPerson->Item[colFriendlyName] = dlgPerson->txtFriendlyName->Text;
		 rowPerson->Item[colPersonGender] = dlgPerson->cboGenders->Text;
		 rowPerson->Item[colRelationshipType] = dlgPerson->cboRelationships->Text;
		 rowPerson->Item[colKnownSince] = dlgPerson->txtKnownSince->Text;
		 rowPerson->Item[colCurrentResidence] = dlgPerson->txtResidence->Text;
		 rowPerson->Item[colPhoneNumber] = dlgPerson->txtPhoneNumber->Text;
		 rowPerson->Item[colLastUpdate] = dlgPerson->dtpLastUpdate->Value.ToString(S"d");
		 rowPerson->Item[colNotifyIfEmergency] = dlgPerson->chkNotify->Checked.ToString();
		 this->tblPersons->Rows->Add(rowPerson);

		 this->dsPeople->WriteXml(S"PeopleInMyLife.xml");
		 RefreshPeople();
	 }
}

Execute the application and try creating a few persons using the New Person button
Close the form(s) and return to your programming environment

Adding a Value Based on the Column Object Name

To specify the name of the column, the DataRow class is equipped with an Item property that allows you to identify a column by its object name, by its variable name, or by its index. Based on this, the DataRow::Item property is overloaded with three versions. One of the versions uses the following syntax:

public: __property void set_Item(String* columnName);

This property expects the object name of the column passed in its square brackets. When calling this property, you can assign it the desired value for the column. Here is an example:

System::Void btnNewDirector_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *rowDirector = this->dtDirectors->NewRow();

	 rowDirector->Item[S"Director"] = S"John Landis";
}

After assigning the desired value to the row, to add the new value to a table, the DataRowCollection class provides the Add() method that is overloaded with two versions. The first version of this method uses the following syntax:

public: void Add(DataRow* row);

This method simply expects you to pass the DataRow object you previously defined. Here is an example:

System::Void btnNewDirector_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *rowDirector = this->dtDirectors->NewRow();

	 rowDirector->Item[S"Director"] = S"John Landis";
	 this->dtDirectors->Rows->Add(rowDirector);
}

In the same way, you can identify each column of a table by its object name and assign it the appropriate value. Once the record is complete, you can add it to the table. Here is an example:

System::Void btnNewVideo_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *rowVideo = this->dtVideos->NewRow();

	 rowVideo->Item[S"Title"] = S"A Few Good Men";
	 rowVideo->Item[S"Director"] = S"Rob Reiner";
	 rowVideo->Item[S"YearReleased"] = __box(1993);
	 rowVideo->Item[S"Length"] = S"138 Minutes";
	 rowVideo->Item[S"Rating"] = S"R";
	 rowVideo->Item[S"Format"] = S"VHS";
	 rowVideo->Item["Category"] = S"Drama";
	 this->dtVideos->Rows->Add(rowVideo);
}

Practical Learning: Adding a Value Based on the Column Object Name

Display the form and click the list view
In the Properties window, click the Events button and double-click the right field to KeyDown

Implement the KeyDown event of the list view as follows:

private: System::Void lvwPeople_KeyDown(System::Object *  sender, System::Windows::Forms::KeyEventArgs *  e)
{
	 // If the user pressed F4...
	 if( e->KeyCode == Keys::F4 )
	 {
		 // ... Get ready to create a new record
		 NewPerson *dlgPerson = new NewPerson();

		 if( dlgPerson->ShowDialog() == DialogResult::OK )
		 {
			 DataRow *rowPerson = this->tblPersons->NewRow();
			 rowPerson->Item[S"FullName"] = dlgPerson->txtFullName->Text;
			 rowPerson->Item[S"FriendlyName"] = dlgPerson->txtFriendlyName->Text;
			 rowPerson->Item[S"Gender"] = dlgPerson->cboGenders->Text;
			 rowPerson->Item[S"TypeOfRelationship"] = dlgPerson->cboRelationships->Text;
			 rowPerson->Item[S"KnownSince"] = dlgPerson->txtKnownSince->Text;
			 rowPerson->Item[S"CurrentResidence"] = dlgPerson->txtResidence->Text;
			 rowPerson->Item[S"PhoneNumber"] = dlgPerson->txtPhoneNumber->Text;
			 rowPerson->Item[S"LastUpdate"] = dlgPerson->dtpLastUpdate->Value.ToString(S"d");
			 rowPerson->Item[S"NotifyIfEmergency"] = dlgPerson->chkNotify->Checked.ToString();
			 this->tblPersons->Rows->Add(rowPerson);

			 this->dsPeople->WriteXml(S"PeopleInMyLife.xml");
			 RefreshPeople();
		 }
	 }
}

Execute the application
Press F4 and try creating a person
Close the form(s) and return to your programming environment

Adding an Array of Records

The above version of the DataRowCollection::Add() method means that you must identify each column before assigning a value to it. If you already know the sequence of columns and don't need to explicitly identify them, you can store all values in an array and simply add the array as a complete record. To do this, you can use the second version of the DataRowCollection::Add() method whose syntax is:

public: virtual DataRow* Add(Object* values __gc[]);

Here is an example:

System::Void btnNewVideo_Click(System::Object *  sender, System::EventArgs *  e)
{
	 String *vdoRecord[] = { S"Fatal Attraction", S"Adrian Lyne", S"1987",
			       S"120 Minutes", S"R", S"DVD", S"Drama" };

	 this->dtVideos->Rows->Add(vdoRecord);
}

There is an alternative to this second version of the DataRowCollection::Add() method. As opposed to passing an array of values to the Add() method, you can first define an array, assign that array to a DataRow variable, then pass that DataRow object to the Add() method. To support this technique, the DataRow class is equipped with an ItemArray property that expects an array. Here is an example

System::Void btnNewVideo_Click(System::Object *  sender, System::EventArgs *  e)
{
	 String *vdoNewVideo[] = { S"Her Alibi", S"Bruce Beresford", S"1989",
			             S"94 Minutes", S"PG-13", S"DVD", S"Comedy" };
	 DataRow *rowNewVideo = this->dtVideos->NewRow();
	 rowNewVideo->ItemArray = vdoNewVideo;
	 this->dtVideos->Rows->Add(rowNewVideo);
}

After creating the records of a table, if a record contains invalid values, the DataRow::HasErrors property can help you identify them.

Locating Records and Their Values

Locating a Record

Before performing any operation on a record, you must be able to locate it. That is, you must be able to identify a record among the various records of a table. To locate a record in the DataTable::Rows collection, the DataRowCollection class provides the Item property that is defined as follows

public: __property DataRow* get_Item(int index);

The records of a table are stored in a list (called the DataRowCollection). The first record, which in the example above has the title as "A Few Good Men" and the Director as Rob Reiner, has an index of 0. The second record has an index of 1, and so on. Here is an example of using it to retrieve the information stored in a record:

System::Void button1_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *row = this->dtVideos->Rows->Item[2];
}

When you pass an index to this property, the compiler would check whether the record exists. If a record with that index exists, its DataRow value is produced. If you specify an index that is either less than 0 or beyond the number of records in the table, the compiler would throw an IndexOutOfRangeException exception.

To get the number of records that a table contains, access the Count property of its DataRowCollection. The Count property is inherited from the InternalDataCollectionBase class, which is the parent of many collection classes.

When the records of a DataTable object have been created, you can get their list as an array using its List property that is inherited from the InternalDataCollectionBase class. This property returns an ArrayList type of list.

Practical Learning: Locating a Record

Display the first form and click the list view

In the Events section of the Properties window, double-click the right field to DoubleClick and implement its event as follows:

private: System::Void lvwPeople_DoubleClick(System::Object *  sender, System::EventArgs *  e)
{
	 ListViewItem *selPerson = this->lvwPeople->SelectedItems->Item[0];
	 int indexOfPersonSelected = selPerson->Index;
	 DataRow *rowPerson = this->tblPersons->Rows->Item[indexOfPersonSelected];
}

Save all

Locating a Value

As mentioned already, a record is in fact one or a group of values from each of the columns of the table. Consider the following table:

The "A Few Good Men" string is a value of the Title column. In the same way, "VHS" is a value of the Format column. In some circumstances, you will need to locate a particular value in order to perform an operation on it. As seen above, you can start by locating the record you need and return its DataRow object. To know the table that the record belongs to, access its DataRow::Table property. This property is declared as follows:

public: __property DataTable* get_Table();

To locate the value that a record holds under a particular column, the DataRow class provides the Item property that is overloaded with three versions (actually six, but at this time we are interested in the first three only). One of the versions of this property uses the following syntax:

public: __property Object* get_Item(String* columnName);

To use this property, pass the object name of the column in the square brackets. The following example is based on the above table. It retrieves the title of the third video and displays it in the caption of the form:

System::Void button1_Click(System::Object *  sender, System::EventArgs *  e)
{
	 DataRow *row = this->dtVideos->Rows->Item[2];
	 String  *strVideoTitle = dynamic_cast<String *>(row->Item[S"Title"]);

	 Text = strVideoTitle;
}

Instead of using the index of a column, you can also locate a value using the variable name of its column. To do this, you can use the following syntax of the DataRow::Item indexed property:

public: __property void get_Item(DataColumn* column);

This property expects the object name of the column passed in its square brackets. The third option you have is to identify the column by its index. To do this, use the following syntax of the DataRow::Item indexed property:

public: __property void get_Item(int index);

This property expects the index of the column.

Practical Learning: Locating a Value in a Record and Updating it

To locate a value inside a record, change the DoubleClick events of the list view as follows:

private: System::Void lvwPeople_DoubleClick(System::Object *  sender, System::EventArgs *  e)
{
	 ListViewItem *selPerson = this->lvwPeople->SelectedItems->Item[0];
	 int indexOfPersonSelected = selPerson->Index;
	 DataRow *rowPerson = this->tblPersons->Rows->Item[indexOfPersonSelected];

	 NewPerson *dlgPerson = new NewPerson();

	 dlgPerson->txtFullName->Text = dynamic_cast<String *>(rowPerson->Item[S"FullName"]);
	 dlgPerson->txtFriendlyName->Text = dynamic_cast<String *>(rowPerson->Item[S"FriendlyName"]);
	 dlgPerson->cboGenders->Text = dynamic_cast<String *>(rowPerson->Item[S"Gender"]);
	 dlgPerson->cboRelationships->Text = dynamic_cast<String *>(rowPerson->Item[S"TypeOfRelationship"]);
	 dlgPerson->txtKnownSince->Text = dynamic_cast<String *>(rowPerson->Item[S"KnownSince"]);
	 dlgPerson->txtResidence->Text = dynamic_cast<String *>(rowPerson->Item[S"CurrentResidence"]);
	 dlgPerson->txtPhoneNumber->Text = dynamic_cast<String *>(rowPerson->Item[S"PhoneNumber"]);
	 dlgPerson->dtpLastUpdate->Text = dynamic_cast<String *>(rowPerson->Item[S"LastUpdate"]);

	 String *strNotify = dynamic_cast<String *>(rowPerson->Item[S"NotifyIfEmergency"]);
	 bool bNotity = false;

	 if( strNotify == S"true" )
		 bNotity = true;

	 dlgPerson->chkNotify->Checked = bNotity;
	 dlgPerson->btnCreate->Text = S"Update";

	 if( dlgPerson->ShowDialog() == DialogResult::OK )
	 {
		 rowPerson->Item[S"FullName"] = dlgPerson->txtFullName->Text;
		 rowPerson->Item[S"FriendlyName"] = dlgPerson->txtFriendlyName->Text;
		 rowPerson->Item[S"Gender"] = dlgPerson->cboGenders->Text;
		 rowPerson->Item[S"TypeOfRelationship"] = dlgPerson->cboRelationships->Text;
		 rowPerson->Item[S"KnownSince"] = dlgPerson->txtKnownSince->Text;
		 rowPerson->Item[S"CurrentResidence"] = dlgPerson->txtResidence->Text;
		 rowPerson->Item[S"PhoneNumber"] = dlgPerson->txtPhoneNumber->Text;
		 rowPerson->Item[S"LastUpdate"] = dlgPerson->dtpLastUpdate->Value.ToString(S"d");
		 rowPerson->Item[S"NotifyIfEmergency"] = dlgPerson->chkNotify->Checked.ToString();

		 this->dsPeople->WriteXml(S"PeopleInMyLife.xml");
		 RefreshPeople();
	 }
}

Return to the form. Under the form, click contextMenu1
On the form, click Context Menu and click Edit Details
In the Events section of the Properties window, set the Click event to lvwPeople_DoubleClick
Execute the application
In the list view, double-click a record, change some of its values and

Record Maintenance

Once a table has been filled with records, you can perform maintenance operations on it such as changing some records or removing others. To remove a record from a table, you can call the DataRowCollection::Remove() method. Its syntax is:

public: void Remove(DataRow *row);

This method takes as argument a DataRow object and checks whether the table contains. If that record exists, it gets deleted, including all of its entries for each column. When calling this method, you must pass an exact identification of the record. If you don't have that identification, you can delete a record based on its index. To do this, you would call the DataRowCollection::RemoveAt() method. Its syntax is:

public: void RemoveAt(int index);

This method takes as argument the index of the record you want to delete. If a record with that index exists, it would be deleted.

To delete all records of a table, call the DataRowCollection::Clear() method. Its syntax is:

public: void Clear();

This method is used to clear the table of all records.

Practical Learning: Deleting Records

Display the first form. Under the form, click contextMenu1
On the form, click Context Menu and double-click Delete Person

Implement the event as follows:

private: System::Void mnuDeletePerson_Click(System::Object *  sender, System::EventArgs *  e)
{
	 ListViewItem *selPerson = this->lvwPeople->SelectedItems->Item[0];
	 int indexOfPersonSelected = selPerson->Index;

	 if( indexOfPersonSelected >= 0 )
	 {
		 DataRow *rowPerson = this->tblPersons->Rows->Item[indexOfPersonSelected];
		 System::Windows::Forms::DialogResult answer = 
			 MessageBox::Show(S"Are you sure you want to delete this record?",
					                  S"Deleting a Record",
						  MessageBoxButtons::YesNo,
						  MessageBoxIcon::Information);
		 if( answer == DialogResult::Yes )
		 {
			 this->tblPersons->Rows->Remove(rowPerson);
			 this->dsPeople->WriteXml(this->strFilename);
		 }
		 RefreshPeople();
	 }
}

Return to the form and double-click the Remove all People menu item

Implement the event as follows:

private: System::Void mnuRemoveAll_Click(System::Object *  sender, System::EventArgs *  e)
{
	 System::Windows::Forms::DialogResult answer = 
			 MessageBox::Show(S"Are you sure you want to delete all records?",
				                  S"Deleting all Records",
					  MessageBoxButtons::YesNo,
					  MessageBoxIcon::Information);
	 if( answer == DialogResult::Yes )
	 {
		 this->tblPersons->Rows->Clear();
		 this->dsPeople->WriteXml(this->strFilename);
	 }
	 RefreshPeople();
}

Execute the application
Close the form(s)


Previous	Copyright © 2004-2012, FunctionX	Next