This Saturday we will cover Kalani's chapter 5, "Data Binding".   I think this is an interesting chapter,  both for the subject itself and for the surprising lack of coverage elsewhere.   This chapter in Kalani was the first time I had heard about Data Binding at all.

Data binding in .NET is the establishment of links between data as displayed to the user and data as held in the machine's internal memory.   It is not  linkage between either of these and data held externally,  say,  in a file or relational database.   (Data Binding in .NET is therefore utterly different from Data Binding in Java.)  

You will find that it also has some tricky lines of code,  such as the combination of simple and complex data binding shown by example 5.6,  on pages 367-369.   The text itself says (page 369):  "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."   Kalani then goes on to try to explain it.   Well, good luck.

Here is a summary of the chapter:

He omits  try  and  catch.   (But he says so in the box on page 439,  adding,  about error-handling:  "You must use it in real-life programs.")   It is in fact fatally easy to fall into this error.   You want to see a really annoyed TA?   Try leaving  try  and  catch out of your code,  and having the TA discover that your code won't run on his or her machine.  

You will find error-handling code to use while reading databases  here.  

Simple Data Binding

• It's the linkage of a single-item display  (such as a text box)  with a single item or row from a list or collection of such items.
• You will find,  of course,  that "simple" data binding is altogether more complicated and hard to use than "complex" data binding.   But the first example is easy enough.   You should understand the "Add" method:

      textBox1.DataBindings.Add("Text", collection, "path within collection");

  Here,  Text is the name of the property of the control being bound.   Notice the pattern of the last two arguments:  collection  is an object,  and the  path  is a string describing something within that collection.   This pattern will recur.  
• What sort of thing can be bound?   A collection implementing an  IList  interface,  or something like it.   See Kalani,  "Bindable Entities",  page 358.
• The  BindingContext  object.  
  • The context is defined for the list object,  not for the control which first declared itself bound.   See Kalani's example on page 360.   Kalani uses buttons with "<" and ">" on them,  but I think it's easier to use a horizontal scroll bar—or, at least I thought it was,  before I found out how tricky scroll bars can be.   You have to be very careful about setting the  Maximum  for scroll bars:  it's apparently

            hScrollBar1.Maximum = Count + hScrollBar1.LargeChange - 2;

  • You increment or decrement  BindingContext[boundListObject].Position  to move around the bound list.   This is how you move to the next item in a list:

            this.BindingContext[boundListObject].Position++;

  • What is returned in that expression by the  BindingContext[boundListObject]  expression is a  CurrencyManager  object.   The previous expression to move to the next bound item is therefore the same as

            ((CurrencyManager)this.BindingContext[boundListObject]).Position++;

    (Yes,  the name  "CurrencyManager"  is unfortunate.   But the word  "concurrency"  is already used for something else.)   The point is that you get exactly one  CurrencyManager  object for the collection,  no matter how many items from that collection you display.   This allows you to synchronize the various items you display.   (But some container objects may have separate  BindingContext  objects.)

Complex Data Binding

• It's the display of many of the items in a list or collection.
• In its common form,  almost trivial to use.   Assuming you've read a database table into a DataSet  (there's code to do this  here),  all you need to do is put a DataGrid on your Form and then say

      dataGrid1.DataSource = dataSet1;

  That's all there is to it,  although it might look a little better if you add

      dataGrid1.DataMember = dataSet1.Tables["Customers"];

  because then this table will come up on the DataGrid automatically.

Combining Simple and Complex Data Binding

• Kalani has a particularly tricky piece of code on page 369.   It's an example of binding a ListBox two different ways:  with complex binding to an array of objects,  and with simple binding to its Selected Value.   You  (well,  maybe we)  will have to stare at this for a minute.
• After that,  complex binding to a DataGrid looks trivial.   (There's an example  here.)
• Kalani mentions  AutoFormat  for DataGrids on page371.   Well,  all right,  look at it;  but I can't get very excited about it.
• The same thing is true for the various display properties of DataGrids that Kalani lists on pages 372-3:  look at them, but don't go blind.
• You should look at the examples on pages 374 so that you are familiar with programming events for binding.
• You should also be familiar with the members of the  BindingContext  and the  CurrencyManager  classes.   Kalani doesn't really use these in the example on page 382;  he just lets you know when they occur.

Data Wizards

Pages 385-391 in Kalani show how to use Wizards to generate DataGrids that display relational data.   You should try a couple of these,  and you should look at the generated code,  especially at the declarations of things like  DataSource  and  DataMember  for the related tables as displayed in the DataGrids.   This also applies to exercise 5.4 on page 414,  where Kalani creates two DataGrids in a parent-child relationship,  while writing only a single word of code.  

The Server Explorer

This is the pane which competes with the ToolBox in the upper left corner of the screen.

• Kalani, page 394, talks about the  "Data Connections"  node  (the top node)  and how,  if you right-click it,  you can fill out a dialog box with all sorts of information about your connection to the database.   You can connect to the SQL Server database more easily in other ways,  and I can't imagine that this will be on the exam.   (You would need this form if you were connecting to other machines or databases from other providers.)
• If you expand the nodes in the Server Explorer:

      SQL Server / Machine / Northwind / Tables / < specific table >

  you can see the data and the design of the table by right-clicking on the table and choosing one.  
  • You can see the data in the table by simply double-clicking on the table name in the Server Explorer.
  • You may edit the data in the table after doing this.
  • You may create views on the server, as described below.
• Drag-and-drop from Server Explorer.   You really ought to know these for your own convenience:
  • Drag a database,  get a  SqlConnection
  • Drag a table,  view,  table column,  or view column,  get a  SqlDataAdapter  and a  SqlConnection
  • Drag a stored procedure or a table-valued function,  get a  SqlCommand  and a SqlConnection
  • You will need  using System.Data.SqlClient;  atop your program to use these objects
  • These objects have no visible component,  and appear below your Form layout
  • You should do some of the examples in Kalani,  such as those on page 398,  and see what kind of code is generated.   In almost all of these examples,  though,  you still have to supply the  "Fill"  command to get something into the table:

    	sqlDataAdapater1.Fill(dataSet, "Table");

  • We will talk about the  "Generate DataSet"  option and strongly typed DataSets next week.

Filtering and Transforming Data

There are obviously two ways to doing this.   Choosing between these methods is a serious question in the design of your database and programs.   Ask our Mr. Holley about the 70-229 exam he's studying for.   It's on SQL Server Database Design.

• You can use a  DataView  object on the client  (your PC).   This can only be used to select rows from a table.   Kalani's code for this is on page 401.   You create the  DataView  just after you do the  Fill()  operation.   You can then sort:

  dataview.Sort = "SomeColumnName";

  or you can filter rows:

  dataview.RowFilter = "ColumnName = 'value'";  //Note the single quotes

  You then bind the resulting  DataView  to a  DataGrid  by using the grid's  DataSource  property.

  Incidentally,  Kalani has some examples  (exercise 5.2,  starting on page 407,  and exercise 5.5,  starting on page 415)  that use  DataView.RowFilter  to select rows to display from a detail table.   My sample code,  available  here,  does this using a  DataRelation  instead.   A DataRelation is set up in a DataSet to relate two tables using their columns which contain matching keys.  

• The second way of filtering data uses the database server:  you create a view on a database table and then base a  SqlDataAdapter  object on that view.   A view is a non-persistent table.   This method will allow you to select columns from existing tables.   To do this,  follow instructions like those in Kalani, pages 402-3:  in Server Explorer, open the Northwind database,  and right-click on the  "Views"  node.   This will allow you to create a new view.   Here you can specify which tables you want as input  (you can combine tables),  which columns you want from those tables,  and your criteria for sorting and selecting the rows.   You save this new view under a new name, and give this name in your  Select  command.   Otherwise,  the code is exactly the same as for any other table-read operation.  
• Such server-side view creation also allows  data transforming.   In creating a new view,  you can tie two database tables together and select columns from the combination to create a new view.   You can then read this view into a DataGrid, using an altered  Select  command.   Clearly this is a good approach to take when you want to reduce the amount of data brought to your PC from a database.  

See you Saturday.

This chapter's questions in long Kalani vary in quality.   The questions are generally good,  except for these:

• Question 3,  I think,  is pointlessly picky.   I don't see much difference even after looking at the description of the events involved.
• Question 5 is so poor I won't take class time for it.   You don't need the second table for the answer at all.
• Question 7 has been changed by the  publisher's errata.    Make sure your question includes this sentence:  "You want to ensure that data access code does not generate conflicts with the existing names of the tables or columns."
• Question 8 has lousy choices for answers.   The question is useful,  though,  if you think about what you would really  do in this situation.

    Test 1:  questions  1  (page 350;  answer:  page 388),  2,  14,  15,  16.

• Test 1, question 1:  For some reason,  answer D has "rows" instead of "columns".

    Test 2:  questions  3  (page 403;  answer:  page 439),  12.

(Some of these questions may duplicate those in long Kalani.   Both texts are listed  here.)