Binding Data to the User Interface

Display and update data:

• Bind data to the user interface.

Data binding refers to the process of creating a link between a data model and the user interface of an application. The data model can be any source of data within the application: It might be an array of values, an Extensible Markup Language (XML) file, or data stored in a database. The user interface consists of the controls that are contained on the forms in an application.

The .NET Framework includes extremely flexible data binding capabilities. In the following sections you'll learn about many of those capabilities, including the following:

• Simple data binding

• Complex data binding

• One-way and two-way data binding

• The BindingContext object

• The Data Form Wizard

Simple Data Binding

Simple data binding means connecting a single value from the data model to a single property of a control. For example, you might bind the Vendor object name from a list of vendors to the Text property of a TextBox control.

private void StepByStep5_1_Load(object sender,
    System.EventArgs e)
{
    // Create an array of vendor names
    String [] astrVendorNames =
       {"Microsoft", "Rational", "Premia"};

    // Bind the array to the text box
    txtVendorName.DataBindings.Add(
        "Text", astrVendorNames, "");
}

Looking at the code in Step by Step 5.1, you can see that the .NET Framework supplies an object model for binding. The control has a ControlBindingsCollection (accessed through its DataBindings property), which contains instances of the Binding class. By default there are no Binding objects in the collection, so when you create a control, it's not bound. To bind the control, you can add a new Binding object to the ControlBindingsCollection by using its Add() method.

Because the Add() method creates a new instance of the Binding class, it takes the same parameters as the constructor for that class:

• The name of the property to bind to

• The data source to bind

• The navigation path to the particular data; in this particular example, the navigation path is empty because there's only one thing to bind to in this array

Now that you've seen simple data binding in action, it's time to explore the topic in a bit more depth. I'll start by looking at which entities can be bound to the user interface. Then I'll talk about which properties you can bind to those entities.

Finally, I'll explain the architecture that the .NET Framework uses to manage simple data binding. You'll see that you can work directly with the objects that handle the data binding connections if you need to interact with the data binding process from code.

Bindable Entities

In Step by Step 5.1, the Text property of the TextBox control is bound to an element from an array. The Binding class can accept many other types of data sources, including the following:

• An instance of any class that implements the IBindingList or ITypedList interface, including the DataSet, DataTable, DataView, and DataViewManager classes.

• An instance of any class that implements the IList interface on an indexed collection of objects. In particular, this applies to classes that inherit from System.Array, including C# arrays.

• An instance of any class that implements the IList interface on an indexed collection of strongly typed objects. For example, you can bind to an array of Vendor objects.

Binding to a collection of strongly typed objects is a convenient way to handle data from an object-oriented data model.

using System;
namespace _316C05
{
    public class Vendor
    {
        private string vendorName;
        public string VendorName
        {
            get
            {
                return vendorName;
            }
            set
            {
                vendorName = value;
            }
        }
        public Vendor(string strVendorName)
        {
            this.VendorName = strVendorName;
        }
    }
}

private void StepByStep5_2_Load(
    object sender, System.EventArgs e)
{
    // Create an array of vendor objects
    Vendor[] aVendors = new Vendor[3];
    aVendors[0] = new Vendor("Microsoft");
    aVendors[1] = new Vendor("Rational");
    aVendors[2] = new Vendor("Premia");

    // Bind the array to the text box
    txtVendorName.DataBindings.Add(
       "Text", aVendors, "VendorName");
}

At this point, you could be forgiven for thinking that binding makes only the first element of a data source available on the user interface. In fact, bound controls are designed to let the user move through an entire collection of data. Later in this chapter you'll learn the details of the BindingContext object, which enables you to manipulate the data behind a bound control. But as a preview, Figure 5.1 shows a form that lets you scroll through the data in a strongly typed IList.

// Create an array of vendor objects
Vendor aVendors = new Vendor[3];

private void StepByStep5_3_Load(object sender,
     System.EventArgs e)
{
    // Initialize the vendors array
    aVendors[0] = new Vendor("Microsoft");
    aVendors[1] = new Vendor("Rational");
    aVendors[2] = new Vendor("Premia");

    // Bind the array to the text box
    txtVendorName.DataBindings.Add(
       "Text", aVendors, "VendorName");
}

private void btnPrevious_Click(object sender,
     System.EventArgs e)
{
    // Move to the previous item in the data source
    this.BindingContext[aVendors].Position -= 1;
}

private void btnNext_Click(object sender,
     System.EventArgs e)
{
    // Move to the next item in the data source
    this.BindingContext[aVendors].Position += 1;
}

Properties That Can Be Bound

Just as the .NET Framework allows flexibility in the source of bound data, it allows flexibility on the user interface side of the equation. You can use simple data binding with any control that has a DataBindings property, which includes any control that is derived from System.Windows.Forms.Control. In practice, that means almost any control you can drop on a Windows form.

You can bind just about any property of these bindable controls to an item of data. This gives you enormous flexibility in building a user interface that depends on data. For example, you can bind an array of DateTime values to the Value property of a DateTimePicker control.

// Create an array of dates
DateTime [] adtBound =
 {DateTime.Today , DateTime.Today.AddDays(1),
 DateTime.Today.AddDays(2), DateTime.Today.AddDays(3),
DateTime.Today.AddDays(4), DateTime.Today.AddDays(5)};

private void StepByStep5_4_Load(object sender,
    System.EventArgs e)
{
    // Bind the array to the date/time picker
    dtBound.DataBindings.Add("Value", adtBound, "");
}

private void btnPrevious_Click(
    object sender, System.EventArgs e)
{
    // Move to the previous item in the data source
    this.BindingContext[adtBound].Position -= 1;
}

private void btnNext_Click(
    object sender, System.EventArgs e)
{
    // Move to the next item in the data source
    this.BindingContext[adtBound].Position += 1;
}

If you think creatively, you can find many ways to use simple data binding beyond simply displaying text in a text box. Here are some possibilities:

• Display a set of photos by binding them to the Image property of a PictureBox control.

• Show the relative magnitude of quantities with the Value property of a ProgressBar control.

• Color-code an area of a form by binding to the BackColor property of a Panel control.

The Architecture of Simple Data Binding

When you use simple data binding to connect a control to a data source, the .NET Framework creates a pair of objects to manage the binding: a CurrencyManager object and a BindingContext object. Depending on the number of controls on the form and the data to which they are bound, a single form might involve several of each of these objects.

The CurrencyManager object is responsible for keeping track of which piece of data from a data source is currently bound to the user interface. Although so far you've only seen one data bound control on each form, a single form can contain multiple bound controls. If all the controls are bound to the same data source, they can share a CurrencyManager object. But a single form can involve multiple CurrencyManager objects as well. Suppose, for example, that you built a form with an array of Vendor objects bound to one control and an array of DateTime objects bound to another control. In that case, the form would have two CurrencyManager objects.

Any bound form will also have at least one BindingContext object. The job of the BindingContext object is to keep track of the various CurrencyManager objects on the form. The indexer of the BindingContext object returns a CurrencyManager object. Consider this line of code:

this.BindingContext[adtBound].Position += 1;

That tells the BindingContext object for the form to return a CurrencyManager object for the adtBound data source and then to increment the Position property of the CurrencyManager object. The CurrencyManager object encapsulates the knowledge of how to move the pointer within the data array when the Position property is changed.

Like forms, container controls (such as the GroupBox, Panel, or TabControl controls) can have their own BindingContext objects. By using these separate BindingContext objects, you can create forms that have independently scolling views of the same data.

You'll learn about the CurrencyManager object in more depth later in this chapter. But first, let's look at another variety of data binding: complex data binding.

Complex Data Binding

In complex data binding, you bind a user interface control to an entire collection of data, rather than to a single data item. A good example of complex data binding involves the DataGrid control. Figure 5.2 shows a bound DataGrid control displaying data from the Suppliers table in the SQL Server 2000 Northwind database.

Figure 5.2. By using complex data binding, you can see an entire collection of data on the user interface at one time.

[View full size image]

You'll learn how to build this form later in the chapter, but for now, just concentrate on its features. DataGrid is a single control that displays many pieces of data. In this case, the data is taken from the rows and columns of the Suppliers table in a SQL Server 2000 database. You can click any cell in the DataGrid control and edit the data that the cell contains. If the form is properly programmed, these edits are reflected in the underlying data.

Obviously, complex data binding is a powerful tool for transferring large amounts of data from a data model to a user interface. The following sections dig into the mechanics of complex data binding with two examples:

• Binding to a ComboBox or ListBox control

• Binding to a DataGrid control

Binding to a ComboBox or ListBox Control

The ComboBox and ListBox controls both provide ways for the user to select one item from a list of data. The difference between the two is that in the ListBox control, the list is visible at all times, whereas in the ComboBox control, the list is hidden until the user clicks the drop-down arrow at the end of the box. Either of these controls can be loaded with an entire list of data via complex data binding.

using System;
namespace _316C05
{
    public class Exam
    {
        private String examNumber;
        private String examName;

        public String ExamNumber
        {
            get
            {
                return examNumber;
            }
        }

        public String ExamName
        {
            get
            {
                return examName;
            }
        }
        public Exam(String strExamNumber,
            String strExamName)
        {
            examNumber = strExamNumber;
            examName = strExamName;
        }
    }
}

private void StepByStep5_5_Load(object sender,
     System.EventArgs e)
{
    // Create an array of exams
    Exam[] aExams =
    {
    new Exam("315",
       "Web Applications With Visual C# .NET"),
    new Exam("316",
       "Windows Applications With Visual C# .NET"),
    new Exam("320", "XML With Visual C# .NET"),
    new Exam("305", "Web Applications With VB.NET"),
    new Exam("306",
        "Windows Applications With VB.NET"),
    new Exam("310", "XML With VB.NET")};

    // Bind the array to the list box
    lbExams.DataSource = aExams;
    lbExams.DisplayMember = "ExamName";
}

Step by Step 5.5 works by first creating an array of exam objects that contains all the information you'd like to display in the list portion of a ListBox control. It then sets the DataSource property of the ListBox control to the name of the array and the DisplayMember property to the name of the object property that supplies the text for the list. The result is a ListBox control that allows the user to choose from a list of exam names.

As it stands, Step by Step 5.5 doesn't do anything with the data after the user chooses an item from the list. But frequently you'll use a complex data-bound ListBox or ComboBox control in conjunction with a simple data-bound control such as a TextBox control. By selecting a row in the ListBox control, the user can choose a value for the TextBox control.

You can think of the ListBox control in this case as a little pump that moves data from one part of the data model to another. Step by Step 5.6 shows how you can set this up.

using System;
namespace _316C05
{
    public class Candidate
    {
        private string examNumber;
        private string candidateName;

        public string ExamNumber
        {
            get
            {
                return examNumber;
            }
            set
            {
                examNumber = value;
            }
        }

        public string CandidateName
        {
            get
            {
                return candidateName;
            }
            set
            {
                candidateName = value;
            }
        }

        public Candidate(String strCandidateName,
           String strExamNumber)
        {
            this.CandidateName = strCandidateName;
            this.ExamNumber = strExamNumber;
        }
    }
}

// Create an array of candidates
private Candidate[] aCandidates = {
              new Candidate("Bill Gates", "305"),
              new Candidate("Steve Ballmer", "320")};

private void StepByStep5_6_Load(object sender,
   System.EventArgs e)
{
    // Create an array of exams

    Exam[] aExams = {
    new Exam("315",
       "Web Applications With Visual C# .NET"),
    new Exam("316",
       "Windows Applications With Visual C# .NET"),
    new Exam("320", "XML With Visual C# .NET"),
    new Exam("305", "Web Applications With VB.NET"),
    new Exam("306",
       "Windows Applications With VB.NET"),
    new Exam("310", "XML With VB.NET")};

    // Bind the array to the list box
    lbExams.DataSource = aExams;
    lbExams.DisplayMember = "ExamName";
    lbExams.ValueMember = "ExamNumber";

    // Bind the candidates to the text boxes
    txtCandidateName.DataBindings.Add(
        "Text", aCandidates, "CandidateName");
    txtExamNumber.DataBindings.Add(
        "Text", aCandidates, "ExamNumber");

    // And bind the exam number to the list box value
    lbExams.DataBindings.Add(
        "SelectedValue", aCandidates, "ExamNumber");
}

private void btnPrevious_Click(object sender,
     System.EventArgs e)
{
       this.BindingContext[aCandidates].Position -= 1;
}

private void btnNext_Click(object sender,
    System.EventArgs e)
{
       this.BindingContext[aCandidates].Position += 1;
}

Understanding Step by Step 5.6 is crucial for the effective use of ComboBox and ListBox controls in applications. Using these controls can be a little tricky because the ListBox control is bound to two different things. Here's a review of how it all fits together:

• The ListBox control in Step by Step 5.6 draws the list of items to display from the array of Exam objects. The list portion of the list box is complex-data-bound to this array. The complex binding is managed by setting the DataSource, DisplayMember, and ValueMember properties of the ListBox control.
  
  
• The two TextBox controls are simple-data-bound to different elements in the array of Candidate objects. As you move through that array (with the btnNext and btnPrevious controls), the data displayed in those TextBox controls changes. This is, by the way, a two-way link. If you change the data in one of the TextBox controls, it's also changed in the array; you can see this by changing an entry, scrolling to another candidate, and then scrolling back.
  
  
• The SelectedValue property of the ListBox control is also simple-data-bound to an element in the array of Candidate objects. This sets up the link between the two arrays. As you choose an item from the list in the ListBox control, your choice is automatically pushed to the bound value from the Candidate array.
  
  
• Because the SelectedValue property of the ListBox control and the Text property of the txtExamNumber control are bound to the same value, they automatically stay in sync when either one is updated.
  
  
• You can use the DisplayMember and ValueMember properties of the ListBox control to cause it to show one value while binding another, as in Step by Step 5.6.
  
  

Binding to a DataGrid Control

The DataGrid control provides a way to display many rows from a data model at one time. The DataGrid control is designed to let you see an entire collection of data (often called a resultset) at one time.

private void StepByStep5_7_Load(object sender,
    System.EventArgs e)
{
    // Create an array of exams
    Exam[] aExams ={
      new Exam("315",
          "Web Applications With Visual C# .NET"),
      new Exam("316",
          "Windows Applications With Visual C# .NET"),
      new Exam("320", "XML With Visual C# .NET"),
      new Exam("305", "Web Applications With VB.NET"),
      new Exam("306",
           "Windows Applications With VB.NET"),
      new Exam("310", "XML With VB.NET")};

    // Bind the array to the data grid
    dgExams.DataSource = aExams;
}

The DataGrid control is a mainstay of data display for Visual C# .NET forms. As such, it is extremely configurable. Visual Studio .NET includes two interfaces for setting the display propeties of a DataGrid control. First, you can set individual properties to control the look of the DataGrid control in the Properties window. Second, you can use AutoFormats to quickly apply a whole new look to a DataGrid control.

When you need more precise formatting for a DataGrid control than the Auto Format dialog box allows, or when you just don't care for the look of any of the AutoFormats, you can set individual display properties for the DataGrid control. Table 5.1 lists the properties you can use to control the look of the DataGrid control.

Figure 5.5 shows a complex-data-bound DataGrid control that displays data from several database tables at one time, to help you understand where each of the areas mentioned in Table 5.1 is located. You'll learn how to bind database tables to the DataGrid control later in this chapter.

Figure 5.5. This figure displays the location of various formatting areas on a DataGrid control.

[View full size image]

using System;
namespace _316C05
{
    public class Employee
    {
        private Int32 employeeNumber;
        private String employeeName;
        private String position;
        private String homePlanet;

        public Int32 EmployeeNumber
        {
            get
            {
                return employeeNumber;
            }
            set
            {
                employeeNumber = value;
            }
        }

        public String EmployeeName
        {
            get
            {
                return employeeName;
            }
            set
            {
                employeeName = value;
            }
        }
        public String Position
        {
            get
            {
                return position;
            }
            set
            {
                position=value;
            }
        }
        public String HomePlanet
        {
            get
            {
                return homePlanet;
            }
            set
            {
                homePlanet=value;
            }
        }
        public Employee(Int32 intEmployeeNumber,
             String strEmployeeName,
             String strPosition,
             String strHomePlanet)
        {
            EmployeeNumber = intEmployeeNumber;
            EmployeeName = strEmployeeName;
            Position = strPosition;
            HomePlanet = strHomePlanet;
        }
    }
}

// Create and stock an array of data
Employee[] aEmployees = {
     new Employee(1, "E.E. Smith", "CEO", "Earth"),
     new Employee(2, "Melanie "Jets" Riggs",
        "Chief Pilot", "Mars"),
    new Employee(3, "William Danforth",
        "Pilot", "Mars"),
     new Employee(4, "Blaise Canton",
        "Engineer", "Luna"),
     new Employee(5, "Amanda Timmel",
        "CFO", "Earth")};

private void GuidedStepByStep5_1_Load(object sender,
    System.EventArgs e)
{
    // Bind data to the ui
    txtEmployeeName.DataBindings.Add(
        "Text", aEmployees, "EmployeeName");
    txtEmployeeName.DataBindings.Add(
        "Tag", aEmployees, "HomePlanet");
    txtPosition.DataBindings.Add(
        "Text", aEmployees, "Position");

    // Transfer the home planet info to the tooltip
    ToolTip1.SetToolTip(txtEmployeeName,
       txtEmployeeName.Tag.ToString());
}

private void btnPrevious_Click(object sender,
     System.EventArgs e)
{
    this.BindingContext[aEmployees].Position -= 1;
    ToolTip1.SetToolTip(txtEmployeeName,
        txtEmployeeName.Tag.ToString());
}

private void btnNext_Click(object sender,
    System.EventArgs e)
{
    this.BindingContext[aEmployees].Position += 1;
    ToolTip1.SetToolTip(txtEmployeeName,
       txtEmployeeName.Tag.ToString());
}

private void btnRoster_Click(object sender,
     System.EventArgs e)
{
    GuidedStepByStep5_1a f =
       new GuidedStepByStep5_1a();
    f.dgEmployees.DataSource = aEmployees;
    f.Show();
}
										

One-Way and Two-Way Data Binding

Data binding in Windows forms can be one-way or two-way. In one-way data binding, the bound property of the control reflects changes to the data model, but changes to the control are not written back to the data model. For example, if you display a list of customers in a ComboBox control, the act of selecting a customer from the ComboBox control does not do anything to modify the list.

In two-way data binding, changes to the control are written back to the data model. For example, if you have a TextBox control that is bound to the CustomerName property of a Customer object, changing the text in the TextBox control changes the corresponding property of the object.

Simple data binding on Windows forms is automatically two-way. Any changes you make to the data on the form are automatically transmitted back to the data model. However, it's important to note that the data model might not be the ultimate data source. The most common exception to this occurs when you use the ADO.NET classes to access data from a database and place it in a data model. Changes to bound data on a form are written back to the data model, but they are not automatically returned to the database (though you can write code to do this).

The BindingContext and CurrencyManager Classes

You saw the BindingContext and CurrencyManager classes earlier in the chapter, in the discussion of the overall architecture of data binding. Now that you've seen both simple and complex data binding in action, it's time to look at the BindingContext and CurrencyManager classes in somewhat more detail.

The BindingContext class exists primarily as a means to retrieve the CurrencyManager objects on a form. Table 5.3 shows the important interface members of the BindingContext class. In many applications, you can let Visual C# .NET manage these objects for you. But there are times when it's useful to work directly with these objects. For instance, the CurrencyManager class provides event hooks that let you react to modifications that the user makes to bound data.

The BindingManagerBase class is an abstract class that is implemented in both the CurrencyManager class and the PropertyManager class. You've already seen the CurrencyManager class. The PropertyManager class is used to manipulate the current value of an individual property, rather than the property of the current object in a list; you are unlikely to have any reason to use the PropertyManager class yourself. Table 5.4 shows the important interface members of the BindingManagerBase class.

The CurrencyManager class implements most of the interfaces of the BindingManagerBase class, and it includes a few others of its own. Table 5.5 lists the important interface members of the CurrencyManager class.

In addition to manipulating the Position property, you'll likely find the CurrencyManager class most useful for managing events on data-bound forms. Of course, because this class doesn't have a visual, control-based representation, you need to set up these events in code. Listing 5.1 shows how you can create delegates and respond to the events of the CurrencyManager class.

Listing 5.1. Trapping Events for the CurrencyManager Class

// Create an array of vendor objects
Vendor[] aVendors = new Vendor[3];

private void Listing5_1_Load(object sender,
    System.EventArgs e)
{
    // Initialize the vendors array
    aVendors[0] = new Vendor("Microsoft");
    aVendors[1] = new Vendor("Rational");
    aVendors[2] = new Vendor("Premia");

    // Bind the array to the text box
    txtVendorName.DataBindings.Add(
       "Text", aVendors, "VendorName");

    CurrencyManager cm =
      (CurrencyManager) this.BindingContext[aVendors];

    cm.CurrentChanged += new EventHandler(
         CurrencyManager_CurrentChanged);
    cm.ItemChanged += new ItemChangedEventHandler(
         CurrencyManager_ItemChanged);
    cm.PositionChanged += new EventHandler(
         CurrencyManager_PositionChanged);
}

private void CurrencyManager_CurrentChanged(Object o,
     EventArgs e)
{
    lbEvents.Items.Add("CurrentChanged");
}

private void CurrencyManager_ItemChanged(Object o,
     System.Windows.Forms.ItemChangedEventArgs icea)
{
    lbEvents.Items.Add("ItemChanged");
}

private void CurrencyManager_PositionChanged(Object o,
    System.EventArgs ea)
{
    lbEvents.Items.Add("PositionChanged");
}

private void btnPrevious_Click(object sender,
    System.EventArgs e)
{
    // Move to the previous item in the data source
    this.BindingContext[aVendors].Position -= 1;
}

private void btnNext_Click(object sender,
    System.EventArgs e)
{
    // Move to the previous item in the data source
    this.BindingContext[aVendors].Position += 1;
}

The names of the CurrencyManager class events may be a bit confusing. The ItemChanged event is fired when the data itself is changed by an external factor. For example, if you modify the data in an array and that array is bound to the user interface, the ItemChanged event occurs. The CurrentChanged event occurs when the data is changed on the user interface. This is true whether the user changes the data by typing a control or the CurrencyManager changes the data by responding to a change of the Position property. Finally, the PositionChanged event occurs when the Position property is changed. In practice, you see a CurrentChanged event whenever you see a PositionChanged event, but you can also get CurrentChanged events without a change in the Position property.

// Create and stock an array of data
Employee[] aEmployees = {
    new Employee(1, "E.E. Smith", "CEO", "Earth"),
    new Employee(2, "Melanie "Jets" Riggs",
        "Chief Pilot", "Mars"),
    new Employee(3, "William Danforth",
        "Pilot", "Mars"),
    new Employee(4, "Blaise Canton",
        "Engineer", "Luna"),
    new Employee(5, "Amanda Timmel", "CFO", "Earth")};

private void StepByStep5_9_Load(object sender,
      System.EventArgs e)
{
    // Bind data to the ui
    txtEmployeeName.DataBindings.Add(
       "Text", aEmployees, "EmployeeName");
    txtEmployeeName.DataBindings.Add(
        "Tag", aEmployees, "HomePlanet");
    txtPosition.DataBindings.Add(
        "Text", aEmployees, "Position");

    // Transfer the home planet info to the tooltip
    ToolTip1.SetToolTip(txtEmployeeName,
        txtEmployeeName.Tag.ToString());

    // Set up an event to update the tooltip
    CurrencyManager cm =
    (CurrencyManager) this.BindingContext[aEmployees];
    cm.PositionChanged +=
    new EventHandler(CurrencyManager_PositionChanged);
}

private void btnPrevious_Click(object sender,
     System.EventArgs e)
{
    this.BindingContext[aEmployees].Position -= 1;
}

private void btnNext_Click(object sender,
    System.EventArgs e)
{
    this.BindingContext[aEmployees].Position += 1;
}

private void CurrencyManager_PositionChanged(Object o,
    System.EventArgs ea)
{
    ToolTip1.SetToolTip(txtEmployeeName,
       txtEmployeeName.Tag.ToString());
}

If you compare the code in Step by Step 5.9 with the code from Guided Practice Exercise 5.1, you see that using the PositionChanged event can save you from writing duplicate code in every procedure where you might change the Position property of the CurrencyManager class.

Using the Data Form Wizard

Now that you've seen the mechanics of data binding, it's time to explore one of the tools that Visual C# .NET offers for automatic data binding: the Data Form Wizard. In the following sections, you'll see how to use the wizard to build both a single-table form and a multiple-table form. This helps you ease into the broad topic of using data from databases, which occupies the rest of this chapter and all of Chapter 6.

Building a Single-Table Data Form

You'll start by building a data form that displays data from a single table: the Customers table in the Northwind sample database.

Figure 5.13 shows the finished Data Form created in Step by Step 5.10. It contains 10 buttons, which have the following functions:

• Load— Load all the data from the database and bind it to the form.
  
  
• Update— Save all changes to the database.
  
  
• Cancel All— Discard all changes without changing the database.
  
  
• <<— Move to the first row.
  
  
• <— Move to the previous row.
  
  
• >— Move to the next row.
  
  
• >>— Move to the last row.
  
  
• Add— Add a new row.
  
  
• Delete— Delete the current row.
  
  
• Cancel— Cancel changes to the current row.
  
  

You might want to browse through the code that the wizard created behind this form. Be warned, though, that there are more than 600 lines of code involved in implementing this functionality! Obviously, the Data Form Wizard can save you a lot of time in building data-bound forms.

As you continue through the book, you'll learn more about database objects and the code that you can use to manipulate them. For now, you'll stick to the relatively easy user interface tools as you explore what can be done with data binding.

Building a Multiple-Table Data Form

You can use the Data Form Wizard to build a form that displays data from more than one table. Step by Step 5.11 explains how to do this.

As you select different Customer table rows in the upper DataGrid control on the form created in Step by Step 5.11, the lower DataGrid control changes to show only the Order rows for that customer. Figure 5.15 shows an example.

Once again, you'll find a tremendous amount of code (about 500 lines) behind this form. And once again, you'll leave it for future inspection.