In terms of LightSwitch, Garth is one of most talented individuals that I know. For me, it’s been pleasure finding out and seeing the projects that he’s worked on.

You can find out more by visiting the following link.

http://blogs.msdn.com/b/ukmsdn/archive/2011/08/08/lightswitch-in-the-real-world.aspx

LightSwitch includes a changed event but the problem with using this is that it only fires after leaving the TextBox. You therefore don’t see the characters being upper cased as you type into the control.

One possible workaround is to handle the KeyUp event of the TextBox control. In keeping with the standard practice of handling Silverlight control events, the ControlAvailable event is used to attach the KeyUp event of the Textbox.

Assuming that you have a TextBox named ‘Surname’, here is some sample code that automatically upper cases the characters as you type into the control. The ‘SelectionStart’ property is used to set the cursor location to the end of the TextBox, otherwise you end up with some strange behaviour as subsequent text will be inserted into the start of the TextBox.

Private Sub MyScreen_Activated()
    AddHandler Me.FindControl("Surname").ControlAvailable, AddressOf TextBoxAvailable
End Sub

Private Sub TextBoxAvailable(sender As Object, e As ControlAvailableEventArgs)
    AddHandler CType(e.Control, System.Windows.Controls.TextBox).KeyUp, AddressOf TextBoxKeyUp
End Sub

Private Sub TextBoxKeyUp(sender As Object, e As System.Windows.RoutedEventArgs)
    Dim strTextUpper As String = CType(sender, System.Windows.Controls.TextBox).Text.ToUpper
    CType(sender, System.Windows.Controls.TextBox).Text = strTextUpper
    CType(sender, System.Windows.Controls.TextBox).SelectionStart = strTextUpper.Length
End Sub

Here’s the C# version.

private void CreateNew_Activated()
{
    this.FindControl("Property1").ControlAvailable += TextBoxAvailable;
}

private void TextBoxAvailable(object sender, ControlAvailableEventArgs e)
{
    ((System.Windows.Controls.TextBox)e.Control).KeyUp += TextBoxKeyUp;
}

private void TextBoxKeyUp(object sender, System.Windows.RoutedEventArgs e)
{
    string strTextUpper = ((System.Windows.Controls.TextBox)sender).Text.ToUpper;
    ((System.Windows.Controls.TextBox)sender).Text = strTextUpper;
    ((System.Windows.Controls.TextBox)sender).SelectionStart = strTextUpper.Length;
}

http://channel9.msdn.com/Events/TechEd/NorthAmerica/2011/DEV354

For those who haven’t watched this, the following post contains some screenshots from the video illustrating how this works. (I would still recommend watching the video however. The toolkit section appears at 55min).

The toolkit goes a long way to simplifying the creation of extensions. The current method of creating extensions using the “Cookbook” is fairly time consuming. In particular, the errors that could be encountered when renaming everything from “BlankExtension” can be very painful.

Screenshots

With the Extension Library installed, opening Visual Studio and selecting “New Project” shows the following Extension templates.

Creating a new project based upon the above template creates a solution with the following projects.

The above projects correspond to the projects in a regular LightSwitch project (for example Client, Common, Server, etc) You will notice 2 additional project which are the “Vsix” and “Lspkg” projects. The output from the Vsix project will be used to install the completed extension into Visual Studio.

LSPKG stands for “LightSwitch Packaging Project”. Right clicking on this and choosing “New Item” brings up the following screen.

From here, templates relating to the 6 LightSwitch Extensibility points are available.

• Business Types
• Custom Controls
• Data Source
• Screen Template
• Shell
• Theme

Selecting the “Theme” option will create a theme which includes all the display elements. You can simply modify the fonts and colours to suit your style.

Although this toolkit has not yet been released, it should hopefully simplify the creation of extensions to a very large degree.

In all honesty, I knew very little about this award until today and still don’t know who nominated me nor what was involved in me being awarded this prize.

I’m very grateful to those who were influential in this process. In particular, I’d like to thank all my friends at Microsoft UK and I also want to give a special mention to everyone in the Microsoft LightSwitch team who are currently doing a spectacular job.

Much was covered during the event but some of the main points whichI took away were:

• Reducing rework is one of the key principles of BDD
• This is achieved by fully testing and involving the customer during each iteration
• Analysis of typical applications reveal that 45% of features are never used. 7% of features are regularly used. There is much inefficiency is software as a large percentage of features are never used.
• ‘5 Whys’ – recursively asking why something is required 5 times can often reveal the real purpose of a requirement
• The ‘Purpose Alignment Model’ can be used to work out features which add the most business value. This comprises of a chart with ‘Market Differentiation’ on the y-axis and ‘Mission Criticality’ on the x-axis. By using this to understand the purpose of a project, we stand a much greater chance of achieving the objectives.

Various tools such as Fit, Cucumber and Nbehave, Nunit, Mspec were also discussed.

I found Ian’s presentation very useful and so did many in the audience judging by some of the questions. Thanks for presenting Ian!

 
Illustration of what happens when installing under XP SP2.

http://blogs.msdn.com/b/ie/archive/2011/05/03/deleting-flash-cookies-made-easier.aspx

In previous versions of Flash, the only way of clearing cookies was to use the Adobe ‘Settings Manager’ via the following web site.

http://www.macromedia.com/support/documentation/en/flashplayer/help/settings_manager07.html

The security risk this posed was that even after deleting your browser history, someone using your PC could partially trace your browsing history and the videos that you’ve viewed using Flash cookies or the ‘Settings Manager’ shown above. Websites were also using Flash cookies to restore ‘regular HTTP cookies’ which may have been intentionally deleted by the user.

This update appears to have been long overdue and is a very positive change in terms of improving browser privacy.

One of the annoyances about the LightSwitch AutoCompleteBox is that there isn’t an option to limit selections to only those items which are shown in the list. Non existent values can be typed in, causing validation errors to occur when a screen is saved.

Fig 1 – Illustration of AutoCompleteBox failing to limit selections.

Fortunately, the Silverlight ComboBox control can limit items to the list and the following article describes how we can use this control on a LightSwitch screen.

In the following example, we’ll create a customer entry screen and allow the user to select from a list of available Countries.

Data

The example solution contains a Person table and a Country table. The table schemas and relationships are illustrated in the following images below.

Fig 2 – Illustration of Person table

Fig 3 – Illustration of Country table

Fig 4 – One to Many relationship between Country and Person 

Screens

The following section describes the creation of the screens in the project..

1. First of all, create an ‘Editable Grid Screen’ on the Country table to enable some Countries to be added.
2. Create a ‘New Data Screen’ on the Person table.
3. By default, an ‘AutoCompleteBox’ is created on the Country field. Change this to ‘Custom Control’ using the drop down list to the left of the control. After doing so, bring up the properties of the control and click on the ‘Change…’ link next to the ‘Custom Control’ field. In the dialog that appears, select the ‘ComboBox’ control from within the System.Windows.Controls namespace.

    
   Fig 5 – Changing the AutoCompleteBox to a ComboBox

4. We now need to create a data source in order to populate our ComboBox with a list of available Countries. In order to do this, click on the ‘Add Data Item’ button, select the ‘Query’ radio button and select ‘Countries – Country (All)’. Retain the default name of ‘Countries’.

   
   Fig 6 – Creating a data source for our ComboBox
    

5. We now need to write some code to bind our ComboBox to the person entity. Click on ‘Write Code’ button and select the ‘_Activated’ event. Now write the following code:

Private Sub CreateNewPerson_Activated()
    Dim comboControl As IContentItemProxy = Me.FindControl("Country")
    comboControl.SetBinding(System.Windows.Controls.ComboBox.ItemsSourceProperty, "Screen.Countries", Windows.Data.BindingMode.TwoWay)
    comboControl.SetBinding(System.Windows.Controls.ComboBox.SelectedItemProperty, "Screen.PersonProperty.Country", Windows.Data.BindingMode.TwoWay)
End Sub

Here’s the C# equivalent…

private void CreateNewPerson_Activated()
{
    IContentItemProxy comboControl = this.FindControl("Country");
    comboControl.SetBinding(System.Windows.Controls.ComboBox.ItemsSourceProperty, "Screen.Countries", System.Windows.Data.BindingMode.TwoWay);
    comboControl.SetBinding(System.Windows.Controls.ComboBox.SelectedItemProperty, "Screen.PersonProperty.Country", System.Windows.Data.BindingMode.TwoWay);
}

6. Now run our application and open the ‘Create Person’ screen. The list of Countries is now limited to those shown in the list.
   
   Fig 7 – Illustration of final screen showing the ComboBox which can not be typed into.

Conclusion 

This article demonstrates how we can limit drop down choices by using a Silverlight ComboBox. It also illustrates the data binding syntax which is used when binding custom controls. The image below illustrates the relationship between the designer and the call to the SetBinding method. This is particularly relevant when creating a ‘details screen’ as the default entity will be ‘Person’ rather than ‘PersonProperty’.

Fig 8 – Illustration of DataBinding Code

The LightSwitch AutoCompleteBox allows you select records using a dropdown list or to enter some text into the control. Typing into the AutoCompleteBox filters down the selectable records.

If a non existent record entered, it’s likely that a new record is required based upon the entered text. 

The following example uses a set of Customer and Category tables. A Customer belongs to a Category and the following sample demonstrates a ‘New Data Screen’ for creating a new Customer. The screen contains an AutoCompleteBox which allows a category to be selected. If a non existent category is typed in, the user will be prompted to save the new category prior to saving the customer record.

Data

The following screenshots illustrate the schema of our tables. A ‘zero or one’ to many relationship has been set up between the Category and Customer tables.

Fig 1 – Category table schema

Fig 2 – Customer table schema

Fig 3 – Relationship between the 2 tables

Screens

Here are the steps to create our ‘Customer’ screen.

1. Create a new ‘Editable Grid Screen’ for entering in some Category details
2. Create a ‘New Data Screen’ based upon the Customer table
3. In order to programmatically access the AutoCompleteBox, we need to add a reference to System.Windows.Controls.Input in the client project. To do this, switch to ‘File Mode’ in solution explorer.
   
   Fig 4 Switch to File View in Solution Explorer

4. Right click the  ‘Client’ folder and click ‘Add Reference’. Select System.Windows.Controls.Input
   
   Fig 4 Add a reference to System.Windows.Controls.Input

5. We need to write some code to handle the LostFocus event of the AutoCompleteBox. However, this can only be done when the AutoCompleteBox becomes available. We therefore need to write an event handler for the ‘ControlAvailable’ event and to add the handler for the LostFocus event there. Click on the ‘Write Code’ button and click and select the ‘CreateNewCustomer_Created’ event. Add the following code:

   Private Sub CreateNewCustomer_Created()
       AddHandler Me.FindControl("Category").ControlAvailable, AddressOf CategoryFieldAvailable
   End Sub
   
   Private Sub CategoryFieldAvailable(sender As Object, e As ControlAvailableEventArgs)
       AddHandler CType(e.Control, System.Windows.Controls.Control).LostFocus, AddressOf CategoryFieldChanged
   End Sub
   
   Private Sub CategoryFieldChanged(sender As Object, e As System.Windows.RoutedEventArgs)
   
       'Add a reference to System.Windows.Controls.Input.dll in the Client project
       Dim txtComboText As String = CType(sender, System.Windows.Controls.AutoCompleteBox).Text
       Me.Details.Dispatcher.BeginInvoke(
           Sub()
               If txtComboText <> "" Then
                   Dim selectedCategory As Category = Me.DataWorkspace.ApplicationData.Categories.Where(Function(Category) Category.CategoryName = txtComboText).FirstOrDefault
                   If selectedCategory Is Nothing Then
                       'Category doesn't exists
                       If Me.ShowMessageBox("Do you want to add the category " & txtComboText & "?", "Add Category", MessageBoxOption.YesNo) = Windows.MessageBoxResult.Yes Then
                           selectedCategory = Me.DataWorkspace.ApplicationData.Categories.AddNew()
                           selectedCategory.CategoryName = txtComboText
                           Me.CustomerProperty.Category = selectedCategory
                       End If
                   End If
               End If
           End Sub)
   
   End Sub
   

   Here’s how the C# equivalent looks like:

   private void CreateNewCustomer_Created()
   {
       this.FindControl("Category").ControlAvailable += CategoryFieldAvailable;
   }
   
   private void CategoryFieldAvailable(object sender, ControlAvailableEventArgs e)
   {
       ((System.Windows.Controls.Control)e.Control).LostFocus += CategoryFieldChanged;
   }
   
   private void CategoryFieldChanged(object sender, System.Windows.RoutedEventArgs e)
   {
       //Add a reference to System.Windows.Controls.Input.dll in the Client project
       string txtComboText = ((System.Windows.Controls.AutoCompleteBox)sender).Text;
       this.Details.Dispatcher.BeginInvoke(() =>
       {
           if (!string.IsNullOrEmpty(txtComboText)) {
               Category selectedCategory = this.DataWorkspace.ApplicationData.Categories.Where(Category => Category.CategoryName == txtComboText).FirstOrDefault;
               if (selectedCategory == null) {
                   //Category doesn't exists
                   if (this.ShowMessageBox("Do you want to add the category " + txtComboText + "?", "Add Category", MessageBoxOption.YesNo) == System.Windows.MessageBoxResult.Yes) {
                       selectedCategory = this.DataWorkspace.ApplicationData.Categories.AddNew();
                       selectedCategory.CategoryName = txtComboText;
                       this.CustomerProperty.Category = selectedCategory;
                   }
               }
           }
       });
   
   }
   

   In the above code, we obtain the text that has been entered using the ‘Text’ property of the AutoCompleteBox. If the text is not empty, we attempt to look up the Category in the Category table. If the Category isn’t found, we use ‘ShowMessageBox’ to prompt the user to save the new Category. After the new Category is saved, we set the Category property on the Customer entity equal to the Category which has just been created.

6. Now run the application. Here are some illustrations showing the application in action. We begin by having just a ‘High Risk’ Category in the database.

   

   In the ‘Create New Customer’ form, we enter a Firstname, Surname and type ‘Low Risk’ into the Category AutoCompleteBox. When we leave the Category AutoCompleteBox, the following dialog appears.

   

   If we click ‘Yes’, the Customer record is saved into the database. If we now return to the Category screen, we see that the ‘Low Risk’ category has also been added into the database.

   

Conclusion

This article illustrates how records can be added using an AutoCompleteBox. The sample solution could benefit from some refinement but highlights various principles required in order to put together a working screen.

The example solution can be downloaded from the following link.

http://cid-7a042700ee409d7b.office.live.com/self.aspx/LightswitchFiles/CustomerCategory3.zip

There are various screen events available in LightSwitch. At the moment, there isn’t very much documentation specifying the order in which these events fire.

The following post documents my findings in relation to the ordering of events.

Methodology

Having created a details screen based on a ‘Customer’ entity, this is a typical screen which is created by default. The name of the screen is ‘CustomerDetail’ and the name of the Customer entity is ‘Customer’.

Fig 1 Illustration of Details screen

The following screenshot shows the available events. There are 3 property/entity events and 7 screen events. ‘CustomerId’ is the name of the property that relates to the screen parameter.

Fig 2 Events that are available

In order to work out the order in which these events fire, I’ve written some code showing a message box on each event. Here are my findings:

Order of events when opening a screen

1. New
2. CustomerId_Changed
3. CustomerDetail_InitializeDataWorkspace
4. CustomerDetail_Created
5. CustomerDetail_Activated
6. Customer_Validate
7. CustomerId_Validate
8. Customer_Loaded

Order of Events when changing a field and clicking ‘Save’

1. CustomerDetail_Saving
2. Customer_Validate
3. CustomerId_Validate
4. Finalize

Order of Events when closing a screen with no changes

1. CustomerDetail_Closing
2. Finalize

Order of Events when closing a screen with unsaved changes and choosing to discard

1. CustomerDetail_Closing
   
     Dialog now appears – we choose ‘Discard’
2. Finalize

Order of Events when closing a screen with unsaved changes and choosing to save

1. CustomerDetail_Closing
   
   Dialog now appears – we choose ‘Save’
2. CustomerDetail_Saving
3. Customer_Validate
4. CustomerId_Validate
5. Finalize

As a final note, the CustomerDetail_Activated will fire whenever you change focus to another screen and return to it. Hopefully, this post sheds a bit more light into the ordering of events.