Over the past few months, I’ve been working with Damián Martinez Gelabert, Nicolás Bello Camilletti, Johnny Halife, Juan Pablo García and Mauro Krikorian in a set of NuGet packages for ASP.NET MVC 3 and Silverlight for Windows Phone projects, targeting server-side and client-side pieces of the same scenario. During the development, we realized that we needed to run initialization code at startup to configure some settings required for our NuGet packages. Additionally, we had a hierarchy of NuGet packages and each of them needed to register its own settings to extend the original scenario.

Resolving these requirements in server-side NuGet packages was easy by using WebActivator as a dependency. This package provides a clean solution for this problem (without having to manually modify the Global.asax file) by letting you use multiple PreApplicationStartMethod and PostApplicationStartMethod assembly attributes to indicate the methods that are intended to run at startup (notice that the Pre and Post attributes already give an implicit execution order). For more information on this package you can check the WebActivator wiki.

On the Windows Phone client-side, however, we couldn’t find a package that did a similar thing. We wanted to have the same attribute-based clean experience to specify the code that should run at startup, to avoid being intrusive modifying existing application code. That is why we created the Silverlight Activator for Windows Phone package, to enable these features in Windows Phone applications.

• NuGet package @ http://nuget.org/List/Packages/SilverlightActivator
• Source code @ https://github.com/mconverti/silverlightactivator

How do I use it in my NuGet packages?

As I already mentioned, the idea behind this package is to allow other Silverlight for Windows Phone NuGet packages to execute some code when the application is starting up and/or closing. So, if you are planning to build a NuGet package with these requirements, you can leverage the Silverlight Activator for Windows Phone NuGet package as follows:

1. In your package’s .nuspec file, add a dependency on SilverlightActivator (version 1.0.4).

   <?xml version="1.0"?>
   <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
     <metadata>
       <id>YourSilverlightForWindowsPhonePackageId</id>
       <version>1.0.0</version>
       <!-- ... -->
       <dependencies>
         <dependency id="SilverlightActivator" version="1.0.4" />
       </dependencies>
     </metadata>
   </package>
   

2. For consistency with WebActivator, include an App_Start folder to place all your activation classes.
3. Under this folder, add the source code files with your initialization / finalization code as shown below (make sure to add the .pp extension to the file so it can be preprocessed).

   [assembly: SilverlightActivator.ApplicationStartupMethod(
       typeof($rootnamespace$.App_Start.MyClassInitializer),
       "ApplicationStartup",
       Order = 10)]
   [assembly: SilverlightActivator.ApplicationExitMethod(
       typeof($rootnamespace$.App_Start.MyClassInitializer),
       "ApplicationExit",
       Order = 10)]
   
   namespace $rootnamespace$.App_Start
   {
       public class MyClassInitializer
       {
           public static void ApplicationStartup()
           {
               // TODO: Add your startup code.
           }
   
           public static void ApplicationExit()
           {
               // TODO: Add your finalization code.
           }
       }
   }

The previous sample code uses the two available assembly attributes: ApplicationStartupMethod and ApplicationExitMethod. Take into account the following when using these attributes:

• The methods marked by the attributes must be static.
• The methods marked with the ApplicationStartupMethod attribute will be executed when the Application.Startup event is risen
• The methods marked with the ApplicationExitMethod attribute will be executed when the Application.Exit event is risen
• The Order property in the attributes lets you control the execution order of the methods. If not specified, its value is set to int.MaxValue by default (so it is the last to run).

How does it work?

The Silverlight Activator for Windows Phone package is composed of the following things:

1. The SilverlightActivator library, which contains the ActivationManager class with the logic to handle the activation logic based on the ApplicationStartupMethod and ApplicationExitMethod assembly attributes.
2. A transformation for the App.xaml file, which adds an application resource of type ActivationManager.

By adding the ActivationManager as an application resource, we are making sure that one instance of this class is created to register handlers for the Application.Startup and Application.Exit events.

public class ActivationManager
{
    private static bool initialized = false;
    // ...

    public ActivationManager()
    {
        if (!initialized)
        {
            Init();
            initialized = true;
        }
    }

    // ...

    private static void Init()
    {
        Application.Current.Startup += (s, e) => RunApplicationStartupMethods();
        Application.Current.Exit += (s, e) => RunApplicationExitMethods();
    }

    // ...
}

This way, when the Silverlight for Windows Phone engine rises those events, the ActivationManager iterates throughout all loaded assemblies in the phone application looking for ApplicationStartupMethod and ApplicationExitMethod assembly attributes and invoking the corresponding methods.

public class ActivationManager
{
    // ...
    private static bool loadAssemblyParts = false;
    private static bool assemblyPartsLoaded = false;

    // ...

    private static void RunActivationMethods<T>() where T : BaseActivationMethodAttribute
    {
        var deploymentParts = Deployment.Current.Parts.Cast<AssemblyPart>();

        // Load all deployment assembly parts based on the LoadAssemblyParts flag
        // in case they include activation attributes.
        if (loadAssemblyParts && !assemblyPartsLoaded)
        {
            Load(deploymentParts);
            assemblyPartsLoaded = true;
        }

        // Filter loaded assemblies to only get the deployment assembly parts.
        var activationAssemblies = AppDomain.CurrentDomain.GetAssemblies()
            .Where(a => deploymentParts.Any(p => p.Source.Equals(a.ManifestModule.Name, StringComparison.OrdinalIgnoreCase))
                        && (a != typeof(ActivationManager).Assembly))
            .ToList();
        var activationAttributes = new List<T>();

        // Iterate throughout all the loaded deployment assembly parts to look for activation attributes.
        activationAssemblies.ForEach(assembly => activationAttributes.AddRange(assembly.GetActivationAttributes<T>()));

        // Execute activation methods according to the order specified.
        foreach (var attribute in activationAttributes.OrderBy(at => at.Order))
        {
            attribute.InvokeMethod();
        }
    }

    // ...
}

By default, the ActivationManager class will not discover assembly attributes in assembly parts that are not loaded into the application domain. If you want to change this to let the ActivationManager load all the assembly parts at startup to look for activation attributes, you only need to set the LoadAssemblyParts property to True in the App.xaml application resource.

<?xml version="1.0" encoding="utf-8"?>
<Application
    x:Class="PhoneApp2.App"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:silverlightactivator="clr-namespace:SilverlightActivator;assembly=SilverlightActivator">

    <!--Application Resources-->
    <Application.Resources>
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
            </ResourceDictionary.MergedDictionaries>

            <silverlightactivator:ActivationManager
                x:Name="SilverlightActivator"
                LoadAssemblyParts="True" />
        </ResourceDictionary>
    </Application.Resources>

    <!--...-->
</Application>

Feedback is always welcome,

Mariano

OData provides a great solution for this service’s goal, since the existing Team Foundation Server 2010 Client Object Model only works for applications developed on the Windows platform. OData, on the other hand, is built upon Web technologies and therefore it is accessible from any platform which supports HTTP requests.

This OData service works in the scope of an specific TFS Project Collection, and the resources that you can query are Builds, Changesets, Changes, Builds, Branches, Work Items, Attachments, Projects, Queries and Area Paths. Since this service is secured with Basic Authentication, you can easily execute queries from any Web browser and see the results as a feed.

To get more context and details about the OData Service for Team Foundation Server 2010 you can check the following resources:

• Announcement: http://blogs.msdn.com/b/briankel/archive/2011/04/07/odata-service-for-team-foundation-server-2010.aspx
• Download: http://www.microsoft.com/downloads/details.aspx?FamilyID=d6f8968c-f27f-43fb-88ae-8805db257a67
• Brian Keller’s Channel 9 video: http://channel9.msdn.com/Blogs/briankel/OData-Service-for-Team-Foundation-Server-2010
• CodePlex OData API Preview (online version targeting CodePlex TFS): https://codeplexodata.cloudapp.net
• Open Data Protocol (OData): http://www.odata.org

Content

The ODataForTFS2010-SampleSetup-Beta.exe self-extractable package that you download from Microsoft Download Center contains the following items:

• Configuration Wizard to check the software requirements and setup your local IIS for the OData service for TFS
• Readme document with detailed information about the available operations and how to configure the service and samples
• Source code and unit tests of the OData service for TFS
• Sample Console client that lets you test the write operations (create / update work items and upload attachments to them)
• Sample Windows Phone 7 client application that uses the OData client library for Windows Phone to consume the OData service for TFS
• ODataForTFS Helper for WebMatrix that uses the OData Helper for WebMatrix to consume the OData service for TFS (there is also available detailed documentation for this helper and a WebMatrix sample application that uses it)

Additionally, you can check the CodePlex OData API Preview which is an online version of the OData service for TFS deployed in Windows Azure that specifically targets CodePlex TFS. You will find all the information needed to work with CodePlex OData API in the online documentation at https://codeplexodata.cloudapp.net.

Enjoy

Mariano

• Official announcement: http://www.wadewegner.com/2011/03/windows-azure-toolkit-for-windows-phone-7/
• Download the toolkit: http://watoolkitwp7.codeplex.com/releases/view/61952
• Online documentation: http://watoolkitwp7.codeplex.com/documentation
• Cloud Cover Episode: http://channel9.msdn.com/Shows/Cloud+Cover/Cloud-Cover-Episode-41-Windows-Azure-Toolkit-for-Windows-Phone-7

After downloading the WAZToolkitForWP7.Setup.exe self-extractable package from CodePlex and running it, execute the Setup.exe command to launch the Configuration Wizard. This tool will check the software requirements and then run the appropriate VSIX files to install the project templates in the different Visual Studio editions.

When you finish configuring your environment, make sure to review the Readme.htm file to get more context about the toolkit and all its content.

As I said before, the toolkit ships with project templates and a sample application among other things. Both of these assets make use of a set of services and a phone client library that you can reuse to build your own phone applications.

Toolkit Services

One of the main purpose of the services included in this toolkit is to provide a secure location where to put the azure storage account name and key. This means that you can avoid including this information inside your phone application, and instead rely on any other authentication & authorization mechanisms to secure the content in your storage (like ASP.NET Membership and Roles providers).

The toolkit services are hosted in an ASP.NET MVC 2 Web role with the following endpoints:

• ~/AuthenticationService: This is a WCF REST service that exposes operations to register new users and get an authentication token. Before consuming any other service, you need to obtain a token from this service and then using it to authenticate your requests.
  Note: Both the authentication and authorization mechanisms rely on the ASP.NET Membership and Roles providers for Azure Tables. The binaries and source code of these ASP.NET providers are also included in the toolkit.
• ~/AzureTablesProxy.axd: This is an HTTP handler that acts as a proxy for the Windows Azure Tables REST API. All the requests that are addressed to this endpoint are forwarded to the real Azure Tables endpoint and signed with the storage account key.
• ~/SharedAccessSignatureService: This is a WCF REST service that generates Shared Access Signatures to work with containers and blobs.

Additionally, a Web site is provided along with the services to manage authorization permissions for the different users.

Windows Phone 7 Code Library and Sample Application

The toolkit includes the binaries and source code of an Azure storage client library for Windows Phone 7 called WindowsPhoneCloud.StorageClient. This client library allows Windows Phone developers to:

• Create and delete Azure Tables
• Perform CRUD operations on Azure Tables’ rows
• Upload blobs to a private / public containers using Shared Access Signatures
• List blobs in a private / public container using Shared Access Signatures

The phone application that you can find in the sample application solution and project templates, showcases the previous features in different pages.

Enjoy

Mariano

Today Roger announced in his blog the availability of the SQL Server 2008 R2 Update for Developers Training Kit (June 2010 Update). This is the final update for this training kit and includes two additional modules covering SQL Server 2008 R2 related improvements in Excel 2010 and SharePoint 2010. Additionally, there were many updates to the original content in previous versions of the training kit to address changes in the final RTM release of SQL Server 2008 R2 (e.g. some UI changes, modifications in the API, minor bug fixing, etc).

You can download this new release at:

• http://go.microsoft.com/?linkid=9710868 (notice that is the same URL of previous releases)

New modules added to the Training Kit

As I said previously, the Excel 2010 and SharePoint 2010 modules were included in the RTM release related with SQL Server 2008 R2 improvements:

• Excel 2010: Excel is the most popular data analysis tool in the world, and Excel 2010 offers a range of powerful data analysis and visualization improvements that makes it the ideal self-service analysis client. Slicers are new visual controls that provide quick, easy and interactive filtering. Sparklines are intense, simple word-sized graphics that make it easy to visualize data in-line with numbers. PivotTables support powerful new capabilities like named sets, what-if analysis (write-back), and pre-built calculations like percent of total, running totals and ranks. Charting has also been improved with an easier user interface, faster performance and expanded limits. SQL Server 2008 R2 introduces PowerPivot for Excel, a free Excel add-in that makes it possible for information workers to create their own powerful analytic models by combining and relating data from a wide variety of data sources.
• SharePoint 2010: SharePoint 2010 is the most popular business collaboration platform in the world for organizations of all sizes, and SharePoint 2010 Insights lets everyone access the business information they need to make good decisions. SharePoint 2010 Insights uses well-known applications and interfaces, people are comfortable from the start, and they know how to get the data they need. Excel Services makes it easy for anyone to publish their Excel workbooks in SharePoint 2010, including workbooks that use data from SQL Server 2008 R2 Analysis Services. From there, an entire team can access and analyze the same data from their web browser and rest assured that everyone has the right information. PerformancePoint Services is a new integrated capability in SharePoint 2010 Enterprise Edition that makes it easy to build flexible, highly interactive scorecards and dashboards using data from SQL Server 2008 R2 Analysis Services. SQL Server 2008 R2 PowerPivot for SharePoint makes it easy to publish analytic models created with SQL Server PowerPivot for Excel to SharePoint 2010 and share them with other users with Excel Services. SQL Server 2008 R2 Reporting Services supports SharePoint 2010 integration, making it easy to publish and access reports using familiar SharePoint paradigms.

Requirements

• Microsoft SQL Server 2008 R2
• Microsoft Visual Studio 2010
• Microsoft Office 2010 Excel
• Microsoft SQL Server PowerPivot for Excel
• Microsoft SQL Server 2008 R2 StreamInsight
• Microsoft SQL Server 2008 R2 Report Builder 3.0
• Microsoft SharePoint Server 2010

Enjoy

Mariano

You can download the training kit from the Microsoft Download Center at:

• http://go.microsoft.com/?linkid=9710868 (notice that is the same URL of previous releases)

If you do not want to download the training kit, but you do want to check what is inside it, you can review its content online in the Channel 9 Learning Center Courses at:

• http://channel9.msdn.com/learn/courses/SQL2008R2TrainingKit

New ‘Application and Multi-Server Management’ module

SQL Server 2008 R2 introduces a set of improvements known as Application and Multi-Server Management (AMM) designed to reduce the cost and complexity of managing database servers and applications, and to help customers get more out of their SQL Server investments. Administrators can register all of their SQL Server instances and automatically collect data on utilization using a new role called a Utility Control Point (UCP). This data is consolidated and visualized using the new Utility Explorer in SQL Server Management Studio, allowing administrators to quickly isolate utilization problems and make more informed consolidation decisions.

This utilization data provides consolidated insight for both database server instances and database applications that are built using new data-tier application projects in Visual Studio 2010. Developers can now build a single unit of deployment for the data-tier portion of an application known as a DACPAC. A DACPAC contains metadata that describes all of the objects in a database application, as well as policies which govern their deployment.

A single DACPAC can be handed off to an administrator to deploy instead of collections of complicated Transact-SQL scripts. SQL Server 2008 R2 automatically evaluates the policies in the DACPAC during deployment for compliance, creates the associated database objects and registers the data-tier application. Upgrades are performed automatically from one version of a data-tier application to another, eliminating the need for administrators to perform manual upgrades.

If the database server is registered with a Utility Control Point, utilization data will be automatically collected for all registered data-tier applications and made visible in the Utility Explorer, enriching the administrator’s insight.

New ‘StreamInsight’ module

SQL Server 2008 R2 introduces StreamInsight, a comprehensive development platform for building event-driven applications. While typical relational database applications are query-driven, event-driven applications are characterized by high event data rates, continuous standing queries, and millisecond latency requirements that make it impractical to store the data in a relational database for processing.

Event driven application workloads are common in many different industries, including manufacturing, oil and gas, utilities, financial services, health care, retail, web analytics, and data center monitoring. Developers turn to complex event processing (CEP) technology like StreamInsight to query, monitor and identify patterns and relationships from huge volumes of seemingly unrelated events, then trigger response actions when specific conditions are met.

Related Resources

• Data-tier Application Whitepaper
• Data-tier Application Tutorials
• Microsoft StreamInsight Documentation

As Roger announced in his blog, the first release of the SQL Server 2008 R2 Update for Developers Training Kit is available for free download from the Microsoft Download center at:

• http://go.microsoft.com/?linkid=9710868

The SQL Server 2008 R2 Update for Developers Training Kit is ideal for developers who want to understand how to take advantage of the key improvements introduced in Microsoft SQL Server 2008 and Microsoft SQL Server 2008 R2 in their applications, as well as for developers who are new to SQL Server.

Stay tuned because new releases of this training kit are going to be published every two weeks approximately containing new labs, demos, presentations and videos related to SQL Server 2008 R2 features.

Training Kit Content

This release contains all the original content from the SQL Server 2008 Developer Training Kit (but targeting Microsoft SQL Server 2008 R2) and also the following new one:

• How to build your first web application with SQL Server and ASP.NET: This hands-on lab shows how to connect to SQL Server and perform Create, Read, Update and Delete (CRUD) operations on SQL Server 2008 from an ASP.NET Web application. It also shows you how to work with images stored in SQL Server in a web application. This lab is ideal for developers who are new to building web applications with SQL Server and ASP.NET.
• Data-tier Applications in SQL Server 2008 R2 and Visual Studio 2010: This hands-on lab shows how to perform the basic steps in creating, developing, deploying, managing and upgrading a Data-tier Application (DAC) using the new features in Microsoft SQL Server 2008 R2 and Microsoft Visual Studio 2010. It also shows some of the new IDE tools and enhancements included in Microsoft Visual Studio 2010 to work with Database projects.
• Introduction To StreamInsight and Complex Event Processing: Microsoft SQL Server StreamInsight is Microsoft’s new Complex Event Processing technology to help businesses derive better insights by correlating event streams from multiple sources with near-zero latency. This hands-on lab shows how to leverage the new StreamInsight framework released as part of Microsoft SQL Server 2008 R2 while developing a StreamInsight sample application. It also explains the basics about Complex Event Processing.
• Using the New Features of Reporting Services 2008 R2: This hands-on lab introduces the new features included in Microsoft SQL Server 2008 R2 Reporting Services like the Map Wizard to display geospatial data, the lookup functions in report expressions so that data from multiple datasets can be shown in a single data region and the capability to export report data to an Atom data feed. It also shows the new features in Report Builder 3.0.
• PowerPivot in SQL Server 2008 R2: This hands-on lab introduces to the Microsoft SQL Server PowerPivot for Excel 2010 add-in and shows how to load data into it and how to create PowerPivot pivot tables. It also introduces DAX expressions for multidimensional calculations against PowerPivot data and explains how to publish PowerPivot workbooks to Microsoft SQL Server PowerPivot for SharePoint 2010.
• 7 Introductory Videos: these videos introduce and review the new features and enhancements in Microsoft SQL Server 2008 and Microsoft SQL Server 2008 R2.
  • SQL Server 2008 R2 Update for Developers Overview Part I – SQL Server 2008 Review
  • SQL Server 2008 R2 Update for Developers Overview Part II – Introducing SQL Server 2008 R2
  • Introducing SQL Server 2008 R2 StreamInsight
  • Demo: Real Time Analytics with SQL Server 2008 R2 StreamInsight
  • Introducing SQL Server 2008 R2 Application and Multi-Server Management
  • Introducing SQL Server 2008 R2 Reporting Services
  • Introducing PowerPivot for Excel 2010 and SharePoint 2010

Resources

• Microsoft SQL Server 2008 R2 November CTP
• AdventureWorks 2008 R2 Sample Databases
• Microsoft Visual Studio 2010 Ultimate 2010 Beta 2
• Microsoft SQL Server PowerPivot for Excel
• Microsoft Office 2010 Excel Beta
• Microsoft SharePoint Server 2010 Beta

Enjoy

Mariano

During this month I was working with my teammates Julian Dominguez and Diego Perez on a project that targeted Window Mobile 6.0 and the .NET Compact Framework 3.5. The main objective of this project was to create a module for an existing mobile application to let users perform different surveys and allowing them to navigate and filter through the questions and answers (between other things).

Among all the requirements for this project, there was one that asked for a view to show a hierarchical list of the questions / answers of the survey grouped by their types. The special thing about this view was that only some items of the hierarchical list should be checkable. Julian and I tried to use the TreeView control included in the .NET Compact Framework, but this control does not allow you to choose which items are checkable and which are not. So we decided to extend the default TreeView and create an optional checkable TreeView control. These were the results:

As you can see, in the default TreeView control (on the left) all the nodes has check boxes even the ones that are expandable. In the OptionalCheckableTreeView control (on the right) the expandable nodes are not checkable.

Implementation Details

Instead of setting the CheckBoxes property of the TreeView to true, we are using images to display the check boxes (either in checked or unchecked state) and the minus and plus icons to expand the tree.

To accomplish this we had to add support for the NodeMouseClick event, which is not available in the .NET Compact Framework. This event allows us to check / uncheck / expand / collapse the clicked node and also change the image index. We followed the guidance provided in the following articles in MSDN, with a few modifications:

• How to: Use a Helper Class for Platform Invokes
• How to: Use a Class for Hooking Windows Procedures
• How to: Subclass a TreeView by Using Native Callbacks

Download

Download the C# source code from here. The ZIP file contains the following:

• OptionalCheckableTreeView.sln: Contains the source code for the OptionalCheckableTreeView control.
• OptionalCheckableTreeView.Sample.sln: Contains a sample application that uses the OptionalCheckableTreeView control.

Feedback is always appreciated!

Mariano

The purpose of this post is to provide an overview of the things that should be taken into account to use the Silverlight 3 Navigation Framework in a Prism v2 application, as well as the limitations / issues that you could come up with during the integration. I used the Remote Modularity QuickStart (shipped with the Composite Application Guidance for WPF and Silverlight – February 2009) as the base application and modified it to provide navigation among modules. As you can see in the image bellow, the original QS (in the left) shows all the modules at once and the updated one (in the right) provides navigation links to see each module page separately.

System Requirements

To be able to open the source code that accompanies this post and follow its guidance, you will need the following:

• Visual Studio 2008 SP1 or Visual Web Developer Express 2008 SP1
• Microsoft® Silverlight™ 3 Tools Beta 1 for Visual Studio 2008 SP1

Steps

The following are the general steps that I performed to add navigation functionality to the Remote Modularity QuickStart, but they could also be reused in other Prism v2 applications:

1. Add a reference to the System.Windows.Controls.Navigation assembly in the Shell project. This assembly contains the Frame and Page controls needed to navigate and the classes that allow the mapping of the Uris.
2. Add a Frame control to the Shell of the Silverlight application. The Frame control is the container for pages. It allows you to navigate to a Uri and exposes a bunch of useful events related to navigation.

   <UserControl x:Class="RemoteModuleLoading.Shell"
       …
       xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation">
       …
       <StackPanel>
           <ItemsControl cal:RegionManager.RegionName="LinkRegion">
               <ItemsControl.ItemsPanel>
                   <ItemsPanelTemplate>
                       <StackPanel Orientation="Horizontal"/>
                   </ItemsPanelTemplate>
               </ItemsControl.ItemsPanel>
               <ItemsControl.Items>
                   <HyperlinkButton Content="Home" Tag="Home"
                        cmd:Click.Command="{Binding NavigateCommand}"
                        cmd:Click.CommandParameter="{Binding RelativeSource={RelativeSource Self}, Path=Tag}" />
               </ItemsControl.Items>
           </ItemsControl>
           <navigation:Frame x:Name="MainFrame" Source="Home" />
       </StackPanel>
       …
   </UserControl>

3. Add a UriMapper to the Application Resources in the App.xaml file.

   <Application
                …
                xmlns:navcore="clr-namespace:System.Windows.Navigation;assembly=System.Windows.Controls.Navigation">
       <Application.Resources>
           <navcore:UriMapper x:Key="uriMapper">
               <navcore:UriMapping Uri="Home" MappedUri="/Views/Home.xaml" />
           </navcore:UriMapper>
       </Application.Resources>
   </Application>

4. Add UriMappings inside the Initialize method of the Module class of each module. The UriMapping class allows us to display a more user friendly Url in the browser. Defining this mapping inside each module avoids having them hard-coded inside the Shell project.

   public void Initialize()
   {
       AddModuleUriMappings();
   
       this.regionManager.Regions["LinkRegion"].Add(new ModuleZLink());
   }
   
   private static void AddModuleUriMappings()
   {
       UriMapper mapper = (UriMapper)Application.Current.Resources["uriMapper"];
       mapper.UriMappings.Add(new UriMapping()
                           {
                               Uri = new Uri("ModuleZ", UriKind.Relative),
                               MappedUri = new Uri("/ModuleZ;component/DefaultViewZ.xaml",
                                                   UriKind.Relative)
                           });
   }

5. For each module, add an UserControl containing an HyperlinkButton which points to the Uri previously mapped. This UserControl is added to the LinkRegion of the Shell when the module is initialized.

   <UserControl x:Class="ModuleZ.ModuleZLink"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
       xmlns:cal="clr-namespace:Microsoft.Practices.Composite.Presentation.Commands;assembly=Microsoft.Practices.Composite.Presentation">
   
       <HyperlinkButton Content="Module Z" Tag="ModuleZ"
                        cal:Click.Command="{Binding NavigateCommand}"
                        cal:Click.CommandParameter="{Binding RelativeSource={RelativeSource Self}, Path=Tag}" />
   
   </UserControl>

   Note: The value of the Tag property of the HyperlinkButton control is the Uri that will be used for navigate. Also notice that I’ve bound the Click event of the control to a NavigateCommand.  For more information related to commands, see Commands article in Prism v2 documentation.

6. Create a global CompositeCommand to handle the navigation within the frame. In this way, all the links previously added will use the frame control defined in the Shell to perform the navigation when they are clicked.

   public Shell(IUnityContainer container, CommandProxy command)
   {
       InitializeComponent();
   
       this.container = container;
       command.NavigateCommand.RegisterCommand(new DelegateCommand<string>(this.OnNavigate));
   
       this.MainFrame.Navigated += new NavigatedEventHandler(this.MainFrame_Navigated);
       this.DataContext = command;
   }
   
   private void OnNavigate(string url)
   {
       this.MainFrame.Navigate(new Uri(url, UriKind.Relative));
   }

7. Add a handler to the Navigated event of the frame control to perform dependency injection in the pages. This requires all the pages to use property injection instead of constructor injection.

   private readonly IUnityContainer container;
   
   private void MainFrame_Navigated(object sender, NavigationEventArgs e)
   {
       if (e.Content != null)
       {
           this.container.BuildUp(e.Content.GetType(), e.Content);
       }
   }

You can download the final solution from the Download section bellow.

Limitations / Issues when modules are loaded dynamically

When the modules are statically loaded, all the above steps work without problems. All the assemblies are declared in the AppManifest.xaml file of the Silverlight application and deployed / loaded before the application starts. Therefore, all the types and resources defined in the modules are available for navigation.

However, if the modules are dynamically loaded like in the Remote Modularity QuickStart, they are not included in the AppManifest.xaml file because their assemblies are deployed on demand by the CAL. This causes some problems when trying to crate an instance of a page class during the navigation. The exception you get says that the type specified in the x:Class attribute of the XAML could not be found in any loaded assembly. I’ve tried the following things to bypass this limitation without success:

1. Modified the XapModuleTypeLoader class of the CAL to add all the AssemblyParts of the modules to the Deployment.Current.Parts collection. This caused no effect.
2. Tried to add the assembly name to the x:Class attribute of each page. However, I was no able to specify the assembly in the x:Class attribute using the syntax x:Class=”namespace.classname;assembly=assemblyname” like the official Silverlight documentation explains. I got a compilation error saying that the value of the x:Class attribute is not a valid fully qualified class name.

Finally I opted for a workaround and found the following two possible ones:

1. Remove code behind classes in module’s pages: If your pages do not contain any x:Class attribute the navigation will work smoothly. You can take advantage of all the features available in Silverlight 3 (like Bindings, Commands, StaticResources, etc) to avoid having a code behind class.
2. Use a Placeholder page in the shell module to host module pages: If your pages are complex and you cannot avoid having code behind classes, you can create a page in the Shell module to which all modules can navigate. This placeholder page will receive as a QueryString parameter the type of the view that should contain, resolve it in the application Container and add it to its Content property. This logic should be placed in the Loaded event of the page.

   // Loaded event of the placeholder page
   private void ModulePlaceHolderPage_Loaded(object sender, RoutedEventArgs e)
   {
       string type = this.NavigationContext.QueryString["viewType"];
       UIElement moduleView = null;
   
       if ((type != null) && (Type.GetType(type) != null))
       {
           Type viewType = Type.GetType(type, false);
           moduleView = this.Container.Resolve(viewType) as UIElement;
       }
   
       // Show in the content place holder the module view
       this.Content = (moduleView != null) ? moduleView :
                                             new TextBlock()
                                             {
                                                 Foreground = new SolidColorBrush(Colors.Red),
                                                 TextWrapping = TextWrapping.Wrap,
                                                 Text = String.Format(CultureInfo.CurrentUICulture,
                                                                      "View {0} was not found.", type)
                                             };
       this.Title = this.NavigationContext.QueryString["title"];
   }

   Each module should also define its own Uri mappings to point the placeholder page adding the right QueryString parameters.

   private static Uri CreateModuleUri()
   {
       string queryString = String.Format("viewType={0}&title={1}",
                                          typeof(DefaultViewY).AssemblyQualifiedName,   // View type
                                          "Module Y - RemoteModuleLoading Quickstart"); // Title
   
       // I added the base Uri of the placeholder page inside the Shell project.
       string modulePlaceHolderUri = Application.Current.Resources["placeHolderUri"] as string;
   
       return new Uri(String.Format("{0}?{1}", modulePlaceHolderUri, queryString), UriKind.Relative);
   }

Download

Download the C# source code from here. The file contains the following:

• CAL folder: contains the source code of the Composite Application Library shipped with the Composite Application Guidance for WPF and Silverlight – February 2009.
• LIB folder: contains assemblies required by the Composite Application Library.
• RemoteModularityQuickstart folder: contains the updated Remote Modularity Quickstart to use navigation functionality with the Silverlight 3 Navigation Framework using workarounds described previously.
• StaticModularityQuickstart folder: contains the updated Remote Modularity Quickstart to use navigation functionality with the Silverlight 3 Navigation Framework and modified to statically load modules.

Feedback is always appreciated!

Mariano

Additionally, the signature of a command handler is fixed and should always be like the following:

[CommandHandler(CommandNames.MyCommand)]
public void OnMyCommandHandler(object sender, EventArgs args)
{
    // The sender parameter is an instance of the Command class.
    Command cmd = sender as Command;

    // The args parameter is empty.
    bool f = (args == EventArgs.Empty);
} 

The instance of the Command class received in the sender parameter could be useful, for example, if you want to change the status of the command to Enabled, Disabled or Unavailable.

cmd.Status = CommandStatus.Disabled;

But, what if you want to share the same command handler for different command invokers (like several menu items) and perform some operations based on which item was the invoker? You will somehow need to receive a parameter describing which was the item that raised the command.

Workaround

A possible workaround to receive parameters using a command could be by not adding your items as invokers of the command and instead execute the command programmatically. If you do this, you could use the State collection of the RootWorkItem to pass parameters to the command.

To implement this workaround follow these steps (the code use the ToolStripMenuItem control but could be used with other toolstrip controls):

1. Add the parameter that you want to receive in the command handler to the Tag property of your menu item control:

   ToolStripMenuItem item = new ToolStripMenuItem() { Text = "My Menu Item", Tag = "My Tag"};

2. Add a handler for the Click event to your menu item:

   item.Click += new EventHandler(Item_Click);

3. In the Item_Click method, add the Tag of your item to the State collection of the RootWorkItem and execute the command programmatically:

   WorkItem.RootWorkItem.State["LastTag"] = item.Tag;
   WorkItem.Commands[CommandNames.CommandWithParameters].Execute();

4. In the command handler, retrieve the Tag from the State collection:

   string tag = WorkItem.RootWorkItem.State["LastTag"] as string;

The following code shows a ModuleController class that demonstrates how the approach above could be implemented:

public class ModuleController : WorkItemController
{
    public override void Run()
    {
        AddServices();
        ExtendMenu();
        AddViews();
    }

    private void ExtendMenu()
    {
        AddTaggedMenuItem("Menu Item 1", "Tag 1", UIExtensionSiteNames.ModulesMenu);
        AddTaggedMenuItem("Menu Item 2", "Tag 2", UIExtensionSiteNames.ModulesMenu);
        AddTaggedMenuItem("Menu Item 3", "Tag 3", UIExtensionSiteNames.ModulesMenu);
        AddTaggedMenuItem("Menu Item 4", "Tag 4", UIExtensionSiteNames.ModulesMenu);
    }

    private void AddTaggedMenuItem(string menuText, string menuTag, string extensionSiteName)
    {
        ToolStripMenuItem menuItem = new ToolStripMenuItem() { Text = menuText, ToolTipText = menuText, Tag = menuTag };

        menuItem.Click += new EventHandler(MenuItem_Click);

        WorkItem.UIExtensionSites[extensionSiteName].Add(menuItem);
    }

    private void MenuItem_Click(object sender, EventArgs e)
    {
        ToolStripMenuItem item = sender as ToolStripMenuItem;

        if (item != null)
        {
            WorkItem.RootWorkItem.State["LastTag"] = item.Tag;
            WorkItem.Commands[CommandNames.CommandWithParameters].Execute();
        }
    }

    [CommandHandler(CommandNames.CommandWithParameters)]
    public void OnCommandWithParameters(object sender, EventArgs args)
    {
        string tag = WorkItem.RootWorkItem.State["LastTag"] as string;

        if (tag != null)
        {
            MessageBox.Show("The tag received in the command handler is: " + tag, "Tags");
        }
    }

    // ...
}

In this way, the State collection is used as a container for your custom command parameters.

Enjoy.

• Migrating Prism v2 RI from static to dynamic module loading

As I mentioned, the article targets the migration of the Silverlight Reference Implementation included in the Prism V2 – Drop 10, but you could use it as a guidance to migrate any Prism v2 Silverlight application from static to dynamic (remote) module loading. The main steps are:

1. Update Silverlight class library projects to Silverlight application projects to generate XAP files
2. Set up remote module loading by adding a ModulesCatalog.xaml file and modify the Bootstrapper class
3. Create a Web Application Project to host the application

The team also published the following:

• The PDF version of the article
• The updated source code of the Silverligh RI