I finally decided to put a stop to this and code tooltip free.

I found this elegant solution provided by Noah Richards that he posted on github:  DisableQuickInfo.

I made one modification to his code by adding a second ContentType attribute to include XAML.

You can download the vsix file below and install or simply use this code to build the project yourself.  If you have Visual Studio 2012 you’ll need to build it yourself.

After installing you view the extensions information in Visual Studio’s Extension Manager.

Source

namespace QuickInfoAssassin {
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.Composition;
    using Microsoft.VisualStudio.Language.Intellisense;
    using Microsoft.VisualStudio.Text;
    using Microsoft.VisualStudio.Utilities;

    //Many thanks to Noah Richards and his DisableQuickInfo extension
    // https://github.com/NoahRic/Random/blob/master/DisableQuickInfo.cs

    [Export(typeof(IQuickInfoSourceProvider))]
    [Name("Quick Info Assassin")]
    [Order(Before = "Default Quick Info Presenter")]
    [ContentType("csharp")]
    [ContentType("XAML")]
    internal class QuickInfoAssassinProvider : IQuickInfoSourceProvider {
        public IQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer) {
            return new CancelingQuickInfoSource();
        }
    }

    internal class CancelingQuickInfoSource : IQuickInfoSource {
        Boolean _isDisposed;

        public void AugmentQuickInfoSession(
            IQuickInfoSession session, IList<Object> quickInfoContent,
            out ITrackingSpan applicableToSpan) {
            
            // Dismiss the session immediately.
            session.Dismiss();
            applicableToSpan = null;
        }

        public void Dispose() {
            if (!_isDisposed) {
                GC.SuppressFinalize(this);
                _isDisposed = true;
            }
        }
    }
}

If you are not familiar with creating Visual Studio Editor Extensions MSDN provides a number of walkthroughs to get you going.  I used this one: Walkthrough: Displaying QuickInfo Tooltips.

You’ll need the Visual Studio SP1 SDK to create the project that can be found here.

Download

After downloading change the extension from .vsix.DOC to .vsix. This is a requirement of WordPress. You will also need to Unblock the file using the file properties dialog in Windows Explorer.

Download (QuickInfoAssassin.vsix (40 KB))

Have a great tooltip free day,

Just a grain of sand on the worlds beaches.

Data Caching Session

This example application is for the session, “An Approach to Real World Application Data Caching” can be downloaded below. Included in the download is the demo application, the Ocean 3 framework binaries, and the  PowerPoint deck.

This application demonstrates one solution to real world data caching.  I use the techniques presented here in production applications with many users.

In the future, I’ll write a full blog post on this and possibly post a video walkthrough. I’ll also post the Ocean 3 code, just have not had time to document and write a full example application.

Mole Session

A pdf of the Mole slides can be downloaded below.

Mole can be purchased or a demo of Mole can be downloaded at Molosoft.com.

Download

After downloading change the extension from .zip.DOC to .zip. This is a requirement of WordPress. You will also need to Unblock the file using the file properties dialog in Windows Explorer.

Download (Data Caching Demo w/Database (1.4 MB))

There is a database backup in the \DataCachingDemo\Database Backup folder.  You’ll need to restore this to a SQL Server 2008 R2 or SQL Server 2008 R2 Express. If you restore to SQL Server, you’ll need to change the connection string to point to your server.  Currently, the demo application points to SQL Server Express.

Download (Mole Session Slides in PDF (613 KB))

Have a great day,

Just a grain of sand on the worlds beaches.

Today, we released new versions of Mole 2010 and for the first time, Mole 2012.

Please visit the Molosoft website for full details of these product launches, especially the FAQ page.

Highlights

• Mole 2010 and Mole 2012 are both included in the purchase.  No separate costs to purchase Mole 2010 and Mole 2012.
• Removed the 3 activation limitation.  Mole can be installed on you home, laptop, and work computers.  When you reinstall Windows, you can simply reinstall and activate Mole without having to contact support.
• All current Mole customers received an email today explaining how to get the new versions of both products at no additional cost to them.

If you’re not using Mole in your WPF, and .NET development you should be.  It will really help you when debugging applications and viewing data at debug time. 

You can get a trial version of Mole here:  http://www.molosoft.com/latestversionsofmole/

Have a great day,

Just a grain of sand on the worlds beaches.

I’ve signed up for two sessions myself. The abstracts can be viewed here.

• An Approach to Real World Application Data Caching
• Using Mole for Debugging Visual Studio 2010 and 2012 Applications

In addition, I’ll release Ocean 3 as part of the associated session source code.

Have a great day,

Just a grain of sand on the worlds beaches.

In one of the sessions, I’ll be using Ocean 3.  I had received many requests, well its about time I release it.

Best to you,

Karl

Our company uses the Infragistics NetAdvantage for WPF product for our WPF UI. We have been very happy with the product, support response and updates. Currently we use the XamRibbon, and XamOutlookBar in our Prism shell; the XamDataChart in our Dashboard; and XamDataGrid in our data entry forms. Our application is in its infancy and as new requirements, features and capabilities are added we will be using more of the controls in the NetAdvantage for WPF full featured suite.

Introduction

For my first post, I thought I would cover an aspect of using the XamDataGrid (all data grids really) that is foundational to LOB applications.

What I’m referring to is tracking the users edits (inserts, updates and deletes) while working in a data grid and then providing the capability to utilize the same database connection to perform the updates, and optionally perform the updates as an atomic transaction.

There are use cases when a user changes data in a data grid, that those changes are immediately reflected back to the database.

Our scenario is one where the design requires that the user be able to make their edits and then commit all the changes all at once. An example of this would be a master-detail use case, when child rows are associated with a master record, e.g. customers, orders, order detail.

In this example, all other development concerns such as data validation, concurrency, actually reading from or writing to a database are not part of the example code; this enables the reader to focus on one technique for tracking inserts, updates, and deletes.

XamDataGrid Requirement

The Infragistics XamDataGrid requires that the data source implement IBindingList in order for the data grid to support adding rows.

Yes, there are techniques for dynamically adding data to your data source without having to do this, but I wanted to allow the data grid to perform its work in a natural way so our data source is derives from BindingList<T>.

Tracking Inserts, Updates and Deletes

When the user deletes a row in the XamDataGrid, the row is removed from the collection and is not longer visible in the UI.

This is where the below ChangeTrackingBindingList<T> comes into play. This class keeps track of the deleted rows by adding a deleted row to an internal collection and then exposing a method (GetDeletedItems) to return those deleted rows when required. If you look below, you’ll see I’ve overridden the RemoveItem method; the implementation adds the deleted row to the internal collection of deleted rows.

It also exposes a method (GetChangedItems) to return only those non-deleted rows that have been inserted or updated.

namespace GridEditing.Infrastructure {
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Linq;

    /// <summary>
    /// Represents the ChangeTrackingBindingList that tracks changes and deleted items.
    /// </summary>
    /// <typeparam name="T">
    /// T: The type of object to provide change tracking binding list services for.
    /// </typeparam>
    public class ChangeTrackingBindingList<T> : BindingList<T> where T : ITrackDirtyEntity {

        IList<T> _deletedItems = new List<T>();

        /// <summary>
        /// Initializes a new instance of the <see cref="ChangeTrackingBindingList{T}"/> class.
        /// </summary>
        public ChangeTrackingBindingList() {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ChangeTrackingBindingList{T}"/> class.
        /// </summary>
        /// <param name="list">The list.</param>
        public ChangeTrackingBindingList(IList<T> list)
            : base(list) {
        }

        /// <summary>
        /// Gets all items in the collection.
        /// </summary>
        /// <returns>
        ///   <see cref="IEnumerable{T}"/> that contains all items from this collection; 
        ///   includes deleted and non-deleted items.
        /// </returns>
        public IEnumerable<T> GetAllItems() {
            return this.Union(_deletedItems).ToList();
        }

        /// <summary>
        /// Gets items that have been changed in the collection.
        /// </summary>
        /// <returns>
        ///   <see cref="IEnumerable{T}"/> that contains items that have been changed; 
        ///   does not include deleted items.
        /// </returns>
        public IEnumerable<T> GetChangedItems() {
            return this.Where(i => i.IsDirty).ToList();
        }

        /// <summary>
        /// Gets the deleted items.
        /// </summary>
        /// <returns>
        ///   <see cref="IEnumerable{T}"/> that contains all items deleted from this collection.
        /// </returns>
        public IEnumerable<T> GetDeletedItems() {
            return _deletedItems;
        }

        /// <summary>
        /// Clears the items.
        /// </summary>
        protected override void ClearItems() {
            base.ClearItems();
            _deletedItems = new List<T>();
        }

        /// <summary>
        /// Sets the item's MarkedAsDeleted property to <c>true</c>. 
        /// Adds the item to the DeletedItems collection. Removes item from list.
        /// </summary>
        /// <param name="index">The index.</param>
        protected override void RemoveItem(Int32 index) {
            var item = this[index];
            _deletedItems.Add(item);
            base.RemoveItem(index);
        }
    }
}

Consuming the ChangeTrackingBindingList<T>

The below MainWindowViewModel exposes the Customers collection. The collection is initialized and customers inserted in the constructor. (please do not populate your collections in your constructors, this is demo-only code)

You’ll notice that after loading the customers, I loop through the collection and set the IsDirty property to false. Your base class for your entity objects should handle this for you, so that when an object is populated from a database, the object is returned from the service layer in a non-dirty state to provide accurate tracking in the UI layer. The below example is over simplified on purpose to show how the view model will process the data once the user saves their changes.

The most important method below is the SaveExecute method that is invoked when the user clicks the Save button. The CanSaveExecute method determines if the collection has been changed or not. Any change to the collection will cause the Save button to be enabled.

Please Note: the code in the SaveExecute method would 99.9999% of the time actually be executing in a service layer. The service layer method would receive the ChangeTrackBindingList<T> as an argument and would use a data layer to process the changes.

Within the SaveExecute method we can see the workflow:

• Deleted items are removed from the database.
• Then the inserted or updated items are committed to the database.
• The view model would then reload the inserted and changed data into the data grid. This reloading refreshing the timestamps that play the role in concurrency and identity columns are populated after an item is inserted and reloaded from the database.

namespace GridEditing {
  using System;
  using System.Diagnostics;
  using System.Linq;
  using System.Windows.Input;
  using GridEditing.Infrastructure;
  using GridEditing.Model;

  public class MainWindowViewModel : ObservableObject {
    ChangeTrackingBindingList<Customer> _customers;
    ICommand _saveCommand;
    Boolean _customersDirty;

    public ChangeTrackingBindingList<Customer> Customers {
      get { return _customers; }
      set {
        _customers = value;
        RaisePropertyChanged("Customers");
      }
    }

    public ICommand SaveCommand {
      get { return _saveCommand ?? (_saveCommand = new RelayCommand(SaveExecute, CanSaveExecute)); }
    }

    public MainWindowViewModel() {
      // load from the service layer
      var list = new ChangeTrackingBindingList<Customer>();
      list.Add(new Customer { FirstName = "Josh", LastName = "Smith", Id = 1 });
      list.Add(new Customer { FirstName = "Sacha", LastName = "Barber", Id = 2 });
      list.Add(new Customer { FirstName = "Brian", LastName = "Lagunas", Id = 3 });
      list.Add(new Customer { FirstName = "Karl", LastName = "Shifflett", Id = 4 });
      foreach (var customer in list) {
        customer.IsDirty = false;
      }
      this.Customers = list;
      this.Customers.ListChanged += (s, e) => _customersDirty = true;
    }

    Boolean CanSaveExecute() {
      return _customersDirty;
    }

    void SaveExecute() {
      // call the service layer, passing the DeleteMarkingBindingList<Customer>
      // the service layer will loop through each item, and either insert it, update it, delete it, 
      // or discard.
      // this is demo code only, but demonstrates the workflow

      foreach (var customer in this.Customers.GetDeletedItems()) {
        // if the Id property is zero then the service layer does not have to do anything
        // if the Id property is greater than zero, the service layer will delete the item.
        // simulate removing from the data base
        Debug.WriteLine(
          String.Format("Customer deleted: {0} {1}", customer.FirstName, customer.LastName));
      }

      foreach (var customer in this.Customers.GetChangedItems()) {
        if (customer.Id == 0) {
          // perform insert in service layer
          customer.Id = this.Customers.Max(c => c.Id) + 1;
          // simulate inserting into the data base
          Debug.WriteLine(
            String.Format("Customer inserted: {0} {1}", customer.FirstName, customer.LastName));
        } else {
          // perform update in service layer
          // simulate updating the data base
          Debug.WriteLine(
            String.Format("Customer updated: {0} {1}", customer.FirstName, customer.LastName));
        }
      }

      // reload the updated records from the database
      // simulate getting all records from the database

      _customersDirty = false;
    }
  }
}

Running the Application

When the application is initially spun up, the Save button will be disabled since no inserts, updates or deletes have taken place.

After a row has been inserted, the Save button is enabled.

To the initial data, the following changes have been made.

When the Save button is clicked, notice the Debug output window. Each of the requested operations are performed; these operations are easily driven by the ChangeTrackingBindingList<T>.

After the Save is completed, the UI will be updated as below, the Id field has been populated and the Save button is disabled again.

UI XAML – XamDataGrid Tips

The Infragistics XamDataGrid really makes it easy for developers to deliver a full-featured data grid editing experience. This example does not even scratch the surface of the many capabilities of the data grid. In future posts I’ll demonstrate some real-world scenarios with respect to the XamDataGrid’s UI capabilities, for now, let’s stick with tracking the users edits and updating the database.

Tips

1.  By default the XamDataGrid will set string properties to null if the user enters a blank or empty string in the data grid. This is not the behavior I want, instead I need an empty string. This is accomplished using a no-op converter.

Infragistics has made applying the no-op converter a snap by setting ValueToTextConverter property on the XamTextEditor using a style as I’ve done below. In the XamDataGridNullStringPreventionConverter’s Convert and ConvertBack methods I simply return value. The causes the XamDataGrid to set string properties to an empty string instead of the null value.

2.  Take a look down at the XamDataGrid.FieldSettings, you’ll notice CellClickAction has been set to EnterEditModeIfAllowed. The user no longer has to double click a cell to get into edit mode, simply clicking the cell, will put the cell in edit mode.

3.  Making an Id field read-only is straightforward. Have a look at the Id field in the XamDataGrid’s FieldLayout. By setting Id columns FieldSettings.AllowEdit to false, the cells are read-only.

<Window 
    xmlns:local="clr-namespace:GridEditing"
    xmlns:infrastructure="clr-namespace:GridEditing.Infrastructure"
    x:Class="GridEditing.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Data Grid Editing and Deleting" 
    Height="341" 
    Width="608" 
    ResizeMode="NoResize"
    xmlns:igDP="http://infragistics.com/DataPresenter" 
    xmlns:igEditors="http://infragistics.com/Editors">
  <Window.DataContext>
    <local:MainWindowViewModel />
  </Window.DataContext>
  <Window.Resources>
    <infrastructure:XamDataGridNullStringPreventionConverter 
      x:Key="XamDataGridNullStringPreventionConverter" />
  </Window.Resources>
  <Grid>
    <Grid.RowDefinitions>
      <RowDefinition Height="Auto" />
      <RowDefinition Height="*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
    <TextBlock Text="Infragistics Data Grid Editing and Deleting" Margin="11" FontSize="18" />
    <igDP:XamDataGrid 
      Grid.Row="1" Margin="11" 
      DataSource="{Binding Path=Customers}" IsNestedDataDisplayEnabled="False">
      <igDP:XamDataGrid.Resources>
        <Style TargetType="{x:Type TextBox}" BasedOn="{StaticResource {x:Type TextBox}}" >
          <Setter Property="Margin" Value="0" />
        </Style>
        <!--this style is required to prevent null strings from being sent to the model-->
        <Style TargetType="{x:Type igEditors:XamTextEditor}" >
          <Setter 
            Property="ValueToTextConverter" 
            Value="{StaticResource XamDataGridNullStringPreventionConverter}" />
        </Style>
      </igDP:XamDataGrid.Resources>
      <igDP:XamDataGrid.FieldSettings>
        <igDP:FieldSettings CellClickAction="EnterEditModeIfAllowed" />
      </igDP:XamDataGrid.FieldSettings>
      <igDP:XamDataGrid.FieldLayoutSettings>
        <igDP:FieldLayoutSettings 
                    SupportDataErrorInfo="None"
                    DataErrorDisplayMode="None" 
                    AutoGenerateFields="False"
                    AddNewRecordLocation="OnBottom" 
                    AllowAddNew="True" 
                    AllowClipboardOperations="All" 
                    AllowDelete="True" 
                    ExpansionIndicatorDisplayMode="Never" />
      </igDP:XamDataGrid.FieldLayoutSettings>
      <igDP:XamDataGrid.FieldLayouts>
        <igDP:FieldLayout>
          <igDP:FieldLayout.SortedFields>
            <igDP:FieldSortDescription FieldName="Id" Direction="Ascending" />
          </igDP:FieldLayout.SortedFields>
          <igDP:Field Name="Id">
            <igDP:Field.Settings>
              <igDP:FieldSettings AllowEdit="False" />
            </igDP:Field.Settings>
          </igDP:Field>
          <igDP:Field Name="FirstName" Width="200" />
          <igDP:Field Name="LastName" Width="200" />
        </igDP:FieldLayout>
      </igDP:XamDataGrid.FieldLayouts>
    </igDP:XamDataGrid>

    <Button 
      Width="65" Margin="7" Grid.Row="2" Content="Save" 
      Command="{Binding Path=SaveCommand}" HorizontalAlignment="Right"/>

  </Grid>
</Window>

Download

After downloading change the extension from .zip.DOC to .zip. This is a requirement of WordPress.

Download Demo Application (25K)

Requirements

To run the demo application, you’ll need to get the Infragistics NetAdvantage for WPF. A demo version is available here.

Close

There are business frameworks like CSLA that have trackable objects and handle the above scenarios I’ve shown. Currently, I prefer to the simplest solution possible and use the above for tracking user changes within the XamDataGrid.

You can see the amount of very simple code to enable this scenario is small, easy to understand and implement.

Have a great day,

Just a grain of sand on the worlds beaches.

One of my duties at my new job is to maintain our legacy VB.NET codebase until we deploy our WPF software. When I use the term legacy it should not be taken in a negative manner. Our legacy code runs our company everyday and does it very well.

If you don’t know, VB.NET has a powerful but insidious property on Microsoft.VisualBasic.DateAndTime module called Today. Well, this little beast is a read-write property to the system date.

Yesterday I got a report of an exception that we have never seen before, System.Security.SecurityException; user does not have permission to change the system date.

Over the last few weeks we have been moving from Windows XP to Windows 7 with UAC set at the Default level (as it should be.) We are running in a different, more secure computing environment. The user that reported the issue was upgraded yesterday morning.

After researching the problem it turns out that we had several method calls within our legacy application that were passing Today ByRef. Yes, you guessed it; this caused a call to update the system date each time these methods were executed and returned. In reality no real damage was done; however under Windows 7 with UAC turned on, it caused the above security exception.

Solution

I found every instance of Today in the code and changed it to, Date.Today which is the read-only syntax.  You can also use Today.Date.

If you are maintaining legacy code that you didn’t write and have an unexplained issue, looking at method calls that are passed ByRef might help. 

If you have Today in your VB.NET code, take a look and make sure it’s not being passed ByRef and make sure you code is not mutating it.

Have a great day,

Just a grain of sand on the worlds beaches.

UAC Friendly Installation Experience

The below image pictures a user friendly UAC dialog, complete with Program name, Verified publisher. If you internal applications are not code signed, the user will get a warning dialog, with a bizarre program name, and Verified publisher set to unknown.

I don’t know about you, but I would rather condition my users to see UAC friendly dialogs, rather than the warning dialog. Next thing you know, they have “accidently” approved a UAC warning that could cause you a big problem.

If you are signing applications that are not internal to your organization, the content surrounding certificates and the guidance surrounding signtool.exe may violate your organizations code signing rules or procedures.

This blog post is about code signing internal applications that will be used within your organization.

Code Signing Certificate

The first order of business is to get a code signing certificate installed on machines that will build your internal applications. You can see from the below image, that my certificate server gmcx-Security-CA has issued a code signing certificate and that I have imported that certificate into the “Personal” Store under the “Certificates” folder.

To be honest, creating a code signing certificate that did not have my name on it, instead had our organization’s name is was bit of a PIA and required creating a certificate template on the certificate server that allowed me to do this. I found this TechNet article very helpful:

http://technet.microsoft.com/en-us/library/cc731705(v=ws.10).aspx

After you create the certificate, export it and import it on all machines under the users “Personal” store as above.

For example, I have this certificate installed on our two developer machines and on the build server.

Configuring the Solution (executable projects)

There are several ways to configure actions that take place during MSBuilds. I have chosen the “batch file” method because it is very easy to implement and debug. You could leverage one of two out-of-the-box build Tasks or create your own build task, but I chose “batch files” for the above reasons.

Notice that I have checked these batch files into source control. This ensures that all machines can build the solution correctly.

AfterBuildTasksDebug.bat

If your scenario requires code signing the debug build, the below batch file uses the signtool.exe program to code sign the .exe program. You “could” also pass in command line parameters to the batch file that would include the folder name of the target along with the target name.  I’ve kept this simple to make it easier to understand all the pieces.

Notice that I didn’t have to specify a certificate, password, etc.  This is because I only have one code signing certificate installed on my machine.  The “/a” switch instructs signtool to automatically pick the code signing certificate from my “Personal” store.

AfterBuildTasksRelease.bat and the Gotcha

Now time for a nasty gotcha. This little beast cost me about 2 hours trying to figure out why, every time I did a Release build using the Setup project to build and create the install package that the .exe the installer installed was not longer signed.

Read this thread on the Windows Dev Center for full details:

Setup project strips digital signature from exe target

Now that you have read the above thread, you’ll fully understand why when creating a release build, you must code sign the .exe under the \obj and \bin folders.

The signtool… commands sign my .exe. Let me call out one additional signtool switch you need to mind when signing your .exe.

You should also specify the “/t” switch. This will time stamp your .exe so the user knows when the .exe was built.

Configuring Visual Studio 2010 to Use the above Batch Files During a Build

• Open the Build Events dialog from the .exe project’s properties tab.
• Change the “Run the post-build event” option to “When the build updates the project output.”
• Enter the above text in the “Post-build event command line” text box.

This will run one of the two batch files based on the configuration, Debug or Release.

Building the Solution

Like many of you, I don’t build my Release builds within Visual Studio.  Some use a build server, others build them from the command line to allow other tasks to be accomplished.

Below is a fragment of a batch file that I use when building a release build.  The devenv… command rebuilds my solution. Notice the “/rebuild” switch instead of the “/build” switch.

The signtool… command signs my .msi installer that the Setup project built. Let me call out two additional signtool switches you need to mind.

It is important that you specify the “/d” switch for your .msi installers. If you scroll back up to the top of this blog post and view the UAC image, you’ll notice the Program name matches the text in the below “/d” switch. If you don’t specify this, your user will see some bizarre text.

You should also specify the “/t” switch. This will time stamp your installer so the user knows when the installer was built.

Legacy Applications Running on Windows 7 and Above

My company has a legacy Windows Forms application that was written during the days of Windows XP.  My company like many other enterprises never installed Windows Vista.  Recently we installed Windows 7 on our enterprise desktops.

Well the legacy enterprise applications I’ve inherited do things are are not UAC friendly.  For example, writing to the \Program Files folder and other tasks that are now under Windows 7 considered taboo.

Being a good Enterprise Administrator and Developer, I want all my clients running Windows 7 with UAC set to the Default setting and for my users to learn about the UAC feature and its benefits; this will provide them a safer computing environment here at work and at home.

Microsoft has documented UAC here: http://msdn.microsoft.com/en-us/library/windows/desktop/aa511445.aspx  

Microsoft and bloggers have documented a number of strategies for dealing with UAC and legacy applications.  Turning UAC off or limiting its capabilities should not be considered a good option.

I was not willing to take on the risk of modifying our legacy applications, so I run my few enterprise applications with an embedded application manifest that tells the operating system this application requires administrator privileges to execute. All of our users are administrators on their local computer.

Example Application Manifest

Notice the the below application manifest that the “requestExecutionLevel” is “requireAdministrator.”

To embed the above application manifest you need to use the mt.exe program. I placed the below command at the top of my two batch files, AfterBuildTasksDebug.bat and AfterBuildTasksRelease.bat.

You’ll need to edit the paths and .exe name as well as the manifest name.

Close

For those of you that have the need or desire to code sign your internal enterprise applications, I hope this blog post will help you avoid the long learning curve.

Have a great day,

Just a grain of sand on the worlds beaches.

This links include Ocean 3 and a modified Prism 4 library that has two new features.

The Ocean 3 solution includes a Prism Ocean Demo application that shows off Ocean working with Prism. In a later release, I’ll add database demonstration code as well that uses the new and improved Service<T> and Repository<T>.

The demo application shows off:

• WPF Ribbon being populated by a Prism Region; when forms are navigated to, their respective ribbon tabs are automatically rendered.
• Automatic view/view model wiring up by the Unity container. No view or view model navigation registrations required.
• Automatic setting of the correct IRegionManager on all view models; this region adapter does not draw the IRegionManager out of the IoC container, instead it uses the one assigned to the view. This technique prevents the incorrect IRegionManager being assigned in cases of child windows or scoped regions.
• Demonstration of a child window hosting a form; that same form can be shown within the shell or child window requiring no form or view model modifications to function correctly; i.e. no “if in popup then do this code.”
• When views are navigated away from, the currently focused control is cached; when that same instance of that form is navigated back to, focus will automatically be set to the correct control.
• Queued dialog service for forms.
• The view modal dialogs are asynchronous, by not blocking the UI thread, a form that has a dialog displayed, can be navigated away from and navigated back to.
• When a view has a view modal dialog displayed, the views ribbon tabs are automatically disabled.
• Ocean FormControl that provides many services for LOB forms.
• Ocean FormNotificationControl that shows the form status from a validation perspective.
• Ocean provides a comprehensive validation stack.
• In addition, many small features are also shown.

I’ll release a new version of BBQShack soon, PrismBBQShack. This is a complete end-to-end store application that will show off all features of Ocean 3 (like the data stack) and will have a Win8, WinRT XAML touch-enabled point of sale application.

Downloads

After downloading, you MUST read the READ ME NOW.txt file in the Acme.Example solution.

After downloading, you must rename the to downloads from .zip.doc to .zip.  This is a requirement of Word Press.

Ocean 3

Modified Prism 4

To use the modified Prism 4 download, after unzipping, go to the \Prism\Prism4\ folder and run these two batch files:

• Run Update Prism Binaries.bat
• RegisterPrismBinaries.bat

They will rebuild the supplied modified Prism 4 and will register this version of Prism in the registry so that you can use the Add References dialog. This modified version of Prism will work with any current Prism application as no API’s were removed or changed, only added.

Have a great day,

Just a grain of sand on the worlds beaches.

Background

In Oct 2011, I moved from Redmond to Boise. Unfortunately I also had to leave Microsoft. I left Redmond because of the housing prices. (See full explanation here: http://karlshifflett.wordpress.com/2011/10/21/to-every-thing-there-is-a-season/.)

To answer the above question, I need to provide context. These were my goals as I left Redmond:

• Work for a company that appreciates its employees
• Maximum 15 minute commute
• Light traffic during the week and on weekends
• Purchase a new home that I could afford (got three kids in college, 401K, etc.) and pay off in 12 years
• WPF architect-developer position

The Boise Area

I spent 3 ½ months looking at new home developments and empty lots. This task takes determination and patience. I suggest you educate yourself on determining value and features along with finding a builder or real estate person you can trust and work with.

Last week I signed a contract to build a new custom designed home (I designed it, they build it) with Boise Hunter Homes. My home is approx. 13 minutes commute from work in a nice new development. The modern/contemporary home is 2835 sqft, a massive master suite and bath, open living area with double sided fireplace, pool room, home theater room, two offices, and 600 sqft patio. The backyard will have an outdoor kitchen, Jacuzzi, and fire pit; these items were not part of the home price.

Unfortunately, I learned that the Boise area has very good health care. I had a neck and spinal cord problem that required surgery, it’s been 5 weeks and I’m doing much better now.

Most people in Boise are truly friendly and make this an enjoyable place to live and work. I have not been stuck in traffic once since moving here. The stress level in Boise is low, you just feel relaxed; it’s hard to explain, but I feel better here. I joined a gym a few minutes from work. They have a pool, racquetball courts, and other typical gym equipment and services; cost, $360 per year.

This winter season, we had snow stick twice but it was gone by the next day or two. However, in 45 minutes you can be in very nice winter recreation areas for skiing, snowmobiling, etc. The winters are dry here, not like the nasty north east that has wet winters, or the ice that comes to Charlotte.

I’m looking forward to jet skiing this summer on one of our lakes and hiking in the surrounding area.

My Company: Gayle Manufacturing Company

Where you work, the people you work with, and the working environment and culture can really affect your quality of life. I’ve been very fortunate in my life, always looking forward to work each day; yes even in the Marines when we were stuck on some freezing cold mountain, hiding out in a tropical jungle, doing search and rescue missions over the Atlantic, or flying low nap of the earth over some desert, I loved it.

Working at GMC is no different; every morning I look forward to my work day and the tasks I will accomplish. Our company motto is, “performance through innovation.” I’m with a company were people get along, value and respect one another, whose core culture is to think outside the box; to look for ways to improve our manufacturing processes, our business processes, and our safety procedures. I’m blessed to have the opportunity to be a part of the GMC family.

Before my neck surgery my surgeon told me the procedure would knock me out of the game for 2-3 weeks. Well, he was not kidding. The first two weeks were brutal and I needed assistance; for example I couldn’t raise my arms to put a shirt on; even with assistance putting a shirt on was painful to say the least.

The owner of my company visited me 2-3 times every day, cooking, cleaning, changing my dressing, shopping, and doing laundry. One of co-workers helped out on weekends too. I’m very appreciative of the support, understanding, and care my company has provided me.

I value the job responsibilities and opportunities I have at GMC; my WPF and business application development experience is a good fit for the company and me.

Close

For me, the move to Boise has been a very good one. Short commute, affordable housing, light traffic, outdoor activities, health care I trust, friendly folks, and a wonderful company to work for.

I hope that you have found a nice place to live and work also.

We do have one opening for a Senior WPF/C# Developer. You can read the details here: http://www.gmcx.com/Employment.aspx?Area=NampaJobs.

Have a great day,

Just a grain of sand on the worlds beaches.

The GMC IT Team is located at the Nampa, Idaho plant. This position has office regular hours without telecommuting.

The Ideal Candidate

The ideal candidate will be technically proficient developer with a solid background in WPF, OO programming concepts, an understanding of common design patterns, and who delivers quality, maintainable code. The candidate will have strong leadership skills and a proven track record of developing and delivering complex software.

The candidate will have the ability to thrive in a small team environment and who embraces new programming challenges; whose experience, creativity, and passion for WPF are demonstrated by their work product. Additionally, the candidate will have the ability to effectively interact and communicate with non-programmer company employees.

This long term, high profile position plays a critical role regarding the future operations and ongoing prosperity of GMC. GMC is prepared to offer an excellent compensation and benefits package to an outstanding individual.

The candidate must have the following experience:

• 5+ years of C# development
• 4+ years of WPF development
• WPF in-depth knowledge and experience that includes: authoring custom controls, data binding, control templates, styles, triggers, behaviors, data entry forms, nested forms and grids, data validation, and MVVM.
• Proficient with C# object oriented programming
• Understanding of cross-cutting concerns and solutions
• 3+ years of SQL Server development using ADO.NET API’s.
• Experience with the following would be helpful:
  • Prism
  • Infragistics WPF controls
  • SSRS or Telerik reporting controls
  • TFS source control
  • TDD, unit and integration testing
  • Expression Blend
  • Commercial MRP systems

Qualified applicants will be vetted for technical proficiency in the above requirements.

About Us

Gayle Manufacturing Company has a 43 year history of growth and prosperity, whose motto is, “performance through innovation.” During those years, GMC has become an established leader and innovator in the Structural Steel Industry. GMC has a 25 year history of successful development and implementation of proprietary MRP software systems. These systems are comprehensive and sophisticated. They are very focused and tuned to the GMC business model and support the specific management and manufacturing methods developed at GMC.

How to Apply

Please download our job application at http://www.gaylemfg.com/Documents/Application.pdf, email the completed application along with your resume to wpfposition@gmcx.com or fax to (208) 468-0500.

If applicable, also include a link to your blog, links to speaking engagements, and links to other on-line WPF articles you have authored.

In the subject field of the email, please enter the following text: WPF Developer: <your first and last name>.

Have a great day,

Just a grain of sand on the worlds beaches.

Friday, 28 Oct 2011 will be my last day in Redmond, and unfortunately Microsoft and the patterns & practices team.

My decision to leave Redmond was driven solely by the poor real estate market in this area. I really want to build a new home, but know too many people here who are upside down (big $$$$) in their mortgages or who short sold their home. This was not a risk I wanted to take. Some say the market is near the bottom and now is a good time to buy here; maybe, but the cost to build a new home is higher than I want to take on and a long or hard commute is not an option for me. I prefer a 10-15 minute traffic-free drive (doesn’t everyone?)

This was a very difficult decision choosing between a life goal of building a new home, a short commute, and trying to stay with Microsoft in Redmond.

On 29 Oct 2011, I’ll be moving to Boise, Idaho and after a short break will begin a new career with Gayle Manufacturing Company. I’m looking forward to becoming part of the GMC family and transitioning back to an architect-developer role. Over the winter I’ll work with a home builder in Boise and hope to break ground in March or April of 2012. The other night I was studying home automation; it felt good to look forward to building a home, something I have not felt in long time.

Leaving Microsoft

Leaving Redmond is easy (for the above reason), leaving Microsoft is difficult. I’m grateful for the opportunities I’ve been given over the last 3 years. Except for the Marine Corps, Microsoft is the best company I’ve ever worked for. I would not hesitate to recommend the opportunities at Microsoft to anyone, this super place to work.

I will very much miss the dedicated and very smart people at Microsoft.

Leaving Redmond also means moving away from friends in the area; I will miss you as well.

Staying Connected

My blog will continue with WPF, Prism, and enterprise development topics, and will venture into WinRT land as well. I’m looking forward to joining the user groups in Boise.

I will also continue to stay close with Microsoft teams and groups by participating on advisory boards and other customer channels.

Close

Microsoft and the people of Microsoft, thank you very much for the last three years.

Have a great day,

Just a grain of sand on the worlds beaches.

One tool I’ll be using is the new Windows Phone Marketplace Test Kit.

From the above MSDN page:

The Windows Phone Marketplace Test Kit provides a suite of automated, monitored, and manual tests to help prepare your applications to be accepted in the Marketplace the first time you submit them. The test kit enables you to identify and fix issues prior to Marketplace submission, which saves time in the submission process. You can use the test kit to evaluate applications that target Windows Phone OS 7.1 or later.

To open the Marketplace Test Kit, select your Windows Phone 7.1 project in the Solution Explorer. Then from the Project menu select, Open Marketplace Test Kit.

The below tool will open allowing you to run a set of prepackaged tests and provides a UI to import the required images for your application.

Thanks go out to the Windows Phone team for shipping this.

Have a great day,

Just a grain of sand on the worlds beaches.

Project Silk

Client-Side Web Development for Modern Browsers

Project Silk provides guidance for building maintainable cross-browser web applications that are characterized by an intentional design, rich interactivity, and a responsive user interface (UI). The result is an immersive and engaging user experience (UX). Such applications take advantage of the latest web standards, including HTML5, CSS3, and ECMAScript version 5, and modern web technologies such as jQuery and ASP.NET MVC 3.

The concepts explained in this book are demonstrated via a real-world customer-facing web application called the Mileage Stats Reference Implementation (Mileage Stats). Mileage Stats allows users to track and compare their vehicles’ fuel efficiency, usage, and operating costs, and to schedule vehicle maintenance reminders. The image below shows the Mileage Stats client-side objects and their implementation mapped to libraries or frameworks.

Building a rich web application that reduces the number of full-page loads, includes animations, and is responsible for updating the UI dynamically requires a thoughtful approach to managing structure, modularity, communication, navigation, and data. The book details how the Project Silk team designed Mileage Stats and solved a number of challenges.

Links

• Project Silk download
• Project Silk Home Page on MSDN
• Project Silk Community on CodePlex
• Project Silk Road Map
• Mileage Stats Video

Audience

• This guidance is intended for web developers and assumes you have some hands-on experience with ASP.NET MVC, CSS, HTML, JavaScript, and jQuery.

In this Release

• Project Silk Mileage Stats Reference Implementation full source code
• Widget QuickStart documentation and source code
• Unit Test Hands on Labs (3)
• Project Silk: Client-Side Web Development for Modern Browsers online documentation
• Mileage Stats Video

About patterns & practices

The Microsoft patterns & practices team provides a wide range of guidance to help customers save time and reduce risk on their software development projects by incorporating proven patterns and practices.  This applied engineering guidance includes both production quality source code and in-depth documentation.

The guidance is designed to help software development teams:

• Make critical design and technology selection decisions by highlighting the appropriate solution architectures, technologies, and Microsoft products for common scenarios
• Understand the most important concepts needed for success by explaining the relevant patterns and prescribing the important practices
• Get started with a proven code base by providing thoroughly tested software and source code that embodies the recommendations

For more information: http://msdn.microsoft.com/practices

Have a great day,

Just a grain of sand on the worlds beaches.

To try and add anything to what has been clearly communicated would be foolish on my part.  Instead let me tell you about my “Lazarus” experience this week.

I’ve been eyeing the Asus EP121 for several weeks now. I got to play with one at the Bellevue Microsoft Store. This is one sweet unit.

Well, I have a dusty, HP tm2 TouchSmart Laptop/Tablet. It has a Core i3 1.2ghz, 4GB memory, integrated graphics card, slow 5400rpm drive. My thinking was, if I can pull a Lazarus on this computer for 6-12 months, I’ll save myself the $1,000 now and wait for the next generation hardware and with fast CPU, SSD, HD screen, etc.

I did use the HP tm2 for Window Phone 7 development and OneNote note taking.  It was kind of slow, especially compared to other modern hardware.

The slowness was not attributed to Windows 7, but rather to lame hardware. 

PC hardware manufacturers please start making decent hardware that competes with Apple’s hardware and PLEASE stop putting crapware on my new PC. All crapware should be a line item, opt-in.

I need to move off this topic before I go into a tirade.

On the good side, one of the keynotes at BUILD showed new hardware coming soon that looks like the MacBook Air, metal, thin, etc.  At last. Please offer good components in your units, I’ll pay for them.

So I replaced the first generation 5,400rpm hard drive with a 7,200 second generation SATA. Was getting just a little excited, breathing new life into my laptop.

Lazarus!

Following simple directions on Scott Hanselman’s blog, I loaded the Win8 Preview on a USB.

When I booted the laptop I change the default boot to the USB so I could install Windows.  When Windows restarts, don’t forget to change the default boot back to your hard drive.

Installation took 12 minutes; Windows, Visual Studio, demo applications, etc.  Core i3 and a decent disk, still respectable.

The laptop boots very quickly, applications are responsive and fun to use.  I have not installed Office yet, but will soon. For now, just learning to get around Windows 8 and how to write Metro XAML apps.

Scud Missile

After I logged in, I ran Windows Update and one of the items installed was the, “Microsoft IntelliPoint 8.2 Mouse Software for Windows – 64 bit” This update on my laptop caused the touch to quick working.  So I used Add Remove programs to uninstall it, rebooted and got touch working again.

Visual Studio XAML Designer Patch

You need to install a patch published by the Expression Team to correct a mouse issue with the designer.

https://connect.microsoft.com/VisualStudio/Downloads/DownloadDetails.aspx?DownloadID=38599

After downloading, don’t forget to “Unblock” the .zip file.  The instructions left this out.

You MUST follow the installation instructions, most important you must install the patch as an administrator.

The fun part will be trying to figure out how to open an Administrator Command Prompt. I could not figure out how to do this using the Metro interface.  So… I opened Windows Explorer in the Desktop, navigated to the \Windows\system32 folder, right-clicked on the cmd.exe file and selected, “Run as Administrator.” While you at it, go ahead and pin that Administrator Command Window to the TaskBar, problem solved.

Getting Around Windows 8

Since you probably won’t be writing code using your TouchScreen keyboard, you’ll want to get up to speed on Windows Shortcuts. The following blog post is being recommended by several on Twitter so I’ve included it here as well.

http://www.winrumors.com/windows-8-tips-and-tricks-for-mousekeyboard-users/

Before Your Frist Project

Before you dive into your first Metro project, take time and watch some of the BUILD videos. If you only watch one video, watch this one: http://channel9.msdn.com/events/BUILD/BUILD2011/BPS-1004. Jensen Harris clearly explains Metro and the thinking behind it. He is also one of the best presenters at BUILD and connects with the audience and viewers alike.

Video

The below video shows my HP tm2 after the Lazarus operation.  Short, 3 minutes gives you a good feel for how a Core i3 runs Windows 8.

http://www.vimeo.com/29222402

Close

These are good times for Windows developers.

For me, I’m finishing up my WPF/Prism BBQ Shack program and will move the cash register and online purchasing modules to Metro.  Metro is perfect for a touch screen cash register.  This will be so much fun to write.

Have a great day,

Just a grain of sand on the worlds beaches.

All the details and sign up for the Redmond GiveCamp can be read here:  http://seattlegivecamp.com/

What I like about weekend events like this is the challenge:

• Working with a team you may have never met
• Writing an application you have zero up front context on
• Delivering over the weekend an application that will be deployed and used the next week

For this event, I’ll be joining a group of of Microsoft LightSwitch team members to take up the challenge of delivering an application using LightSwitch over the weekend.

This is a great opportunity for you to meet others, exercise your skills on a team, learn from other team members and have fun at the same time.

If you find yourself in Redmond in October, we hope to see you there.

Don’t forget you need to sign up here: http://seattlegivecamp.com/

Have a great day,

Just a grain of sand on the worlds beaches.

New to Prism 4 was the Navigation API’s. The use of the Navigation API’s greatly simplifies application development because the Navigation API takes over the responsibility of object creation and siting objects in the target region.

The Prism library is designed to support applications that can target WPF and Silverlight with good code reuse. While not all developers need this capability, a lot of thought and design decisions were made to fully support this scenario.

One API that took this capability into account while being designed is the Navigation API; specifically the confirmation of a navigation request. Objects that implement IConfirmNavigationRequest have the option to veto a navigation request. In order to support the limitation that Silverlight does not allow blocking dialog boxes, the IConfirmNavigationRequest.ConfirmNavigationRequest method had to be written so that Silverlight objects could participate in vetoing a navigation request without a blocking dialog.

Without going into all the details (you can read them here), objects that implement IConfirmNavigationRequest are required to invoke the callback in the ConfirmNavigationRequest method arguments. Objects are free to implement any vetoing code they want as long as the callback is invoked.  In practice the navigation request is halted until the callback is invoked. This design enables Silverlight developers to implement a variety UI solutions for prompting the user, for example the Prism Interaction Request.

I’ve found that I’m my WPF development that I had to jump through the above hoops just to have navigation confirmation, when in fact WPF has out of the box support for modal, UI blocking dialogs. In an effort to simplify my WPF applications I’ve created a replacement for the Prism RegionNavigationService that allows for synchronous navigation confirmation.

The implementation is very straightforward and only requires that you add one class and one interface to the Prism library and recompile it.

The RegionNavigationSynchronousService is the replacement for the stock RegionNavigationService. This class uses the new synchronous (blocking) navigation confirmation interface IConfirmNavigationRequestSynchronous, listed below.

public interface IConfirmNavigationRequestSynchronous : INavigationAware
{
    /// <summary>
    /// Determines whether this instance approves being navigated away from.
    /// </summary>
    /// <param name="navigationContext">The navigation context.</param>
    Boolean ConfirmNavigationRequestSynchronous(NavigationContext navigationContext);
}

By default, Prism automatically registers the RegionNavigationService in the container as part of the bootstrapping pipeline. However, we want to use the WPF friendly synchronous confirmation service, RegionNavigationSynchronousService.

All that is required is to override the ConfigureContainer method in your bootstrapper and register RegionNavigationSynchronousService as I’ve done below.

namespace TestBench {
    using System.Windows;
    using Microsoft.Practices.Prism.Modularity;
    using Microsoft.Practices.Prism.Regions;
    using Microsoft.Practices.Prism.UnityExtensions;
    using Microsoft.Practices.Unity;
    using TestBench.Customers;

    class Bootstrapper : UnityBootstrapper {
        protected override IModuleCatalog CreateModuleCatalog() {
            var catalog = new ModuleCatalog();
            catalog.AddModule(typeof (CustomersModule));
            return catalog;
        }

        protected override DependencyObject CreateShell() {
            var shell = this.Container.Resolve<ShellView>();
            Application.Current.MainWindow = shell;
            Application.Current.MainWindow.Show();
            return shell;
        }

        protected override void ConfigureContainer() {
            base.ConfigureContainer();

            // register the new navigation service that uses synchronous navigation 
            // confirmation instead of the async confirmation.
            this.Container.RegisterType(typeof(IRegionNavigationService), 
                typeof(RegionNavigationSynchronousService));
        }
    }
}

Below is a very simple implementation.

PLEASE do not put MessageBox code in your view models!  This is for demo purposes only and to keep the code simple.  Please use a dialog service that abstracts the UI dialog away from the view model.

The below code is from the included download and is in the CustomerMaintenanceViewModel. The below ConfirmNavigation property allows the demo to confirm or not but is not part of the Navigation API. This method returns true or false to continue the navigation request or not.

public Boolean ConfirmNavigationRequestSynchronous(NavigationContext navigationContext) {
    if (this.ConfirmNavigation) {
        if (MessageBox.Show("Close form and navigate?", "Confirm Navigation", 
            MessageBoxButton.OKCancel, MessageBoxImage.Question) == MessageBoxResult.OK) {
            return true;
        }
        return false;
    }
    return true;
}

Demo Application

Very simple Prism application that demonstrates confirming navigation requests and region lifetime. The status bar indicates the views in the ContentRegion on the right.  As you open or close views their name will be displayed; for the Customers, the customer number will be displayed.

Crack the code open, you’ll have this down in a few minutes.

Download

As always, don’t forget to “Unblock” the zip file after downloading from the Internet before you unzip it.

Synchronous Prism Navigation (177KB)

The download includes a sample Prism solution that your can run without modifying your Prism library code.  I’ve included a \Lib folder in the solution with pre-built, modified Prism library code.

I’ve also included two files in the \PrismSource folder that you can add to your Prism library. Simply copy these two files into the below folder and recompile Prism. You now have the option to use a simpler navigation confirmation API in your WPF projects. 

This only works in WPF and NOT Silverlight.  If you have the requirement to share code between WPF and Silverlight this will not work because Silverlight requires the navigation confirmation to be async.

Have a great day,

Just a grain of sand on the worlds beaches.