Wednesday Quickie - Building Lightswitch Projects in TFS

So I've been fighting with getting my Lightswitch application to build under TFS as part of our (slow) move towards Continuous Build / Continuous Deployment at work... and for weeks I've been banging my head against the wall with the deaded "UnpackExtensionsToProjectDir" error.

And then came the revelation... looking a couple of lines down I found that the real error was being masked - looking at the detailed logs we can see the real culprit:

C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\LightSwitch\v1.0\Microsoft.LightSwitch.targets(1257,9): error MSB4018: The "UnpackExtensionsToProjectDir" task failed unexpectedly.

<SNIP>

[C:\Builds\4\MyApp\Trunk\Sources\Authentication\MyApp.LightswitchApp\MyApp.LightswitchApp.lsproj]C:\Program Files (x86)\MSBuild\Microsoft\VisualStudio\LightSwitch\v1.0\Microsoft.LightSwitch.targets(1257,9): error MSB4018:    at Microsoft.LightSwitch.ExtensionsReader.ExtensionInformationService.ExtensionInformation.LSPKGPackage.ExtensionDirectoryDeletionFailedAction(IServiceProvider serviceProvider, String directory) [C:\Builds\4\MyApp\Trunk\Sources\Authentication\MyApp.LightswitchApp\MyApp.LightswitchApp.lsproj]

<SNIP> 

[C:\Builds\4\MyApp\Trunk\Sources\Authentication\MyApp.LightswitchApp\MyApp.LightswitchApp.lsproj]Done Building Project "C:\Builds\4\MyApp\Trunk\Sources\Authentication\MyApp.LightswitchApp\MyApp.LightswitchApp.lsproj" (default targets) -- FAILED.Done Building Project "C:\Builds\4\MyApp\Trunk\Sources\Authentication\MyApp.LightswitchApp\MyApp.LightswitchApp.lsproj.metaproj" (default targets) -- FAILED.

By looking at the Microsoft.Lightswitch.targets file, I found that the actual error was that the build process couldn't delete the _Pvt_Extensions directory.

A quick check showed that that particular directory had been added to TFS source control - removing it and the deaded "UnpackExtensionsToProjectDir" error was finally vanquished. (OK - there were a couple of other build errors, but they were easily fixed).

So now I have a green tick beside my Lightswitch application in TFS Build Explorer - WIN!

Tomorrow, my next challenge - getting the thing packaged for MSDeploy deployment.

Fixing CornerRadius in Silverlight

OK - I know I've not posted in nearly a year... but this time I'm covering one of those "why the frack does it work like that" issues with Silverlight 4.

I hit this one today - I wanted to unify the radii of corners within a Silverlight application to replace the random set of radii used (1, 2, 4, 5, 8, 10, 12, 15 and 20 pixels no less) with a simpler set - small, medium, large and massive.

The problem is that (for whatever reason), the developers of Silverlight decided that we didn't need to be able to create CornerRadius objects in our ResourceDictionaries. Or rather that we could TRY, but that the XAML Loader was never told how to deal with them. Even though the design surfaces in Visual Studio and Expression Blend can quite happily deal with this!

So if you *DO* try then you either get an error saying that you can't set the readonly TopLeft property of a CornerRadius, or if, like me, you do this in your theme.xaml you just get a catastrophic error - somewhere in your project.

So what was the solution?

Well, there was a very good answer to exactly this on Stack Overflow - using a Value Converter to read named resource values from the object for which we want to set the CornerRadius... But I suddenly realised that there was no need to have a "magic string" as keys for the TopLeft etc values - we can just use properties on the value converter ITSELF!

The result is a pretty elegant way to get around a limitation of Silverlight, thus:

<Border x:Name="buttonBorder">

<Border.CornerRadius>

<Binding ElementName="buttonBorder">

<Binding.Converter>

<Converters:DynamicCornerRadiusConverter TopLeft="{StaticResource massiveCornerRadiusValue}"

TopRight="{StaticResource massiveCornerRadiusValue}"

BottomRight="{StaticResource massiveCornerRadiusValue}"

BottomLeft="0.0" />

Binding.Converter>

Binding>

Border.CornerRadius>

…

Border>

Not quite as simple as defining a CornerRadius in a ResourceDictionary, but not bad at all - and certainly it allowed me to do what I wanted - to rationalise my myriad of Radii!

And here's the code:

namespace CheviotConsulting.Common.Silverlight.Converters

{

    using System.Windows;

    using System.Windows.Data;

    /// 

    /// Exposes a CornerRadius instance configured for a ValuationProgressButton

    /// 

    public class DynamicCornerRadiusConverter : IValueConverter

    {

        /// 

        /// Gets or sets the top left.

        /// 

        /// The top left.

        public double TopLeft { get; set; }

        /// 

        /// Gets or sets the top right.

        /// 

        /// The top right.

        public double TopRight { get; set; }

        /// 

        /// Gets or sets the bottom left.

        /// 

        /// The bottom left.

        public double BottomLeft { get; set; }

        /// 

        /// Gets or sets the bottom right.

        /// 

        /// The bottom right.

        public double BottomRight { get; set; }

        /// 

        /// Gets the corner radius.

        /// 

        /// The resource source.

        /// the corner radius

        private CornerRadius GetCornerRadius(FrameworkElement resourceSource)

        {

            var result = new CornerRadius(this.TopLeft, this.TopRight, this.BottomRight, this.BottomLeft);

            return result;

        }

        /// 

        /// Modifies the source data before passing it to the target for display in the UI.

        /// 

        /// The source data being passed to the target.

        /// The  of data expected by the target dependency property.

        /// An optional parameter to be used in the converter logic.

        /// The culture of the conversion.

        /// 

        /// The value to be passed to the target dependency property.

        /// 

        public object Convert(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            return this.GetCornerRadius(value as FrameworkElement);

        }

        /// 

        /// Modifies the target data before passing it to the source object.  This method is called only in cref="F:System.Windows.Data.BindingMode.TwoWay"/> bindings.

        /// 

        /// The target data being passed to the source.

        /// The  of data expected by the source object.

        /// An optional parameter to be used in the converter logic.

        /// The culture of the conversion.

        /// 

        /// The value to be passed to the source object.

        /// 

        public object ConvertBack(object value, System.Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            throw new System.NotImplementedException();

        }

    }

}

Thursday Quickie - Mocking Events with Moq

There are times when the code under test depends on an event being fired by a component we're mocking. You can explicitly fire a mocked object's event using the following code

            var authService = new Mock<IAuthenticationService>();
          authService.Raise(m => m.LoggedIn += null, null as AuthenticationEventArgs);

You can also raise an event on the mock as part of a callback - i.e. fire the event when a method or property on the mock is triggered.

            var authService = new Mock<IAuthenticationService>();
           authService.Setup(a => a.LoadUser(null, null))
                      .Returns(null as LoadUserOperation)
                      .Callback(() => authService.Raise(m => m.LoggedIn += null, null as AuthenticationEventArgs));

To call a delegate passed into a mocked handler, you just need to do exactly that - the magic is in getting the generics right

            var worker = new Mock<IWorker>();             worker.Setup(w => w.DoWork(It.IsAny<EventHandler<WorkCompletedEventArgs>>()))                   .Callback<EventHandler<WorkCompletedEventArgs>>(c => c(worker.Object, new WorkCompletedEventArgs()))                   .Verifiable();

Tricks & Tips: ListBoxes, TextBoxes and SelectedItems

I ran across this today and thought it was worth sharing. The problem is one that's been found in both Silverlight and WPF, but there doesn't seem to be a nice simple solution for either.

The issue involves a control that can accept focus (e.g. a TextBox) being part of the ItemTemplate of a ListBox control. In this scenario, you can select one ListBoxItem by clicking on the whitespace within the ItemTemplate, but when you click on the focusable control (the TextBox) of another ListBoxItem, then the selection does NOT move along with the focus.

The solution is a dinky little behavior that walks up the Visual tree from the TextBox when it gets focus and selects the parent ListBoxItem.

namespace MyProject.Behaviors

{

  using System.Windows;

  using System.Windows.Controls;

  using System.Windows.Interactivity;

  using System.Windows.Media;



  /// 


  /// Behaviour that allows a control to cause a parent ListBox to become focused.

  /// 

  public sealed class ListBoxItemFocusBehaviour : Behavior<Control>

  {

      /// 


      /// Called after the behaviour is attached to an AssociatedObject.

      /// 

      /// Override this to hook up functionality to the AssociatedObject.

      protected override void OnAttached()

      {

          base.OnAttached();

          this.AssociatedObject.GotFocus += OnControlFocused;

      }



      /// 


      /// Called when the behaviour is being detached from its AssociatedObject, but before it has actually occurred.

      /// 

      /// Override this to unhook functionality from the AssociatedObject.

      protected override void OnDetaching()

      {

          base.OnDetaching();

          this.AssociatedObject.GotFocus -= OnControlFocused;

      }



      /// 


      /// Called when [control focused].

      /// 

      /// "sender">The sender.

      /// "e">The "System.Windows.RoutedEventArgs"/> instance containing the event data.

      [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "By design - p is re-used for multiple control types.")]

      private static void OnControlFocused(object sender, RoutedEventArgs e)

      {

          var control = sender as Control;

          DependencyObject p = control;

          while (p != null && !(p is ListBoxItem))

          {

              p = VisualTreeHelper.GetParent(p);

          }



          if (p == null)

          {

              return;

          }



          ((ListBoxItem)p).IsSelected = true;

      }

  }

}

Alll you have to do is attach this behavior to your focusable control and when it receives focus, its associated ListBoxItem gets selected.

                <TextBox x:Name="MyTextBox>

                    <Interactivity:Interaction.Behaviors>

                        <Behaviours:ListBoxItemFocusBehaviour />

                    <Interactivity:Interaction.Behaviors>

                TextBox>

Not forgetting of course to register the appropriate namespaces and reference the System.Windows.Interactivity assembly from the Blend SDK.

xmlns:Behaviours="clr-namespace:MyProject.Behaviors;assembly=MyProject" 

xmlns:Interactivity="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

Nothing too it!

RIA Services and NHibernate Recipes - Introduction

For the last few weeks I've been working on a new system at work that implements a Silverlight MVVM UI on top of RIA Services. The back end is a SQL Server database that is accessed via NHibernate using LINQ4NHibernate and FluentNHibernate to configure everything.

There has been a fair amount of pain in the process, so prompted by a tweet from @SLColinBlair I've decided to start blogging a series of recipes for using RIA Services and NHibernate together.

As I go, I'm going to create a simple "Client / Project" management application to use throughout which will allow me to blog about each recipe within a common context.

The diagram to the right shows the data structures we'll be starting with.

• A Client has zero or more Contacts and Projects.
• A Contact belongs to just one client and has zero or more Responsibilities, each of which is to just one Project.

I will expand the scope of the sample application as we introduced more recipes - any requests will be most welcome on Twitter.

Next time: Getting started - The Clients object.

Quickie: Unwrapping Invocation Exceptions

If you work with dynamic invocation in any way, shape or form you're bound to catch a TargetInvocationException at some time or another. However, the fact that the real exception has been wrapped into a TargetInvocationException can hide a multitude of sins - potentially all sorts of different exception types can get wrapped from all sorts of sources.

One further problem is that it's entirely possible to get nested TargetInvocationExeptions as the call stack unwinds - again masking what the real problem is. This was the precise situation I found myself in with my nicely crafted n-tier WCF-based system.

So to make life just a little easier on myself when dealing with the exceptions thrown whilst performing a dynamic invocation I put together the following extension methods - one that re-wraps an exception and one that un-wraps nested TargetInvocationExceptions.

To use it, we just catch and re-throw, except using the extension methods.

try
{
// Do something dangerous with dynamic invocation
}
catch (TargetInvocationException ex)
{
throw ex.UnwrapTargetInvocationExceptions().ForRethrowing();
}

What you'll get is an exception throw of the same type as the actual fault, regardless of how many nested TargetInvocationExceptions it is wrapped in. Because we're nicely wrapping the exception we also maintain the call stacks to let you trace what's really going on.

Finally, here's the source - use it at your own risk - I've found it handy!

public static class ExceptionExtensions
{
///

/// Returns an exception wrapping an exception, but of the same type a

/// that's exception's INNER exception.
///

///
/// This allows us to write code like
/// throw ex.InnerException.ForRethrowing()
/// to re-throw an inner exception type without losing the stack trace.
///

public static T ForRethrowing(
this T innerException, Exception outerException)
where T: Exception
{
var actualType = innerException.GetType();

var ctorParams = new object[] {
innerException.Message, outerException
};
var result = (T)Activator.CreateInstance(actualType, ctorParams);
return result;
}

///

/// Unwraps an exception from any wrapping target invocation exceptions.
///

public static Exception UnwrapTargetInvocationExceptions(
this Exception exception)
{
var innerException = exception.InnerException;

// not a TargetInvocationException, or no inner exception? Then
// just return the exception itself
if ((innerException == null) ||
(!(exception is TargetInvocationException)))
{
return exception;
}

return innerException.UnwrapTargetInvocationExceptions();
}
}

Getting it right - filming DDD WP7

OK, now they're all available I want describe how I filmed the Developer Developer Developer - WP7 event that was held back in October 2010 at The Printworks in Manchester.

As an entirely community driven event, the day provided 9 sessions that gave a really good introduction to WP7 development - including Andy Wigley's excellent talk on Tombstoning - with NO Microsoft presenters.

The videos are now all up on Channel 9, courtesy of Mike Ormond - and are all in HD to boot.

• Session 0: "Windows Phone 7: A Different Kind of Phone"
  Andrej Radinger, 20 minutes
  
  
• Session 1: "Understanding the Windows Phone 7 Development Tools and Getting Started"
  Maarten Struys, 1 hour, 2 minutes
  
  
• Session 2: "Silverlight App Development on Windows Phone 7"
  Andy Wigley, 29 minutes
  
  
• Session 3: "Integrating with the device capabilities (location, camera, contacts, phone)"
  Andy Wigley, 47 minutes
  
  
• Session 4: "Raising the dead: Programming Silverlight Apps that survive Tombstoning"
  Andy Wigley, 51 minutes
  
  
• Session 5: "Games Programming on Windows Phone 7 with Silverlight and XNA"
  Rob Miles, 58 minutes
  
  
• Session 6: "How to sell Apps through Marketplace"
  Rob Miles, 28 minutes
  
  
• Session 7: "Creating an application for WP7 with Cortexica’s ‘visual search’ API"
  Tricky Bassett, 21 minutes
  
  
• Session 8: "Creating WP7 Apps that work offline"
  Andrej Radinger, 45 minutes

And now for the trumpet-blowing bit - I was the lunatic that volunteered to film, edit and produce all 6 hours of final video output.

Filming

I filmed the presenter using a Canon XM camera placed at the front of the auditorium - this gave me good footage of the presenter (although Rob Miles enthusiasm as he bounds around the stage makes tracking him a challenge!) as well as a master wide shot against which to synchronise the slide graphics.

A second, smaller Sony HD Handycam was placed in the middle of the back row of the cinema to get a "god's eye view" of proceedings, and to record the screens during demo's. This worked well, but I do think that a camera that has manual focus would have been better, and a direct feed recorded from the screen best of all. Unfortunately that last option requires a £500 converter and some kind of SDI recorder - well beyond the budget of this kind of community event.

Finally I had a second Sanyo HD Handycam for quick pick-up shots of the audience - this really needs a dedicated cameraman / interviewer to make best use of it. I used it in the breaks to get some shots of the outside area where Mike Ormond was running his XAPathon, but the light levels were really too low for any of the footage to be useful. Some of the in-auditorium shots were used as cut-aways in the final edit tho'.

Each presenter was given a second radio pack (in addition to the one for the venue SR system) that was recorded by the Canon - I had two packs, so there was no rushing to swap between presenters. These recorded a good clean audio track against the close-up video which would allow me to sync the recordings from both camera in the edit more easily.

The Sony camera's front stereo mics recorded a good "wild-track" of the audience (and the presenter's voice played through the SR speakers), but regretably the audience levels were never enough to get a clean recording of any questions. This audio did get used at low-levels in the mix to provide some room ambience.

I think the only way to improve the recording of audience questions would be to have 2 or 3 runners with radio stick mics ready to hand them out, or else use a couple of shotgun mics on long booms. That would also allow the question to be piped through the SR system so everyone could hear it clearly as well as allowing it to be recorded.

After the success of filming the Guathon, I wanted to once again get a really clean audio recording of the presenter. As the portable digital recorder I used before wasn't available I used a stereo 1/4" jack to USB audio interface to record the mix audio directly from the Sends of the SR mixing desk into a netbook running Sony Sound Forge Audio Studio. This worked superbly, giving a perfectly clear recording without having to worry about batteries or filling the CF card - seeing "196 hours available" gives a nice warm feeling!

Post Production

After the event, the footage from the Cannon was ingested into my Vaio laptop using a Sony HDV deck over Firewire. Footage from the handycams was pulled straight from the SD cards, and the audio files were just copied over the network from the Netbook onto the Vaio. Then came the hard work - editing in Sony Vegas.

I started by pulling in the master audio files - these were full-length for each session, so gave me a good place to start. Laying the Canon video/audio tracks alongside synchronised the audio for each clip, then did the same for the Sony Handycam footage. This gave me two video tracks (the close-up of the presenter and the "God's eye" view to work with whilst adding the slide graphics exported from Powerpoint as Png's.

Once each session was prepared, the video and slides were merged down into a "Multi-Camera Edit Track". This is a superb feature in Vegas, and lets you easily cut between the three shots as the video is playing. Once the cuts were finalised, it was just a matter of putting a 16 frame cross-fade between each shot, adding top and tail titles and rendering out as a Windows Media file.

Final file sizes were ranged from 700Mb to 1.5Gb per session - 720p targetting a 3.5Mb data rate.

Distribution

This was where Mike Ormond came in - he'd most graciously offered to get the final videos up onto Channel 9 for distribution, and provided access to Microsoft's "big-file-upload" service. He then took each one, uploaded it to C9 for conversion and authored the associated blog posts that are linked above.

Final Thoughts

Was it worth doing?

Absolutely. The DDD sessions are always a superb resource on their subject matter, so allowing those that couldn't be there on the day to see them is highly valuable.

What would you do differently?

First, take a week off from my day-job to do the edit! Fitting this level of complex editing into late-nights and weekends when you've got a young family is hard.

Second, given a larger budget I'd have at least one other cameraman, a second Canon, boom operater / mic runners and record the screen output directly.

Thirdly, I'd try and have Rob Miles tied to the desk! His exuberance makes it damn hard to film as be bounds around and even harder to edit - but that's what makes him such an engaging presenter.

Thanks to everyone involved in setting up this event and letting me record it - may there be many more.

Another New Start

There are a couple of the reasons I've been so quiet on this blog. Firstly, Blogger was (until recently) blocked entirely at my workplace, making ad-hoc posts a pain; and secondly because Chris Alcock has done such a sterling job with "The Morning Brew" that my musings on .Net tidbits were entirely superflous (he well deserved his MVP for that).

But it's another New Year, Blogger has been unblocked at work, so I should really get on and post about some of the technical nuggets that have been stuck in limbo for the last year or more.

Time to dig into the internal blogs and wikis and pull out some nuggets.

What no posts?

I've been guilty of lapsing on my blogging before, but six full months without a Nugget is probably a personal record.

This time, however, I've got an excuse. No, really! Corporate policy.

Much as I can see the need to restrict access to Facebook and YouTube in the corporate environment, I've been torn over just how much technical content I've been missing since Twitter was blocked along with the major blog engines.

The block serves it's purpose - as an employee, I'm not idly browsing blogs, and nor am I posting drivel throughout the day. But whilst there are ways around the restrictions (go-go-gadget iPhone!) the pain of having to forward links or full articles to myself via email means that in general I don't.

So until I find an efficient way of blogging can I humbly point you to Chris (@calcock) Alcock's "The Morning Brew" - essential reading every day.

So now I'm a published author.

Well, not *EXACTLY*!

My MSDN Flash article “Getting started with MEF” made the grade and was included in the “MSDN Flash eBook of the best 13 technical articles of 2009”.

Thanks to Eric Nelson for including me – I’m well chuffed. Now to write some more!

Get it: http://blogs.msdn.com/ericnel/archive/2009/12/16/free-msdn-flash-ebook-of-the-best-13-technical-articles-of-2009.aspx

Friday Quickie: The *other* TemplateBinding syntax

Setting up the template for a new custom control in Silverlight is fraught at the best of times – the Silverlight runtime invariably swallows any error in the template and gives just a cryptic exception.

But stranger still is a limitation on how the {TemplateBinding ...} syntax can be used and the exception that is thrown when in error.

The {TemplateBinding ...} syntax provides a quick and simple way to bind properties within a control’s template to the properties of the control itself. According to the MSDN documentation, it’s a shortcut to the more full-featured {Binding ...} syntax. But what’s not clear from the documentation is that {TemplateBinding ...} can only bind a control property to a DependencyProperty on the control class.

If you try and use {TemplateBinding ...} against a normal property on the control, you get the strange exception shown right – confusing because the target control (WizardActionButton in the example) absolutely does have a State property.

The solution is to use the {Binding ...} syntax where the source property isn’t a DependencyProperty, and to use the {RelativeSource ...} syntax to specify that you’re actually binding to the control within its template.

Wrong:

<i4tControls:WizardActionButton x:Name="RetreatButtonPart"

Style="{StaticResource ActionButtonStyle}"

State="{TemplateBinding CanRetreat}"

Content="{TemplateBinding RetreatButtonContent}"

ContentTemplate="{TemplateBinding RetreatButtonContentTemplate}"

/>

Correct:

<i4tControls:WizardActionButton x:Name="RetreatButtonPart"

Style="{StaticResource ActionButtonStyle}"

State="{Binding Path=CanRetreat,RelativeSource={RelativeSource TemplatedParent}}"

Content="{TemplateBinding RetreatButtonContent}"

ContentTemplate="{TemplateBinding RetreatButtonContentTemplate}"

/>