There is a way to display properties of related objects in DataGridView, and you can take advantage of that here. The grid will be useful if it displays the reservation date, the start and end dates of the trip, and the destination of the trip. Destination comes from a navigation property of the Trip entity, so first we’ll need to modify the columns in the grid.

Edit the grid’s columns. You can make the ReservationID’s Visible property false, and then remove the TimeStamp, Customer, Trip, and Payments columns. Add three new TextBox columns named tripStartColumn, tripEndColumn, and destinationColumn. Make sure their ReadOnly property is True.

The trick to displaying the navigation properties is in the code. You must override the individual cells as the grid is being rendered for display, and the place to do this is in the DataGridView.RowPrePaint event. Example 8-2 shows how to do this.

VB
Private Sub ReservationsDataGridView_RowPrePaint _
 (ByVal sender As Object, ByVal e As _
  System.Windows.Forms.DataGridViewRowPrePaintEventArgs) _
  Handles ReservationsDataGridView.RowPrePaint

 'get a reference to the reservation currently being painted
  Dim res = _
      CType(ReservationsBindingSource.Item(e.RowIndex),BAGA.Reservation)
 'push the reservations's navigation properties into the correct cells
  With ReservationsDataGridView
    .Rows(e.RowIndex).Cells(tripStartColumn.Index).Value = _
     res.Trip.StartDate.ToShortDateString
    .Rows(e.RowIndex).Cells(tripEndColumn.Index).Value = _
      res.Trip.EndDate.ToShortDateString
    .Rows(e.RowIndex).Cells(destinationColumn.Index).Value = _
      res.Trip.Destination.DestinationName
  End With
End Sub

C#
private void reservationsDataGridView_RowPrePaint
 (object sender, DataGridViewRowPrePaintEventArgs e)
{

 //get a reference to the reservation currently being painted
  var res = (BAGA.Reservation)(reservationsBindingSource[e.RowIndex]);

 //push the reservations's navigation properties into the correct cells
  var grid = reservationsDataGridView;
  grid.Rows[e.RowIndex].Cells[tripStartColumn.Index].Value =
   res.Trip.StartDate.ToShortDateString();
  grid.Rows[e.RowIndex].Cells[tripEndColumn.Index].Value =
   res.Trip.EndDate.ToShortDateString();
  grid.Rows[e.RowIndex].Cells[destinationColumn.Index].Value =
   res.Trip.Destination.DestinationName;
}

Notice that you don’t have to add any additional querying or binding code into the form load. The fact that you have already bound the customers to the BindingSource is enough. The BindingSource will work out all of the relationships. In the form, as you navigate from one customer to the next, that customer’s reservations will be displayed in the grid (see Figure 8-9).

Figure 8-9. The sample with reservations added to the form

The trip start and end dates were formatted in the RowPrePaint event using ToShortDateString. To format the ReservationDate column, you’ll need an additional line of code in the Form Load event. After renaming the column to resDateColumn, the formatting code is as follows:

VB
ReservationsDataGridView _
.Columns(resDateColum.Index) _
.DefaultCellStyle.Format = "d"

C#
reservationsDataGridView
.Columns[resDateColumn.Index]
.DefaultCellStyle.Format = "d";

By default, the navigation toolbar disables the Save button when the toolbar is first created. Right-click the button and check the Enabled property in the context menu.

Before you can add the method to save data, you have to make an important change in the existing code. Currently, you are instantiating the BAEntities ObjectContext in the Form Load event. The context is not available outside the event.

When you query data with the context, by default the entities that result are managed by the context that keeps track of changes made to those entities. You can then use the ObjectContext.SaveChanges method to save those changes back to the data store. Although you will learn much more about this later in the book, here you’ll need to be aware of the fact that only the context that is tracking the changes is able to save them. You can’t instantiate a new context and expect it to save changes to the entities that you’re working with in the form. It won’t know anything about them.

Therefore, it is important to be sure that when you call SaveChanges, you are working with the same context you used to retrieve the data.

To do this in the form, you need to declare the context in the form declarations, not within a method. In this way, all of the form’s methods can work with the same context and you will be able to call SaveChanges in the Click event of the Save button.

Just beneath the line of code that declares the form, add the following code to declare the context:

VB
Public Class Form1
  Private context As BAGA.BAEntities

C#
public partial class Form1 : Form
{
  BAGA.BAEntities context;

In the form’s Load event, change the code that declared and instantiated the context so that it instantiates only the context, as shown in the following code snippet:

VB
context = New BAGA.BAEntities

C#
context = new BAGA.BAEntities();

In the form’s Design view, double-click the Save button to get to its Click event handler. Then add the SaveChanges code into the Click event, as shown in the following code:

VB
context.SaveChanges

C#
context.SaveChanges();

That is the complete code for saving all of the entity changes! There is no connection code, no need to build commands, and no need to worry about what entities are being saved or what types of changes are being made. Object Services reads all of the change information that it has kept track of for the entities that it is managing, and works out the proper commands (Insert, Update, or Delete) and then executes them.

If the model had any function mapping, Object Services would use stored procedures to perform the changes on the entities that have functions mapped to them.

In its current state, you can test edit a customer. Another tweak is necessary before you can edit the navigation properties, though, and yet another before you can add a new customer. So for now, try editing and saving the name fields of a customer.

Currently, the only activities and destinations in memory are those that are attached to the customers, and this may not even be all of the available options.

Instead, we’ll need the full lists, so we’ll need a new query to retrieve all of the activities and another for all of the destinations.

This will add a big benefit to the application. When the activities and destinations are queried, their objects are stored in memory. More specifically, they will be managed by the ObjectContext. This means it won’t be necessary to include the activity and destination data in the Customers query. When the customers are queried, they will still have the reference EntityKeys even if they don’t have the actual related entities. Figure 8-10 shows the PrimaryActivity and PrimaryActivityReference properties of a Customer that was queried without any of its related data.

Figure 8-10. PrimaryActivity and PrimaryActivityReference properties of a Customer that was queried without any of its related data

When the context creates the Customer, if the Activity object with that same EntityKey is already in the context, the two will be hooked up. The same happens if you were to query the customers first and then the activities.

So, now you can add the new queries and trim down the Customers query so that it doesn’t pull all of that extra data out of the database and over to the application. The new queries will be method queries so that you can keep your various querying skills tuned up.

At the same time, we’ll create two new form-level variables to contain the activities and destinations.

Add the new activities and destinations variables to the form declarations, as shown in Example 8-3.

VB
Public Class Form1
  Private context As BAGA.BAEntities
  Private activities As List(Of BAGA.Activity)
  Private destinations As List(Of BAGA.Destination)

C#
public partial class Form1 : Form
{
  BAGA.BAEntities context;
  List<BAGA.Activity> activities;
  List<BAGA.Destination> destinations;

Next, add the new queries shown in Example 8-4 into the form load and modify the existing Customers query to remove the extraneous navigations. Notice that Destination is also removed from the Reservations.Trip navigation path. Trip will also be able to find its related destinations in the context after they are created from the Destinations query.

VB
Private Sub Form1_Load _
 (ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load

  context = New BAGA.BAEntities
  activities =  context.Activities _
                .OrderBy(Function(a) a.ActivityName).ToList
  destinations = context.Destinations _
                 .OrderBy(Function(d) d.DestinationName).ToList
  Dim customers = context.Customers.Include("Contact") _
                  .Include("Reservations.Trip") _
                  .Execute(Objects.MergeOption.AppendOnly)

C#
private void Form1_Load(object sender, EventArgs e)
{
  context = new BAGA.BAEntities();
  activities = context.Activities
               .OrderBy((a) => a.ActivityName).ToList();
  destinations = context.Destinations
                 .OrderBy((d) => d.DestinationName).ToList();
  var customers = context.Customers.Include("Contact")
                  .Include("Reservations.Trip")
                  .Execute(Objects.MergeOption.AppendOnly);

Notice that the example uses ToList on the new queries instead of Execute. This data will be used only for pick lists and will not be edited directly, so you don’t have to worry about the BindingSource being able to pass along change information for activities and destinations to the context.

Now that the data for the lists exists, you can change the controls for PrimaryActivity and the other navigation properties to ComboBoxes so that it will be possible to edit a customer’s preferences.

You can bind the ComboBox controls in code or in the UI. Since there are four properties to change, let’s do both methods so that you can learn each one.

Replace the TextBox controls for the four target properties with ComboBox controls, giving them names to help you differentiate them. The FillCombos method in Example 8-5 performs the standard bindings for a ComboBox and additionally binds them to the Customer’s PrimaryActivity and PrimaryDestination navigation properties. Notice that the first argument for the new binding is SelectedItem. You may be more familiar with using Text in that argument. SelectedItem will cause the control to read the entire Activity object attached to the Customer and will work out how to match it up with the items in the ComboBox.

VB
Private Sub FillCombos()
  With PrimaryActivityComboBox
    .DisplayMember = "ActivityName"
    .ValueMember = "ActivityID"
    .DataSource = activities
    .DataBindings.Add _
      (New Binding("SelectedItem", CustomerBindingSource, _
                  "PrimaryActivity", True))
  End With
  With PrimaryDestinationComboBox
    .DisplayMember = "DestinationName"
    .ValueMember = "DestinationID"
    .DataSource = destinations
    .DataBindings.Add _
      (New Binding("SelectedItem", CustomerBindingSource, _
                  "PrimaryDestination", True))
  End With
End Sub

C#
private void FillCombos()
{
  PrimaryActivityComboBox.DisplayMember = "ActivityName";
  PrimaryActivityComboBox.ValueMember = "ActivityID";
  PrimaryActivityComboBox.DataSource = activities;
  PrimaryActivityComboBox.DataBindings.Add
   (new Binding("SelectedItem",customerBindingSource,
               "PrimaryActivity", true));

  PrimaryDestinationComboBox.DisplayMember = "DestinationName";
  PrimaryDestinationComboBox.ValueMember = "DestinationID";
  PrimaryDestinationComboBox.DataSource = destinations;
  PrimaryDestinationComboBox.DataBindings.Add
   (new Binding("SelectedItem",customerBindingSource,
               "PrimaryDestination", true));

Insert a call to the FillCombos method (FillCombos for VB or FillCombos(); for C#) into the form’s Load event You can put this line at the end of the existing code. Run the application again if you want to see how the ComboBoxes have been populated so far.

The other ComboBoxes will be bound in the UI. To do this, you will need to create one new Object data source for the BAGA.Activity class and one for the BAGA.Destination class. Then, in the form load, you will bind those new DataSources to the list variables, as shown in the following code:

VB
ActivityBindingSource.DataSource = activities
DestinationBindingSource.DataSource = destinations

C#
activityBindingSource.DataSource = activities;
destinationBindingSource.DataSource = destinations;

Using the ComboBox Tasks window, you can fill out three of the four properties for each ComboBox. Figure 8-11 shows the combo properties for the SecondaryActivity navigation property.

Figure 8-11. Binding some of the properties through the ComboBox Tasks window

The last property is not filled because you will need to set the SelectedItem property, not the SelectedValue property. Do this in the Properties window, as shown in Figure 8-12.

Figure 8-12. Binding the ComboBox selection using SelectedItem, which is available in the ComboBox Properties window

Now you can view, edit, and save these properties along with the rest of the customer data, as shown in Figure 8-13.

Figure 8-13. Editing the navigation properties with pick lists

We’ve established that clicking the plus sign icon adds a new Customer to the BindingSource, and that the CurrentChanged event is your first opportunity to work with the new Customer entity. But the CurrentChanged event is hit anytime the BindingSource points to a different Customer. You’ll need a way to discern the newly added Customer from those that already existed in the BindingSource.

One way might be to check the Customer’s ContactID, because it will not have been created yet. But if the user has added a number of customers prior to saving, ContactID=0 will not necessarily mean that the user just clicked the Add New icon.

Until you have more tools in your Entity Framework tool belt, the best way to determine a newly added Customer at this point is to use a flag to identify that a new Customer is being added to the BindingSource. We’ll employ a Boolean variable named adding for the flag.

Once that is in place, you will need to do the following for new customers:

Let’s see how to implement these steps.

Add the Boolean variable in Example 8-6 to the form’s declarations.

VB
Public Class Form1
  Private context As BAGA.BAEntities
  Private activities As List(Of BAGA.Activity)
  Private destinations As List(Of BAGA.Destination)
  Private adding As Boolean

C#
public partial class Form1 : Form
{
  BAGA.BAEntities context;
  List<BAGA.Activity> activities;
  List<BAGA.Destination> destinations;
  bool adding;

In the CustomerBindingSource.AddingNew event, set the adding flag to True, as shown in Example 8-7.

VB
Private Sub CustomerBindingSource_AddingNew _
 (ByVal sender As Object, _
  ByVal e As System.ComponentModel.AddingNewEventArgs)
 Handles CustomerBindingSource.AddingNew
    adding = True
End Sub

C#
private void customerBindingSource_AddingNew
 (object sender, AddingNewEventArgs e)
{
  adding = true;
}

In the CurrentChanged event, check the adding flag. If it is true, perform the steps outlined earlier on the new Customer. If adding is false, this logic will be skipped, as shown in Example 8-8. In this example, CustomerBindingSource.EndEdit is called prior to adding the related entities to the Customer. This method will trigger the BAEntities context to add the new Customer and therefore the context will also manage the new Contact entity properly. Without this method call here, you will experience problems when it comes time to call SaveChanges. Finally, note that the CustomerType is assigned with an EntityKey. You’ll learn more about assigning EntityReference.EntityKey in the next chapter.

VB
Private Sub CustomerBindingSource_CurrentChanged _
 (ByVal sender As Object, ByVal e As System.EventArgs) _
 Handles CustomerBindingSource.CurrentChanged
  If _adding Then
    CustomerBindingSource.EndEdit()
    Dim newcust = CType(CustomerBindingSource.Current, BAGA.Customer)
    If newcust.Contact Is Nothing Then
       newcust.Contact = New BAGA.Contact
       newcust.Contact.ModifiedDate = Now
       newcust.Contact.AddDate = Now
    End If
    newcust.InitialDate = Now
    newcust.CustomerTypeReference.EntityKey = _
     New EntityKey("BAEntities.CustomerTypes", "CustomerTypeID", 1)
     adding = False
  End If
End Sub

C#
private void customerBindingSource_CurrentChanged
 (object sender, EventArgs e)
{
  if (adding)
  {
    customerBindingSource.EndEdit();
    var newcust = (BAGA.Customer)customerBindingSource.Current;
    if (newcust.Contact == null)
    {
      newcust.Contact = new BAGA.Contact();
      newcust.Contact.ModifiedDate = DateTime.Now;
      newcust.Contact.AddDate = DateTime.Now;
    }
    newcust.InitialDate = DateTime.Now;
    newcust.CustomerTypeReference.EntityKey = 
     new EntityKey("BAEntities.CustomerTypes", "CustomerTypeID", 1);
     adding = false;
  }
}

You’ll need one last line of code for saving newly added customers. It’s not uncommon for the BindingSource to leave its current item in the “edit state.” With entities, this means that the changes in the UI won’t be pushed into the entities, and therefore SaveChanges will not see the need to do any updates to the database. BindingSource.EndEdit will ensure that the UI changes are registered with the entities. Add this method to the Save Item button’s Click event, just before SaveChanges is called, as shown in Example 8-9.

VB
Private Sub CustomerBindingNavigatorSaveItem_Click _
 (ByVal sender As System.Object, ByVal e As System.EventArgs) _
 Handles CustomerBindingNavigatorSaveItem.Click
  CustomerBindingSource.EndEdit()
  context.SaveChanges()
End Sub

C#
private void customerBindingNavigatorSaveItem_Click
 (object sender, EventArgs e)
{
  customerBindingSource.EndEdit();
  context.SaveChanges();
}

Run the form again and add a new customer. You’ll be able to enter name and preference information and save the record. Because the context is keeping track of additions and edits, it is possible to make changes to multiple records before clicking the Save button. When you do, all of the changes you have made to the list of customers, whether they were additions or edits, will be sent to the database. The best way to ensure that the code is working is to stop the application after you have saved your changes, and then start it again. This will force it to requery the database, and you can verify that the changes were definitely persisted to the store.

Not all of the form features will work. For instance, you will run into problems if you attempt to delete a customer, because of constraints in the database that we have not yet addressed. In upcoming chapters, you will learn how to perform this and other types of functions with your entities, how to add business logic, how to write layered applications, and more.

You could add plenty of features to this form to make it even more functional, but it’s time to move on to a different type of client-side data binding: data binding in WPF.

The original XAML of the txtStart controls will look like this:

<TextBox Height="23" Width="85" Margin="124,0,207,101" Name="txtStart"
         VerticalAlignment="Bottom" Grid.Column="0"/>

You’ll be adding a Binding element as a child of each TextBox, which means you’ll need to remove the slash at the end of the control so that you can add the TextBox closing element after the binding.

Example 8-12 shows what the txtStart and txtEnd controls will look like after you add the Binding elements.

<TextBox Height="23" Width="85" Margin="124,0,207,101" Name="txtStart"
         VerticalAlignment="Bottom" Grid.Column="0">
  <Binding ElementName="lstBoxTrips"
           Path="SelectedItem.StartDate"
                StringFormat="{}{0:MM/dd/yyyy}" />
</TextBox>

<TextBox Height="23" Width="85" Margin="0,0,54,101" Name="txtEnd"
         VerticalAlignment="Bottom" Width="120" >
  <Binding ElementName="lstBoxTrips"
           Path="SelectedItem.EndDate"
                 StringFormat="{}{0:MM/dd/yyyy}" />
</TextBox>

Binding a WPF ComboBox is similar to binding a Windows Forms ComboBox in that you need to set the source (ItemsSource) to a set of data, identify the value and display properties, and identify what source provides its value. We’ll bind to the ItemsSource in code, just as you did for the ListBox. Then we’ll use XAML to provide the rest of the information as you just did for the TextBox.

First, the code.

In the Window.Loaded event, bind the results of the Destinations and Lodgings queries to the ComboBoxes. You can add this right beneath the code for binding the lstBoxTrips control:

VB
cboDestination.ItemsSource = destinations
cboLodging.ItemsSource = lodgings

C#
cboDestination.ItemsSource = destinations;
cboLodging.ItemsSource = lodgings;

In the XAML, add more attributes to the ComboBox controls, rather than adding a child element as you did for the TextBoxes, as shown in Example 8-13.

Before:
<ComboBox Height="23" Margin="0,0,36,72" Name="cboLodging" Width="198"/>

After:
<ComboBox Height="23" Margin="0,0,36,72" Name="cboLodging" Width="198"
          DisplayMemberPath="LodgingName"
          SelectedValuePath="LodgingID"
          SelectedValue="{Binding ElementName=lstBoxTrips,
                         Path=SelectedItem.Lodging.LodgingID}"/>

The DisplayMemberPath and SelectedValuePath attributes refer to the properties of the list of lodgings to which you bound the ComboBox in code. SelectedValue gets the LodgingID from the currently selected trip in the ListBox.

Example 8-14 shows the XAML for the ComboBox that displays the selected trip’s destination.

<ComboBox Height="23" Margin="26,0,0,72" Name="cboDestination"
          DisplayMemberPath="DestinationName"
          SelectedValuePath="DestinationID"
          SelectedValue="{Binding ElementName=lstBoxTrips,
                         Path=SelectedItem.Destination.DestinationID}"/>

Now your form is starting to get interesting. When you run the application, the Start Date and End Date text boxes and the Destination and Lodging combo boxes should sync up to whatever trip is selected in the ListBox, as shown in Figure 8-15.

Figure 8-15. The form with the selection functionality enabled

You still have three more tasks to complete: viewing the activities for a trip, editing trip details, and adding new trips.

Activities and trips are joined in a many-to-many relationship. Although the Entity Framework can query across this type of relationship and coordinate inserts, updates, and deletes without you having to work directly with the Join table, there is one thing that the Entity Framework is unable to do with this type of relationship, which is explained in the following paragraphs.

In previous examples, you saw how Object Services can automatically wire up related objects that are in the context. It will find entities that are related and build graphs between them. You took advantage of this in the Windows Forms application earlier. Because the activities and destinations were being returned in their own queries, you were able to remove the Include paths to the Customer preference properties.

In the Window.Loaded event for this WPF form, you have a query that returns a list of activities. You will use this as a pick list when you create a new trip. So, since those activities are already in the cache, it would make sense that they will automatically be wired up to the existing trips. But they aren’t. This is expected behavior and you’ll need to either load the related data with Include or Load, or manually attach the entities. In this example, you will use an Include. You’ll learn more about this in Chapter 15.

The bottom line is that you need to change the Customer query in the Window.Loaded event. To do this, add an Include method to pull in the activities, as shown in the following code:

VB
trips = context.Trips.Include("Activities") _
               .OrderBy("it.Destination.DestinationName") _
               .ToList

C#
trips = context.Trips.Include("Activities")
               .OrderBy("it.Destination.DestinationName")
               .ToList()

Drag another ListBox onto the Window you are designing. You can take advantage of binding to get its data from the Trips ListBox just as you have done with the TextBoxes and ComboBoxes. The syntax is a little different because of the nature of the control.

The ListBox will look similar to when it is first added to the Window:

<ListBox Height="88" Margin="36,0,238,12" Name="lstActivities" />

You need to use a number of attributes to data-bind in a ListBox. For example, DataContext performs the binding to the source—in this case, lstBoxTrips. ItemsSource points to the actual items that will be used to populate the ListBox. You want the Activities EntityCollection of the selected trip for this attribute. Next, DisplayMemberPath identifies which property of the ItemsSource will be displayed in the box. ActivityName will do the trick here. Finally, the ListBox needs a little extra help syncing up with the source ListBox. You need to set IsSynchronizedWithCurrentItem to True.

Example 8-15 shows the modified ListBox with all of the data-binding attributes in place.

<ListBox Height="88" Margin="36,0,238,12" Name="lstBoxActivities"
     DataContext="{Binding ElementName=lstBoxTrips, Path=SelectedItem}"
     ItemsSource="{Binding Path=Activities}"
     DisplayMemberPath="ActivityName"
     IsSynchronizedWithCurrentItem="True"
/>

Don’t forget that you can set some of these values in the Properties window for the control. Figure 8-16 shows the IsSynchronizedWithCurrentItem and DisplayMemberPath properties. The other binding attributes are not available in the Properties window, so you’ll have to type them manually.

Figure 8-16. A modified view of the ListBox control’s Properties window showing some of the properties that you can modify

Once you have the ListBox control configured, you should be able to see the effect of having each trip’s activities displayed in this ListBox as you select different trips from the main ListBox. Figure 8-17 shows the application performing its newest trick.

Figure 8-17. The WPF form with the Activities ListBox displaying an EntityCollection

You might prevent destinations from being edited on existing trips, but you’ll need to use that ComboBox for new trips. If the user changes the trip’s destination, you won’t see the change on the ListBox.

WPF provides a way to sort the items of list controls with a SortedDescriptions collection. If you re-sort the list after the user selects a destination from the combo box, the list will be refreshed, the new destination name will appear, and the item will be properly sorted using the new name.

Add the code in Example 8-18 to the end of the cboDestination’s SelectionChanged event.

VB
lstBoxTrips.Items.SortDescriptions.Add _
  (NewSortDescription("Destination.DestinationName", _
                      ListSortDirection.Ascending))
lstBoxTrips.Items.SortDescriptions.Add _
  (New SortDescription("StartDate", ListSortDirection.Descending))

C#
lstBoxTrips.Items.SortDescriptions.Add
 (new SortDescription("Destination.DestinationName",
                      ListSortDirection.Ascending));
lstBoxTrips.Items.SortDescriptions.Add
 (new SortDescription("StartDate", ListSortDirection.Descending));

Run the application, select a trip, and add some activities. You’ll see the Activities ListBox react. You can save the changes with your existing Save method. Note that since the data is not refreshed, again you’ll want to stop and start the application for proof that the change was saved.

Before modifying the new button’s Click event, you’ll need to make two changes that are related to WPF’s data binding and are not specifically related to the Entity Framework.

In the Windows form, you had a BindingSource to coordinate between the controls and the data. WPF has no such control; however, it does have another mechanism, called the ObservableCollection. Without getting too sidetracked, if you use an ObservableCollection of trips as the source for the Trip ListBox control, as you add and remove items from this collection the ListBox will respond by adding or removing the items from the display.

It’s worth the effort to use this rather than a ListBox so that you won’t have to write the extra code to stuff your new trip into the ListBox.

To pull this off, you’ll need a new variable that is scoped to the whole Window class. Add this to the Window’s declarations. We’ll instantiate it in the declaration so that it’s ready to use in the Window.Loaded event.

VB
Private ObservableTrips As New ObservableCollection(Of Trip)

C#
private ObservableCollection ObservableTrips = new ObservableCollection();

In the Window.Loaded event, after the Trips query has been executed, transfer the trip results into the new collection. Then change the ItemsSource of the Trips ListBox to this new collection, as shown in the following code:

VB
For Each t In trips
  ObservableTrips.Add(t)
Next
lstBoxTrips.ItemsSource = ObservableTrips

C#
foreach (var t in trips)
{
  ObservableTrips.Add(t);
}
lstBoxTrips.ItemsSource = ObservableTrips;

Now when you add new trips to the collection, they will automatically pop into the ListBox. But they’ll be at the bottom and will remain there until you run the application again. That’s no good. You can get the ListBox to sort on the DestinationNames and StartDates using this WPF code, which is very different from what you might be used to with Windows Forms or ASP.NET applications.

You can copy the sorting code from the Destination ComboBox’s SelectionChanged event into the Window.Loaded event to benefit from the sorting early on. In this way, if you add a new trip before you hit the other location where the sort is applied, the new trip will drop into the correct position in the ListBox. With the ListBox controlling the sort, you can remove the OrderBy method in the Trips query.

With that functionality in place, you can now add a new trip and have the form respond in an expected manner.

The Click event of the New Trip button will add a new trip, set some default values, and add the trip into the ListBox’s items (see Example 8-20).

VB
Private Sub btnNewTrip_Click _
 (ByVal sender As System.Object, _
  ByVal e As System.Windows.RoutedEventArgs) Handles btnNewTrip.Click

 'create a new Trip object with default date values
  Dim newtrip = New Trip
  newtrip.StartDate = Today
  newtrip.EndDate = Today

 'add a default destination. Sorting will fail if Destination is null
   newtrip.Destination = destinations[0]

 'add the trip to the context so that its changes will get tracked
   context.AddToTrips(newtrip)

 'add the new trip to the bound collection
   ObservableTrips.Add(newtrip)
 'select the new trip so that the bound controls will be tied to it
   lstBoxTrips.SelectedItem = newtrip

End Sub

C#
private void btnNewTrip_Click
 (object sender, System.Windows.RoutedEventArgs e)
{
 //create a new Trip object with default System.DateTime values
  var newtrip = new Trip();
  newtrip.StartDate = System.DateTime.Today;
  newtrip.EndDate = System.DateTime.Today;

 //add a default destination. Sorting will fail if Destination == @null
  newtrip.Destination = destinations[0];

 //add the trip to the context so that its changes will get tracked;
  context.AddToTrips(newtrip);

  //add the new trip to the bound collection
   ObservableTrips.Add(newtrip);
  //select the new trip so that the bound controls will be tied to it
   lstBoxTrips.SelectedItem = newtrip;
}

You may want to consider using one last bit of code: validation code for the new trip.

You can call the short method shown in Example 8-21 prior to calling SaveChanges to prevent your demo from blowing up if the user gets click-happy. It just checks to make sure that any new trips have a destination and valid start and end dates. If it returns False, it displays some type of message and doesn’t call SaveChanges.

VB
Private Function validateNewTrips() As Boolean
  Dim newtrips = From t In ObservableTrips _
                 .Where(Function(t) t.TripID = 0)
  For Each Trip In newtrips
    If Trip.Lodging Is Nothing Then
        Return False
    ElseIf Trip.StartDate < Today Then
      Return False
    ElseIf Trip.EndDate < Trip.StartDate Then
      Return False
    End If
  Next
  Return True 'when newTrips.Count=0 or all trips validate
End Function

C#
private bool validateNewTrips()
{
  var newtrips =
    from t in ObservableTrips.Where(t => t.TripID == 0)
    select t;
  foreach (var Trip in newtrips)
  {
   if (Trip.Lodging == null)
     return false;
   else if (Trip.StartDate < System.DateTime.Today)
    return false;
   else if (Trip.EndDate < Trip.StartDate)
    return false;
 }
 return true; //when newTrips.Count==0 or all trips validate
}

Run the demo again and check out the new features. When you add a new trip, watch how smoothly the bound Trip ListBox displays the new trip at the top of the ListBox. When you change the default destination, the trip will reappear alphabetically sorted in the ListBox, but still selected. Add some activities to the new trip. Save your changes and restart the application to prove that it all really worked (see Figure 8-18).

Figure 8-18. The final WPF form with all of its features in place