Preface

This is a quick introduction towards starting your life with Microsoft Robotic Developer Studio (RDS) and Microsoft Visual Programming Language (MVPL) for creating simple robotic simulations. This is intended to be an ‘absolute beginner’s guide’ to RDS. 

In fact, I just started playing with RDS after some inspiration from Ramaprasanna during Kerala DevCon 2010 – and it is fun. And the objective of this post is to share the fun, mainly from a hobby programming perspective.

As a pre-requisite, for doing the hands own instructions below – you may need to download and install  Microsoft Robotic Developer Studio 2008 R3 – The installation should be pretty simple and easy.

Microsoft Robotic Developer Studio (RDS) comes with

• Microsoft Visual Programming Language – An easy to use visual language so that even non programmers can create simulations
• A 3D Environment simulation module

The RDS comes with two runtimes

• The Concurrency and Coordination runtime (CCR) – To make easy the handling of asynchronous input/output scenarios when you deal with sensors, motors etc
• The Decentralized Software Services (DSS) model – To enable easy access and response to your robots and devices, via desktop, web etc

Now, the fun part.

Your First Simulation

So, Let us create a quick simulation, using the Microsoft Visual Programming Language environment.

1 – Bring up the VPL Designer

Assuming that you’ve already got the Microsoft Robotic Developer Studio installed, goto Start –> Programs –> Microsoft Robotics Developer Studio 2008 R3 –> Microsoft Visual Programming Language 2008 R3, to bring up the Visual Programming Language environment.

Note that you’ll get the VPL Designer, and you’ve a Basic Activities toolbox and Services toolbox on the left pane, a Designer in the middle, and a Project explorer pane towards the right.

2 – Let us pick a Joystick

In the Services pane, search for Joystick to filter the listings. Just drag and drop Desktop Joystick from the Services toolbox to the designer pane as shown below. You’ll see a rectangular indicator with a set of connectors.

3 – Let us pick a Target service

The next step is obviously to pick a target to receive our Joystick notifications. So, again from the services pane, locate a simple Generic Differential Drive device, and drag it to the designer area as we did for the Joystick.

4 – Connect the Joystick to our target

The next step is to connect the Joystick to the target device. For this, create a connection from the Notification icon of our DesktopJoystick towards the GenerciDifferntialDrive indicator (You can click and drag), so that it’ll bring up the Connections dialog box. There, on the ‘From’ area, select UpdateAxes, and ‘To’ area, select SetDrivePower.

By common sense, this means that when ever user changes the axes of the Joystick, the notification will be pumped to SetDrivePower action of our GenericDifferentialDrive service

5 – Set the data properties

Once you press OK button of the connections dialog, this will bring up the Data Connections dialog box. There, you need to check the ‘Edit Values directly’ checkbox (see the Data Connections dialog box below), so that you can edit the values. Modify the Values to what you see in the dialog box below. The target variables (LeftWheelPower and RightWheelPower) represent the parameters of SetDrivePower notification we specified in the above step. The X and Y values represent the input values we are getting from the DesktopJoystick service. And finally, your diagram should look like what you see in the Diagram pane below. You can select the Connector anytime to edit the data connection properties you just specified.

6 – Specify a manifest for your DifferentialDrive service

The final step is to specify a manifest for the GenericDifferentialDrive Service. For this, Select the GenericDifferentialDrive service by clicking it to bring up the properties in the Properties window. In the Properties window, select the Configuration as “Use a manifest”, and click the ‘Import’ button to select a manifest. This will bring up a dialog box, and select the IRobot.Create.Simulation.Manifest, so that it’ll appear in the properties windows as shown below.

7 – Time for action, Run the simulation.

Just press F5 to run the simulation. You’ll see the simulation environment coming up. Just use your mouse in the Desktop Joystick window, and see the robot moving in the simulator.

Go ahead and explore more. Have a look at the samples that came with your Robotic Studio installation. Happy Coding!!

This post assumes you are familiar a bit with the MVVM concepts. Otherwise, here is a 5 minute overview from John Papa

How do you wire up your ViewModels to your Views in your WPF and Silverlight apps? Of course, the simplest approach is assigning your View Model’s instance to the View’s data context, in the code behind .

    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.DataContext = new MainViewModel();
        }
    

Understanding The ViewModelLocator Concept

An alternate way to do the above task is via a ViewModelLocator implementation, mainly so that you can preserve the Blendability – to enable designers to see see the correct preview of the View. Laurent Bugnion has a pretty neat implementation of ViewModelLocator in his MVVM Light toolkit . A simple approach to use ViewModelLoator in MVVMLight is – you can create an instance of ViewModelLocator and keep it in App.xaml as a global resource, so that you can bind your views to that – As shown below. Assume we have a MainWindow.xaml view and a MainViewModel class as our view model

1 – Create a global resource in your App.xaml

    <Application.Resources>
        <!--Global View Model Locator-->
        <vm:ViewModelLocator x:Key="Locator"
                             d:IsDataSource="True" />
    </Application.Resources>

2 – You can bind to your locator from your Views.

<Window x:Class="MvvmLightApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow"
        Height="300"
        Width="300"
        DataContext="{Binding Main, Source={StaticResource Locator}}">

		<!-- More Xaml -->

</Window>	

If you are interested in the actual implementation of ViewModelLocator in MVVMLight, here is a ‘trimmed down’ version (The whole code of ViewModelLocator.cs is here in codeplex, under MVVMLight repository)

  public class ViewModelLocator
    {
        private static MainViewModel _main;

        /// <summary>
        /// Initializes a new instance of the ViewModelLocator class.
        /// </summary>
        public ViewModelLocator()
        {
            CreateMain();
        }

        /// <summary>
        /// Gets the Main property.
        /// </summary>
        public static MainViewModel MainStatic
        {
            get
            {
                if (_main == null)
                {
                    CreateMain();
                }

                return _main;
            }
        }

        /// Gets the Main property.
        public MainViewModel Main
        {
            get
            {
                return MainStatic;
            }
        }

        /// Provides a deterministic way to create the Main property.
        public static void CreateMain()
        {
            if (_main == null)
            {
                _main = new MainViewModel();
            }
        }

		//Clean up code omitted..

    }	

As you can see, you are expected to expose a property per ViewModel that returns a singleton instance of the same – so that we can bind to the same from the View.  Of course, the MVVMLight implementation is pretty clean and neatly blendable.

Locating ViewModels by Convention – AutoViewModelLocator

I was a bit lazy to create a property per ViewModel in the ViewModelLocator, and thought it is nice if I get my ViewModels resolved by convention. Thus born the AutoViewModelLocator. Have a look at the source code first.

 public class AutoViewModelLocator
    {
        private static List<object> _viewModels = new List<object>();

        /// <summary>
        /// Return the view model based
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public object this[string name]
        {
            get
            {
                //Need to have a cleaner way of doing this
                var type = typeof(AutoViewModelLocator).Assembly.GetTypes().First
                 (t => t.IsClass && t.Name.EndsWith(name + "ViewModel"));

                var obj = _viewModels.Find(vm => vm.GetType() == type);

                if (obj != null)
                {
                    return obj;
                }
                else
                {
                    obj = Activator.CreateInstance(type);
                    _viewModels.Add(obj);
                    return obj;
                }
            }
        }

        /// <summary>
        /// Cleans up all the resources.
        /// </summary>
        public static void Cleanup()
        {
            foreach (var vm in _viewModels)
            {
                //Cleaup here
            }
        }
    }

Nothing big there. As you can see, we are instantiating the view models based on reflection. In actual implementation, you may use a better resolution method, probably using an Container or so.

Anyway, now you can use the AutoViewModelLocator much like we explained earlier – by creating it as a global resource in App.xaml, and then binding to the same from the View. How ever, please note that in the View, we should bind to the Indexer from Xaml (Please have a look at the source code attached).

Let us test our Locator via a simple ViewModel and a View.

Our Minimal View Model

 //Our minimal view model
 public class MainViewModel
    {

        public string Data
        {
            get
            {
                return "Hello via AutoViewModelLocator";
            }
        }
    }

Binding the View

Note that we are binding the data context of the control to the Indexer of our AutoViewModelLocator. And we have a text box that binds to our above Data property. Here is how that looks like in Visual Studio.

And in Expression Blend 4.0

Happy Coding!!

[+] Download Related Source Code

There are more interesting reads here, make sure you read about

• 4 .NET 4.0 Libraries You *Should* Know Better – MEF, Reactive, Tasks and Dynamic
• Developing for Multicore machines. Tasks in .NET 4.0 – Why/What/How?

A lot of excitement is there in the air, and the focus will be on Cloud computing, VS2010 Features, Robotics, Windows Phone 7, Azure, Application Compatibility, ASP.NET etc. I would be one of the speakers as well. Walk in, uplift yourself, and go back with some great energy.

We’ll also launch Microsot Office 2010 during the event.

Speakers

We’ve got speakers including Janakiram, Vijay (msigeek), Ramaprasanna, Shobhan, Shiju, Sreeju, Praseed, Jene, Manu etc.  Checkout the speakers page in DevCon 2010 website.

Oh yea, I’m also taking a session. I’ll be taking a session on VS 2010 + .NET 4.0 – I’ll talk about New VS2010 Features, and .NET 4.0 Frameworks. A session on Windows Phone 7 is also planned

Agenda

Here is the detailed Agenda.

Day 1 (3rd July – Saturday)

• 08:30AM – 09:15AM – Registration Confirmation
• 09:15AM – 09:30AM – Welcome Speech
• 09:30AM – 10:15AM – Key Note Session – “Cloud – The Meta Platform”
• 10:15AM – 11:00AM – New features in .NET 4.0 & Visual Studio 2010
• 11:00AM – 11:15AM – Tea break
• 11:15AM – 12:15PM – Robotics Programing
• 12:15PM – 01:15PM – Web Security and Security Auditing
• 01:15PM – 02:15PM – Lunch
• 02:15PM – 03:15PM – Windows Azure
• 03:15PM – 04:00PM – Great Developer Contest – Final
• 04:00PM – 05:00PM – Managing Application Compatibility in Windows 7

Day 2 (4th July – Sunday)

• 08:30AM – 09:30AM – Registration Confirmation
• 09:30AM – 10:30AM – Data on the Cloud
• 10:30AM – 11:30AM – Mixed Mode Windows development using C# and C++
• 11:30AM – 11:45AM – Tea Break
• 11:45AM – 12:00PM – Visual Studio 2010 tips
• 12:30PM – 01:30PM – Tuning Tools in SQL Server 2008
• 01:30PM – 02:30PM – Lunch
• 02:30PM – 03:15PM – ASP.NET MVC
• 03:15PM – 04:00PM – Windows 7 Phone
• 04:00PM – 05:00PM – Closing Ceremony

We’ll also perform the Microsoft Office 2010 Launch during the event.

How to Reach

Kerala is known for it’s natural beauty, and is called God’s own land. The event is in Technopark, Trivandrum, Kerala – Technopark is the greenest IT Park in India.

See the Map | See Technopark Website | Campus Photos

Places To See

Don’t miss these places, if you are in Trivandrum. These locations are near by.

• Veli Tourist Village:
• It is about 5kms from the place of DevCon event, and boating facilities are offered at this picnic spot. Speed boats, restaurants and well landscaped gardens are available.
• Kovalam:
• It is a globally renowned beach destination of Trivandrum and is strewn with the coconut groves that make it a tropical paradise
• Padmanabhaswamy Vishnu Temple:
• It is a magnificent temple, which featuring pure Dravidian style of architecture. The temple houses the shrine of the presiding deity of Thiruvananthapuram, Lord Vishnu and was built by the Maharaja of Travancore.
• Napier Museum:
• On your travel to Trivandrum, you will also come across this museum that was built in the 19th century and is an amazing example of the affluent history of Kerala

Visit DevCon2010 website to take part in the cool contests, to book your seat etc. See you guys there!!.

I paid some serious attention to the book over the last couple of weekends, when I was playing around with JQuery a bit to implement some desired user experience. I should say I’m pretty impressed with the book – mainly for it’s practical value, and about the way it is organized.

The whole book has ten sections, with multiple recipes under each section, detailing specific tasks. In short, you’ll be able to quickly find how to implement a specific functionality in JQuery, just by looking at the index.

I feel that the practical value of the book is immense. The examples and explanation are clear and concise – you don’t find any useless crap there. Each recipe has a problem statement (challenge), solution (the actual code),  Explanation of the code, A link to a live demo, a note on Browsers supported,  and a set of useful links on this problem. Great.

For my scenario, I was actually trying for implementing a Google reader like feature using JQuery – to high light multiple rows of the Grid view, so that the user can perform an operation with the high lighted rows. Wow, and I got pleasantly surprised when I saw this.

I think the book, along with the sample code, can really fasten up the development time of web applications. For a developer, with out doubt, this e-book will serve as a travelling compass in the world of ASP.NET and JQuery, and is definitely recommended for anyone who is interested to build great user experiences with JQuery.    

You may read 5 sample chapters of the book here for free. And if you are serious about learning JQuery, don’t waste time, Go and buy it for $14.99 – The book comes with

• 51 Tips, Tricks and Recipes with jQuery and ASP.Controls EBook (PDF)
• Entire Source Code of the EBook
• Cross Browser Scripts – tested on IE 7, IE 8, Firefox 3, Chrome 2, Safari 4
• Common code that runs on ASP.NET Page, Master Pages, and in most cases, HTML pages too.

Again, congratulations to Suprotim for his great effort.

This post explains how to create a View Engine for ASP.NET MVC, leveraging the Text Template (T4) infrastructure already out there for rendering the view based using a custom T4 template host.

Clarification: Here, I’m not using T4 for design time code generation. We are using T4 toolkit to render the views during runtime.

[+] Download Related Source Code

For me, the most beautiful aspect of ASP.NET MVC is it’s extensibility – they way you can ‘stretch’ the framework, to make it suitable for your own needs. I highly recommend you to read this article from Code Climber’s blog – 13 ASP.NET MVC Extensibility Points you have to know

In this post, we’ll explore the following concepts.

• ViewEngines in ASP.NET MVC
• Creating a custom ViewEngine for ASP.NET MVC
• Supporting multiple View Types (our view engine will support both aspx/ascx files and tt files)
• Partial rendering between view types (you can render a tt view from an aspx view)

Preface About View Engines

This is a quick recap on how the View Engine is invoked with in the ASP.NET MVC Framework. Let us start from how a controller is created and how an action is called. I’m going the easy way – the route handling system in ASP.NET MVC invokes a DefaultControllerFactory by default, which is responsible to choose the correct controller class and an action for a given request. For example, consider the URL http://Portal.com/Customer/Get/3 – As you know, by default, MVC will expect a CustomerController class with a Get Action inside the same, like

   public class CustomerController : Controller
    {
        public ActionResult Get(int id)
        {

           //Get the customer with ID from repository, place it in ViewData
            ViewData["Customer"] = rep.GetCustomerWithId(id);

            //View method returns a Viewresult
            return View();
        }
    }

The controller will invoke the correct action method, which returns an ActionResult object. In the above example, you may see that we are returning a ViewResult. In ASP.NET MVC, there are various action results, including ViewResult, ContentResult etc.

Wow, There we are. If the controller action is returning a ViewResult, the action method can use the ViewData structure (see the above example) to fill it with some values, to pass the same to ViewResult. ViewResult can locate and render a particular view template using ViewData. It does so by invoking WebFormViewEngine.

The default View engine available with ASP.NET MVC is WebFormViewEngine, which creates a WebFormView to render your aspx and ascx files. The View Engine normally passes the path information of the file to render, along with the view context information to the view.

The view file name and path is normally detected based on convention – normally in the path – /Views/{ControllerName}/{ActionName} – i.e, If your Controller class name is CustomerController and action/method name is Get, the default view engine will expect a file in the location /Views/Customer/Get.aspx

Using Text Template Toolkit To Render A View

The beauty of ASP.NET MVC is in it’s extensibility. All interaction points above can be customized the way you like. As of now, we are only interested to see how to create a custom View Engine, which can create a T4View that knows how to render a text template (tt) file, leveraging the Text Templating infrastructure.

Normally, as you are aware, Text Templates (T4) are used with in Visual Studio for activities like Code Generation. When I was going through this exercise of explaining how to create a custom view engine for ASP.NET MVC, I thought it’ll be an interesting exercise to leverage T4 toolkit for the task.

But we’ve got a problem there – We can’t use the Microsoft.VisualStudio.TextTemplating libraries, because I don’t believe that T4 can be legally redistributed without Visual Studio. So, I’ve decided to relay on the Mono equivalent T4 implementation, Mono.TextTemplating (included in the download)

Now, let us get in to the actual task. These are the steps we should do to create our view engine.

• A ViewEngine implementation
  • We’ll create a view engine by implementing the IViewEngine interface. There is an abstract class VirtualPathProviderViewEngine that already implements IViewEngine interface and provides some extra functionality for path detection of view files.  VirtualPathProviderViewEngine  has two methods we are concerned about – CreateView and CreatePartialView from where we should return a custom View, that has the path information to the template file (*.tt) to render.
• A View
  • We’ll create a view, by implementing the IView interface. IView has a Render method that we are interested about. We’ll read and render the tt file, leveraging the TT engine
• A T4 Host
  • We’ll also create a custom T4 host, by implementing the ITextTemplatingEngineHost interface, for self hosting the template transformation process.

Once we’ve the above pieces, we need to register our custom view engine with ASP.NET MVC. That’s pretty simple, and we’ll see that soon.

The View Engine Implementation

May be it is time to have a look in to the actual view engine implementation. A slight variation to what we discussed earlier. Instead of creating a ViewEngine from scratch, we are going to inherit our ViewEngine from VirtualPathProviderViewEngine that’s already there in MVC framework – so that all the file path logic will be taken care automatically. VirtualPathProviderViewEngine provides some extra functionality so that we can specify the location formats to look for our view files (in this case, *.tt files), when ever the View Engine is invoked.

Alright. Let us be a bit more creative here. What about creating a View Engine that can handle the aspx and ascx files *along with* the text template files? Creating such a composite view engine is pretty simple – So, this is what our view engine should do.

• First, the view engine should look for a View file that ends with *.view.tt
  • If that file exists, create and return a T4View that’ll render our tt file
  • If not, look for a View file that ends with *.ascx or *.aspx
    • If exists, create and return a WebFormView that knows how to render the aspx/ascx files.

Enough blabbering. Here we go, the code of our CompositeViewEngine. All the implementations are in MvcT4ViewEngine.Lib project, so you may download the related source code from the above link to have a look at the same side by side.

    /// <summary>
    /// A composite view engine to help plugging view engines
    /// </summary>
    public class CompositeViewEngine : VirtualPathProviderViewEngine
    {
        // Ctor - Let us set all location formats
        public CompositeViewEngine()
        {
            base.MasterLocationFormats = new string[] { "~/Views/{1}/{0}.master",
                                                        "~/Views/Shared/{0}.master" };
            base.AreaMasterLocationFormats = new string[] { "~/Areas/{2}/Views/{1}/{0}.master",
                                                         "~/Areas/{2}/Views/Shared/{0}.master" };
            base.ViewLocationFormats = new string[] { "~/Views/{1}/{0}.view.tt",
                                                      "~/Views/{1}/{0}.aspx", "~/Views/{1}/{0}.ascx",
                                                      "~/Views/Shared/{0}.view.tt",
                                                      "~/Views/Shared/{0}.aspx", "~/Views/Shared/{0}.ascx" };
            base.AreaViewLocationFormats = new string[] { "~/Areas/{2}/Views/{1}/{0}.view.tt",
                                                       "~/Areas/{2}/Views/{1}/{0}.aspx", "~/Areas/{2}/Views/{1}/{0}.ascx",
                                                       "~/Areas/{2}/Views/Shared/{0}.view.tt",
                                                       "~/Areas/{2}/Views/Shared/{0}.aspx", "~/Areas/{2}/Views/Shared/{0}.ascx" };
            base.PartialViewLocationFormats = base.ViewLocationFormats;
            base.AreaPartialViewLocationFormats = base.AreaViewLocationFormats;
        }

        /// <summary>
        /// Handle the creation of a partial view
        /// </summary>
        protected override IView CreatePartialView
                 (ControllerContext controllerContext, string partialPath)
        {
            if (partialPath.EndsWith(".view.tt"))
                return new T4View(partialPath);
            else
                return new WebFormView(partialPath, null);
        }

        /// <summary>
        /// Handle the creation of a view
        /// </summary>
        protected override IView CreateView
               (ControllerContext controllerContext, string viewPath, string masterPath)
        {
            if (viewPath.EndsWith(".view.tt") && String.IsNullOrEmpty(masterPath))
            {
                return new T4View(viewPath);
            }
            else if (viewPath.EndsWith(".view.tt") && !String.IsNullOrEmpty(masterPath))
            {
                return new T4View(viewPath,masterPath);
            }
            else
                return new WebFormView(viewPath, masterPath);
        }

        /// <summary>
        /// Check if the file exists
        /// </summary>
        protected override bool FileExists
                (ControllerContext controllerContext, string virtualPath)
        {
            return base.FileExists(controllerContext, virtualPath);
        }

    }

That looks pretty simple, right? Have a look at the constructor, and you’ll find that we are specifying the path format constraints to detect our T4 view files as well (*.view.tt), along with the aspx and ascx path formats. And you may also find that in the CreateView and CreatePartialView, we are creating and returning a WebFormView, in case the *.vew.tt files are not found. CreatePartialView will be invoked when a partial rendering is requested – e.g. when the user calls a RenderPartial method in a view.

Now, the interesting aspect there is, you can render a text template view from an aspx view, using the Ht

The View Implementation

The T4View implementation is also very simple. We are just invoking our T4 host, to render the tt files. Have a look at the Render method below. You may also note that we are passing the ViewContext to the host, so that we can access the view context later in our text template files, via the host variable.

     /// <summary>
    /// A view based on T4
    /// </summary>
    public class T4View : IView
    {

        #region IView Members

        private string viewName = string.Empty;
        private string masterName = string.Empty;

        public T4View(string ttViewName)
        {
            viewName = ttViewName;
        }
        public T4View(string ttViewName, string masterttName)
        {
            viewName = ttViewName;
            masterName = masterttName;
        }

        /// <summary>
        /// Render our tt file
        /// </summary>
        /// <param name="viewContext"></param>
        /// <param name="writer"></param>
        public void Render(ViewContext viewContext, System.IO.TextWriter writer)
        {
            string filePath = viewContext.HttpContext.Server.MapPath(viewName);
            string masterPath=string.Empty;

            if (!string.IsNullOrEmpty(masterName))
            {
                masterPath=viewContext.HttpContext.Server.MapPath(masterName);
            }

            var thost = new T4TemplateHost();
            thost["ViewContext"] = viewContext;

            string data = string.Empty;
            var results = thost.ProcessTemplate(filePath, masterPath, out data);
            if (results.HasErrors)
            {
                writer.WriteLine("<h1>errors found</h1>");
            }
            foreach (var res in results)
            {
                writer.WriteLine("Error - " + (res as CompilerError).ToString());
            }
            writer.Write(data);

        }

        #endregion
    }

About the Template Host

You may see that in the Render method, we are creating an instance of our T4 template host, and requesting the template host to process our our *.view.tt file. You may read more about creating a custom template host here, though I’m not detailing that much. How ever, if you are so curios, here is the ProcessTemplate method in our custom T4 host.

        /// <summary>
        /// Process the input template
        /// </summary>
        /// <returns></returns>
        public CompilerErrorCollection ProcessTemplate
		          (string templateFileName, string masterFileName, out string data)
        {

            if (!File.Exists(templateFileName))
            {
                throw new FileNotFoundException("The file cannot be found");
            }

            var engine = new TemplatingEngine();
            TemplateFile = templateFileName;

            //Read the text template.
            string input = File.ReadAllText(templateFileName);

            if (!string.IsNullOrEmpty(masterFileName))
            {
                input = File.ReadAllText(masterFileName).Replace("<!--[Content]-->",input);
            }

            //Transform the text template.
            data = engine.ProcessTemplate(input, this);
            return Errors;
        }

Registering our View Engine

The last piece of the puzzle would be to register our custom View Engine, so that the framework will use our View Engine instead of the default one. Let us create a new ASP.NET MVC Project. Now in the Global.asax.cs file of our MVC application (See MvcT4ViewEngine.Demo project in the downloaded source code), we need to specify our CompositeViewEngine as the default view engine, in the Application_Start.

    protected void Application_Start()
        {
            ViewEngines.Engines.Clear();
            ViewEngines.Engines.Add(new CompositeViewEngine());
            RegisterRoutes(RouteTable.Routes);
        }

And there we go.

The Results

First of all, let us add a new GetMessage method to the HomeController ASP.NET MVC project. Our GetMessage action in the Home controller simply returns a view after storing someting in ViewData, like

   public ActionResult GetMessage()
        {
            ViewData["MessageForT4"] = "Welcome to ASP.NET MVC Views using T4";
            return View();
        }

Now, add a new view, named GetMessage.view.tt in the Views/Home  folder as shown below. And you can access the ViewData like this.

Now, run the application, and navigate to the path /Home/GetMessage and you should be able to see the above view getting rendered. If you are wondering what the GetViewData method does, it fetches the ViewData context we set to the host earlier, in the above Render method.

More interestingly, you may also try partially rendering a T4 view from an aspx file. You can use Html.RenderPartial(“YourView”); from your aspx view, to render the YourView.view.tt file – See how I’m rendering IndexPart.view.tt from the Index.aspx view, in the attached example.

Conclusion

The intent of this article is just to explore how to create custom view engines for ASP.NET MVC. The example view engine we put together is very elementary as of now, but I’ld like to evolve that towards something useful, so that finally it can be a part of MvcContrib. For this, several performance features like caching of compiled views needs to be implemented. That is for later.

Recommending you to follow me on twitter – Also, read my previous posts – A duck typed view model in ASP.NET MVC or Understanding Managed Extensibility Framework and Lazy<T> – Happy Coding!!

The objective of this post is to brief how you can leverage the lazy initialization support available in MEF. We’ll examine MEF and Lazy, and then we’ll see how to use them together.

[+] Download final version of source code

Preface About MEF

I hope you are already using Managed Extensibility Framework to build beautiful software. If you are not yet there, that is a crime, and I highly recommend you to read my introductory post on MEF. Let us start with another very basic MEF example. Let us get back our Zoo.

We are composing our Zoo with a couple of Animals here.

    //Abstract animal interface
    interface IAnimal { void Eat(); }

    //Concrete animal 1
    [Export(typeof(IAnimal))]
    class Lion : IAnimal
    {
        public Lion() { Console.WriteLine("Grr.. Lion got created"); }
        public void Eat() { Console.WriteLine("Grr.. Lion eating meat"); }
    }

    //Concrete animal 2
    [Export(typeof(IAnimal))]
    class Rabbit : IAnimal
    {
        public Rabbit() { Console.WriteLine("Crrr.. Rabbit got created"); }
        public void Eat() { Console.WriteLine("Crrr.. Rabbit eating carrot"); }
    }

    //Our Zoo. MEF will inject animals to this zoo later, at the time of composition
    class Zoo
    {
        [ImportMany(typeof(IAnimal))]
        public IEnumerable<IAnimal> Animals { get; set; }
    }

    //Let us construct our zoo and animals
    class Program
    {
        static void Main(string[] args)
        {
            //Let us create a catalog and a container
            var catalog = new AssemblyCatalog(typeof(Program).Assembly);
            var container = new CompositionContainer(catalog);

            //Compose the zoo.
            var zoo = new Zoo();
            container.ComposeParts(zoo);

            //Let's feed our animals
            foreach (var animal in zoo.Animals)
                animal.Eat();

        }
    }

As you remember, a catalog is a sack full of types (cookies) to export. The container will fetch these exported types from the catalog, to instantiate and import them where ever applicable – based on the matching contracts specified in the Export and Import attributes. (Note to self – Shh!! don’t mention anything about ExportProvider and ExportDefinition now). In this case, we are using a type as the contract (IAnimal) for our Export and Import. And if you run that app, you’ll see.. hm.. a cute black screen. More importantly, you’ll see that MEF has created an instance of Lion and Rabbit at the time of composition – i.e, when we call container.ComposeParts. See the messages we are writing from the constructor.

Note – If you want to be more realistic or if you hate animals in general, my advice is to think about your Business class instead of the Zoo, and think about some validation rules instead of those Animals. So that, you can plug in new validation rules with out affecting your entire system.

Preface About Lazy<T>

Oh yea, though MEF is seductive, let us stop thinking about that for a moment. Let us be a bit Lazy. You might have already heard about the Lazy<T> class in .NET 4.0. Lazy class allow you to support for lazy initialization. I.e, you can use Lazy<T> to defer the creation of a large or resource-intensive object, till you really need that.

Here is a quick example.

            //Let us be lazy about creating a lion
            Lazy<Lion> lazyLion = new Lazy<Lion>();

            //Do something else..

            //Actual object will be created here
            var lion = lazyLion.Value;
   

The interesting point to note is, you can defer the creation of your lion, till you really need it in your flow, probably inside an if block or so. Another interesting aspect of Lazy<T> is, you can specify your own factory method to create your object, via the Lazy<T> constructor. See this example.

            //Let us be lazy about creating our animal
            Lazy<IAnimal> lazyAnimal = new Lazy<IAnimal>(()=>new Lion());

            //Actual object will be created here
            var animal = lazyAnimal.Value;

Being Lazy with MEF

Now, let us see how to combine MEF and Lazy together. All right, you don’t really need to do anything special there – MEF already has some great support for Lazy. MEF can wire up your exports directly to a Lazy at the time of import. Now, let us see how to do that. We just need to make two modifications to our zoo example. Time for a KG Excercise – Spot the difference of this code example with the very first example.

 //Our zoo
    class Zoo
    {
        //** MODIFICATION 1 -You need to directly import to Lazy<IAnimal>
        [ImportMany(typeof(IAnimal))]
        public IEnumerable<Lazy<IAnimal>> Animals { get; set; }
    }

    //Abstract animal interface
    interface IAnimal { void Eat(); }

    //Concrete animal 1
    [Export(typeof(IAnimal))]
    class Lion : IAnimal
    {
        public Lion() { Console.WriteLine("Grr.. Lion got created"); }
        public void Eat() { Console.WriteLine("Grr.. Lion eating meat"); }
    }

    //Concrete animal 2
    [Export(typeof(IAnimal))]
    class Rabbit : IAnimal
    {
        public Rabbit() { Console.WriteLine("Crrr.. Rabbit got created"); }
        public void Eat() { Console.WriteLine("Crrr.. Rabbit eating carrot"); }
    }

    //Let us construct our zoo and animals
    class Program
    {
        static void Main(string[] args)
        {
            //Let us create a catalog and a container
            var catalog = new AssemblyCatalog(typeof(Program).Assembly);
            var container = new CompositionContainer(catalog);

            //Compose the zoo.
            var zoo = new Zoo();
            container.ComposeParts(zoo);

            //** MODIFICATION 2 - An instance will be created only when you access it
            //Use the Value property of the Lazy object to initialize and access the actual value
            foreach (var animal in zoo.Animals)
                animal.Value.Eat();
        }
    }

And now, to understand how this changed the flow, let us run the application.

You’ll see that our animals are getting created only when we consume them – and not at the time of composing the zoo as we did earlier. 

Dealing with Metadata when MEF goes Lazy

MEF allows you to export Metadata along with the types you export. For example, assume that you want to specify whether your exported animals eat meat or not, so that some one can decide what to give them as food. One way is to use the ExportMetaData attribute with your exported types, as shown below.

   //Concrete animal 1
    [Export(typeof(IAnimal))]
    [ExportMetadata("EatMeat",true)]
    class Lion : IAnimal
    {
        public Lion() { Console.WriteLine("Grr.. Lion got created"); }
        public void Eat() { Console.WriteLine("Grr.. Lion eating meat"); }
    }

    //Concrete animal 2
    [Export(typeof(IAnimal))]
    [ExportMetadata("EatMeat", false)]
    class Rabbit : IAnimal
    {
        public Rabbit() { Console.WriteLine("Crrr.. Rabbit got created"); }
        public void Eat() { Console.WriteLine("Crrr.. Rabbit eating carrot"); }
    }

That looks a bit clumsy, because of those strings. Right? A better way is to create your own custom Export attribute that includes the metadata information as well. That is pretty simple. The code below is equivalent to what we have just done above. You see that we are creating a custom export attribute named ExportAnimal.

       //Our custom metadata attribute to exp animals
    [MetadataAttribute]
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    class ExportAnimal : ExportAttribute
    {
        //Pass the contract type to the base
        public ExportAnimal() : base(typeof(IAnimal)) { }
        //Additional metadata info
        public bool EatMeat { get; set; }
    }

    //Concrete animal 1
    [ExportAnimal(EatMeat=true)]
    class Lion : IAnimal
    {
        public Lion() { Console.WriteLine("Grr.. Lion got created"); }
        public void Eat() { Console.WriteLine("Grr.. Lion eating meat"); }
    }

    //Concrete animal 2
    [ExportAnimal(EatMeat = false)]
    class Rabbit : IAnimal
    {
        public Rabbit() { Console.WriteLine("Crrr.. Rabbit got created"); }
        public void Eat() { Console.WriteLine("Crrr.. Rabbit eating carrot"); }
    }

Now let us come to the real question. How to import the metadata information in a Lazy way? Fortunately, MEF has an overload of Lazy, Lazy that supports importing Metadata information. So, all we need to do is create a metadata import interface that matches our export definition, and use it. Like this.

   //An interface to import animal metadata
   //This should match the metadata we've in our custom export definition
    public interface IAnimalMetadata
    {
        bool EatMeat { get; }
    }

    //Our zoo
    class Zoo
    {
        //Directly import to Lazy<IAnimal,IAnimalMetadata>
        [ImportMany(typeof(IAnimal))]
        public IEnumerable<Lazy<IAnimal, IAnimalMetadata>> Animals { get; set; }
    }

So, here is the final piece that includes the above fragments. You can see that we are exporting our animals using a custom export attribute, and importing them in a lazy way along with the metadata. Then, Have a look at the Main method. You’ll find that we are using the metadata to feed only the animals that eat meat.

In other words, the Lazy implementation provides you the luxury of initializing only the animals that you want to feed, at the time of feeding them – and not all the animals.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.Primitives;

namespace MefLazy
{

    #region Contracts

    //Abstract animal interface
    interface IAnimal { void Eat(); }

    #endregion

    #region Export Related

    //Our custom metadata attribute to exp animals
    [MetadataAttribute]
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    class ExportAnimal : ExportAttribute
    {
        //Pass the contract type to the base
        public ExportAnimal() : base(typeof(IAnimal)) { }
        //Additional metadata info
        public bool EatMeat { get; set; }
    }

    //Concrete animal 1
    [ExportAnimal(EatMeat = true)]
    class Lion : IAnimal
    {
        public Lion() { Console.WriteLine("Grr.. Lion got created"); }
        public void Eat() { Console.WriteLine("Grr.. Lion eating meat"); }
    }

    //Concrete animal 2
    [ExportAnimal(EatMeat = false)]
    class Rabbit : IAnimal
    {
        public Rabbit() { Console.WriteLine("Crrr.. Rabbit got created"); }
        public void Eat() { Console.WriteLine("Crrr.. Rabbit eating carrot"); }
    }

    #endregion

    #region Import Related

    //An interface to import animal metadata
    public interface IAnimalMetadata
    {
        bool EatMeat { get; }
    }

    //Our zoo
    class Zoo
    {
        //Directly import to Lazy<IAnimal,IAnimalMetadata>
        [ImportMany(typeof(IAnimal))]
        public IEnumerable<Lazy<IAnimal, IAnimalMetadata>> Animals { get; set; }
    }

    #endregion

    #region Main

    //Let us construct our zoo and animals
    class Program
    {
        static void Main(string[] args)
        {
            //Let us create a catalog and a container
            var catalog = new AssemblyCatalog(typeof(Program).Assembly);
            var container = new CompositionContainer(catalog);

            //Compose the zoo.
            var zoo = new Zoo();
            container.ComposeParts(zoo);

            //An instance will be created only when you access it
            //Use the Value property of the Lazy object to initialize and access the actual value
            //Let us feed only animals eating meat
            foreach (var animal in zoo.Animals)
                if (animal.Metadata.EatMeat)
                    animal.Value.Eat();
        }
    }

    #endregion
}

Conclusion

I encourage you to apply these concepts to more practical scenarios. Like, instead of a Zoo, think about a RuleProcessor that runs a set of rules on a business object – and instead of an Animal, think about a Rule that can validate or process the business object. I’ll give some more practical examples pretty soon . For now, the objective was to introduce Lazy concepts and MEF, and I hope you enjoyed the read. And you can download the final version of the code from the above link. Keep in touch, Follow me on twitter

Also, read my last post 4 .NET 4.0 Libraries You should know about

Happy Coding!!

MEF or Managed Extensibility Framework – System.ComponentModel.Composition

MEF or Managed Extensibility Framework is cool. Firstly, it allows you to decouple your components pretty easily. Secondly, it supports various component discovery scenarios, and enables you to write better frameworks.

• An Introduction to MEF- Creating a Zoo And Animals
• MEF or Managed Extensibility Framework and Lazy<T> – Being Lazy with MEF, Export Attributes etc

Reactive Extensions and LINQ To Events – System.Reactive

Reactive Extensions will soon become the de-facto for writing asynchronous code in a declarative manner .NET Rx gives greater freedom to compose new events – you can create specific events out of general events

• What is LINQ To Events
• Concepts And First Look
• Linq To Events – A WPF Drawing Demo
• A Text Template for generating GetEventName wrapper

Parallel Extensions and Tasks – System.Threading.Tasks

With those multi core processors everywhere, support for parallelism is an already implicit requirement for any new application. NET 4.0 framework provides a wealth of easy to use primitives and abstractions to enable developers to quickly write parallel programs, targeting multi core machines.

• An Introduction to Tasks in Parallel Extensions

Dynamic Extensions – System.Dynamic

C# 4.0 introduced dynamic capabilities (duck typing) capabilities. There are a number of scenarios where the dynamic features can really simplify things for you. For example, let us assume a Reflection based scenario where you load a type (from an external assembly or so) to invoke a member, or think about a dynamic fluent wrapper on top of XML or JSON.

• An introduction to C# 4.0 dynamic keyword
• Understanding ExpandoObject in .NET 4.0
• A Dynamic Wrapper in .NET 4.0

Here is a simple extension method to dump the control template of a WPF control.

 public static class ControlTemplateExtension
    {
         public static string DumpControlTemplate(this Control ctrl)
        {
            XmlWriterSettings settings = new XmlWriterSettings()
            {
                Indent = true,
                NewLineOnAttributes = true
            };

            StringBuilder strbuild = new StringBuilder();
            XmlWriter xmlwrite = XmlWriter.Create(strbuild, settings);
            XamlWriter.Save(ctrl.Template, xmlwrite);
            return strbuild.ToString();
        }
	}

And now you can go ahead and dump your control templates, like this.

   //use your control name instead of mybutton
   var strXaml = this.myButton.DumpControlTemplate();
   //Do something with your control template
   Debug.WriteLine(strXaml);

Frankly, intrusion in to the private space of others is not so great. Mostly, you’ll get a kick in your ass, but at times, if you are lucky and if you are really smart, you’ll end up finding something really cool (Bond, James Bond).

For me, at times, when doing some hacks/exploration of compiled or third party assemblies, I end up wanting to initialize a private class or a class with a private or internal constructor. Or, at times, when dealing with pre-compiled legacy libraries that I can’t change – I want to write a couple of tests against a private method to understand how it works.  I remember going through the source code of TFS power toys or so some time back – and I found that those guys are bringing up a lot of goodness by unearthing some private classes in the TFS library.

Still, I should warn you.

Warning (assume that this is in red): Private types, internals and private members are so because of some reason, and often you don’t want to mess with them directly. And if you do, chances are that you’ll break later, because there is no guarantee that the guys who created those assemblies will keep the private/internal implementations as such.

If you still don’t mind breaking the rules so that you can un earth some hidden potential against all the danger warnings – here is a quick wrapper class that’ll make the job easy using C# 4.0 dynamic features and reflection.  And more than that, this is a good learning point to see how you can use reflection to initialize private types, invoke private/internal constructors, get/set private properties, invoke private methods etc.

1 – What we are talking about

To explain further what we’ll achieve, consider this simple example.

class Program
    {
        static void Main(string[] args)
        {
            //Note that the type of 'wrapper' is dynamic
            dynamic wrapper =  new AccessPrivateWrapper(new ClassWithPrivateMembers()) ;

            //Let us access the private members
            wrapper.somePrivateField = "Field Val";
            wrapper.SomePrivateProperty = "Property Val";
            wrapper.DumpValues();

            Console.ReadLine();
        }

        class ClassWithPrivateMembers
        {
            private string somePrivateField;
            private string SomePrivateProperty { get; set; }

            private void DumpValues()
            {
                Console.WriteLine("Look ma, I'm accessing private members. Prop = "
                    + SomePrivateProperty + ", Fld=" + somePrivateField);
            }

        }
    }

And if you run that, you’ll find that the dynamic wrapper is correctly setting the the private field and property values, and then  invoking a private method in the class (DumpValues method), to print the result.

No, we are not yet happy. What about accessing private members in private classes in other assemblies? All right, you can use the FromType method of AccessPrivateWrapper to initialize a private/internal class in a different assembly – and you can initilize the class, even if it’s constructor is internal or private. Assume that you have a class named ‘ClassWithPrivateConstructor’ in an assembly, and it is having a private constructor. And you want to create an instance of that, and to invoke some private members inside. This is what you can do.

            //Note that the wrapper is dynamic
            dynamic wrapper = AccessPrivateWrapper.FromType
                (typeof(SomeKnownClass).Assembly,"ClassWithPrivateConstructor");

            //Access the private members
            wrapper.PrivateMethodInPrivateClass();

2 – What the heck is AccessPrivateWrapper

If you are wondering what exactly is AccessPrivateWrapper – it is a simple class we inherited from the System.Dynamic.DynamicObject class.

But before that If the keyword ‘dynamic’s not not familiar to you, I really suggest you to read this article I wrote earlier – C# 4.0 dynamic keyword – Under the hood

Coming back to DynamicObject – In dynamic languages like Ruby, there is an interesting feature called method_missing. Method missing is where your method request will end if the method you called cannot be found.

In .NET 4.0, now you can bring in the same feature, by inheriting your object from the DynamicObject class. What this means is, you’ll get notified when a method/property is invoked/accessed on your object. The DynamicObject class has a few cool methods for you to override. For now, we are only interested in these members:

• TryInvokeMember – Provides the implementation of calling a member.
• TrySetMember – Provides the implementation of setting a member.
• TryGetMember – Provides the implementation of getting a member.

So, we are inheriting our AccessPrivateWrapper from the DynamicObject class, and overriding these methods to access private and public methods, properties and fields via reflection (I hope you know the fact that via reflection, you can invoke, set and get the values of even private and internal members).

Have a look at the implementation of AccessPrivateWrapper

/// <summary>
    /// A 10 minute wrapper to access private members, havn't tested in detail.
    /// Use under your own risk - amazedsaint@gmail.com
    /// </summary>
    public class AccessPrivateWrapper : DynamicObject
    {

        /// <summary>
        /// The object we are going to wrap
        /// </summary>
        object _wrapped;

        /// <summary>
        /// Specify the flags for accessing members
        /// </summary>
        static BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance
            | BindingFlags.Static | BindingFlags.Public;

        /// <summary>
        /// Create a simple private wrapper
        /// </summary>
        public AccessPrivateWrapper(object o)
        {
            _wrapped = o;
        }

        /// <summary>
        /// Create an instance via the constructor matching the args
        /// </summary>
        public static dynamic FromType(Assembly asm,string type,params object[] args)
        {

            var allt = asm.GetTypes();
            var t=allt.First(item=>item.Name==type);

            var types=from a in args
                      select a.GetType();

            //Gets the constructor matching the specified set of args
            var ctor = t.GetConstructor(flags, null, types.ToArray(), null);

            if (ctor != null)
            {
                var instance = ctor.Invoke(args);
                return new AccessPrivateWrapper(instance);
            }

            return null;
        }

        /// <summary>
        /// Try invoking a method
        /// </summary>
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            var types=from a in args
                      select a.GetType();

            var method = _wrapped.GetType().GetMethod
                (binder.Name,flags, null, types.ToArray(), null);

            if (method == null)
                return base.TryInvokeMember(binder, args, out result);
            else
            {
                result=method.Invoke(_wrapped, args);
                return true;
            }
        }

        /// <summary>
        /// Tries to get a property or field with the given name
        /// </summary>
        public override bool TryGetMember(System.Dynamic.GetMemberBinder binder, out object result)
        {
            //Try getting a property of that name
            var prop = _wrapped.GetType().GetProperty(binder.Name,flags);

            if (prop == null)
            {
                //Try getting a field of that name
                var fld = _wrapped.GetType().GetField(binder.Name, flags);
                if (fld != null)
                {
                    result = fld.GetValue(_wrapped);
                    return true;
                }
                else
                    return base.TryGetMember(binder, out result);
            }
            else
            {
                result = prop.GetValue(_wrapped, null);
                return true;
            }
        }

        /// <summary>
        /// Tries to set a property or field with the given name
        /// </summary>
        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            var prop = _wrapped.GetType().GetProperty(binder.Name, flags);
            if (prop == null)
            {
                var fld = _wrapped.GetType().GetField(binder.Name, flags);
                if (fld != null)
                {
                    fld.SetValue(_wrapped,value);
                    return true;
                }
                else
                    return base.TrySetMember(binder, value);
            }
            else
            {
                prop.SetValue(_wrapped, value, null);
                return true;
            }
        }

    }

That looks simple, isn’t it? To detail that a bit, when ever user sets or gets a property or field on our dynamic object, the TrySetMember or TryGetMember will get called – and from there onwards, we use reflection to do the job of setting or getting the property or field value, regardless whether it is private or public. If a property of the given name doesn’t exist we’ll try to find a field of the given name to do the get or set operation.

Similarly, TryInvokeMethod will get fired when the user tries to invoke a method via our dynamic wrapper. We fetch the method matching the type of arguments, to obtain the correct overload, and then do the job via reflection. Make sure you download the code from the above link, and debug through a bit.

Also, pay some special attention to the FromType method that we used earlier. Basically, it’ll find the type to create an instance of, and then will find the constructor to invoke, based on the given arguments.

More Thoughts

Now, what about Unit testing your private members? Ever wanted to do that? That is not a common scenario, but at times, as I mentioned earlier, you might be dealing with a legacy system and you want to write a couple of tests against some of the private methods. Oh yes, you can use the AccessPrivateWrapper to do that.

Note that the above implementation don’t work with libraries that are obfuscated, because we are relying on reflection.

Also, the above implementation won’t access inherited private or internal members. That is pretty simple to implement, but that is an exercise for you

Conclusion

A related tip: You can use InternalsVisibleTo attribute to grant access to the internal members of the target assembly to your caller assembly, if you’ve access to both the assemblies. This is useful, especially when you do unit testing.

Also, check out my other C# 4.0 dynamic tricks

• ExpandoObject in C# 4.0 – Inside look
• Introducing ElasticObject in C# 4.0

Happy Coding!!

• Silverlight Nerd Dinner Client Offline Installer
• Files Required To Create the Installer (NSIS Script, XAP File etc)
• NSIS Installer to compile the above Script

What?

Recently a friend asked me to help him create an ‘installer’ to pack and distribute the Silverlight game he recently developed. He wanted to distribute his game via software download websites (like download.cnet.com), and via medias like CD/DVD.

In fact, that is pretty easy (technically) – and this post is about creating and deploying Silverlight Runtime + Your Silverlight application (Xap file) using your very own custom, standalone, offline installer with out getting a browser installed – instead of the user installing your Silverlight application Out Of Browser via the web browser.

Alright. In this post, we’ll see how to build a standalone installer for Silverlight Nerd Dinner Client that I built some time earlier (It is a Silverlight client for Scott’s Nerddinner.com to enable nerds to ‘eat in packs’). The installer will start with a Splash screen as well . 

About License related issues, see the Appendix towards the end of this post. Also, the scenario I’m discussing is limited to creating installers for Windows machines alone .

Why?

I can already hear you thinking, “why this is required”? Think about this – You created a Nice game or a Cool gadget in Silverlight. Now you want to create a standalone Installer – so that you can push the same to your potential users via various means. Like, users may download your installer via CNET like software websites – or you may distribute your installer via CD/DVD media etc. In this way, you can push your Silverlight apps to the masses- instead of waiting for them to come to your website and discover it – You got it, that is what we are talking about .

So, in short, I think Silverlight can be used a platform of choice for building light weight desktop applications, mainly applications like utility tools, light weight games etc.

I feel there are a good number of use cases where you want to do this.

• You can write and deploy tiny apps and gadgets – with out worrying about the presence of/version of the .NET runtime in user’s machine.
• You can maintain the same code base for your web and desktop versions if the scenario suits.
• You can contribute towards increasing the number of boxes where Silverlight exists . More people with Silverlight = a brighter web

And yes, if you are doubtful about what you can really do from a Silverlight application that is running in an elevated trust, out of browser mode, check out this epic post from Justin Angel where he demonstrates how to do all whacky things with Silverlight + COM, including accessing Win 7 APIs, Accessing Scanners and printers, Adding your OOB application to windows startup etc. He rocks.

How?

So, let us see this in detail – how to create a stand alone installer to install Silverlight Runtime + Your Silverlight Application (i.e, the Xap file). These steps detail how I created my installer for Silverlight Nerd Dinner client.

1 – Preparing the required files

For this example, I’m going to use Nullsoft NSIS Installer to roll down the custom installer. NSIS is a simple windows installer from the WinAmp guys, and you can find ton of information here on that. You can write a custom NSIS script, and make a standalone installer executable out of that.

If you download the example package, you’ll find

• The NSIS script to create the installer from.
• The Silverlight runtime installer (Silverlight.exe) – You should ensure you have the latest from here.
• Copy of your Silverlight Xap (that you are going to install in the user’s machine).
• A license.txt file and splash.bmp file to show during the time of installation.

Download and Extract the Required Files zip – and have a look at the files I have. I’ve a Nerddinner.nsi script (we’ll soon see what is inside that), the Silverlight.exe runtime installer, SilverlightNerdDinner.xap, a license file and a Splash screen for the installer.

2 – What the installer should do

Basically, we need our installer to

• Copy Silverlight.exe to the user’s machine and execute that in Silent mode to install the Silverlight runtime.
• Use Sllanucher.exe to install our Xap in out of the browser mode (Sllauncher.exe will be installed by the above Silverlight runtime installer) – Tim already has a nice post on using sllauncher.exe – I’ll also touch that a bit.

The Silverlight deployment guide is a handy read regarding the supported command line arguments for Silverlight.exe and Sllauncher.exe, but here is the summary.

You can install the Silverlight runtime in quiet mode, using the following arguments. 

Silverlight.exe /q /doNotRequireDRMPrompt

The ‘/q’ switch will install the runtime in silent mode. Here is some excerpt from the Silverlight deployment manual version 4.0

• /q = quiet install or upgrade. This installs or upgrades Silverlight without seeing the GUI. When Silverlight is installed quietly, by default privacy related features such as DRM protected media playback and the Silverlight auto-update feature will be configured to prompt the user for permission on 1st use of the respective features. The Silverlight auto-update feature requires administrative rights so non-admin users will not be prompted.
• /doNotRequireDRMPrompt = turns off the 1st use prompt allowing content protected by Digital Rights Management (DRM) to play without requiring any end-user intervention. When Silverlight is installed quietly, DRM Playback is set to prompt on 1st use by default.
• /ignorewarnings = non-fatal warnings will not be reflected in the quiet installer return code but will instead return zero indicating success.
• /noupdate = disables the Silverlight internal auto-updater.
• /qu = quiet uninstall. This uninstalls Silverlight without seeing the GUI.

The Silverlight runtime installer will install sllauncher.exe to the {PROGRAMFILES}\Microsoft Silverlight\sllauncher.exe path. So, after installing Silverlight runtime, we may use sllauncher.exe to ‘install’ our xap in Out of Browser mode, and to create the required short cuts

sllauncher.exe
           /install:"{LocalPathToXapFile}\Yourfile.xap"
           /origin:"{urltoxapfile}/Yourfile.xap"
           /shortcut:desktop+startmenu

You can see that Sllauncher.exe will accept the local path to the xap file, the url to the xap file and the shortcut options. Here is some excerpt from the Silverlight deployment manual about using sllauncher.exe to install XAP.

Installation

• /install:"xapFile" – where xapFile is the file name/file path to the .xap file., E.g. /install:"c:\temp\sample.xap"
• /origin:"xapURI" – where xapURI is the URI where the .xap file would’ve come from if not installed at the commandline
  • e.g. /origin:"http://example.com/sample.xap" .  This URI will be used as the site of origin for security purposes. For example, for sandboxed applications, Silverlight networking requires a policy file check when making network requests to domains other than the site of origin.  The origin also serves as a unique ID for the application.  The xapURI must be an absolute URI not a relative URI, and must start with http:, https:, or file:.
• /overwrite — (optional) Overwrites any previously installed .xap with that xapURI.

Un installation

• /uninstall  – Uninstalls the application specified in /origin. This is the same /origin value that was used to install the app originally.
• /origin:"xapURI" – same as /origin for the install case

3 – The NSIS Script

So, now let us write a quick NSIS script to create an installer that performs these operations. Our script will look like this

Name "Nerd Dinner Desktop Installer"
OutFile "NerdDinnerDesktopInstaller.exe"
InstallDir "$PROGRAMFILES\NerdDinnerDesktop"

XPStyle on

Function .onInit
	# the plugins dir is automatically deleted when the installer exits
	InitPluginsDir
	File /oname=$PLUGINSDIR\splash.bmp "splash.bmp"
	splash::show 1000 $PLUGINSDIR\splash
	Pop $0
FunctionEnd

Section
    SetOutPath "$INSTDIR"
    SetOverwrite ifnewer
    File "Silverlight.exe"
    ExecWait "$INSTDIR\Silverlight.exe /q /doNotRequireDRMPrompt"
    File "SilverlightNerdDinner.xap"
    ExecWait '"$PROGRAMFILES\Microsoft Silverlight\sllauncher.exe" /install:"$INSTDIR\SilverlightNerdDinner.xap" /origin:"http://amazedsaint.net/nerddinner/clientbin/silverlightnerddinner2.xap" /shortcut:desktop+startmenu'
SectionEnd

Basically, the installer will

1. Show a splash screen during initialization of the installer
2. Copy Silverlight.exe to the target folder, and execute it in quite mode
3. Copy our xap file to the target folder, and use sllauncher.exe to install the xap

4 – Creating the Installer

Once you have NSIS installed, you can simply right click on an NSIS file to ‘Compile’ it create an installer.

You should see the MakeNSISW prompt, with a message that the installer is created. Our final installer (that contains Silverlight.exe runtime + XAP + Splash Screen image) is almost ~7 MB, and now you can distribute this the way you need, provided you have the permission from Microsoft to re-distribute Silverlight runtime.

The above installer will install your Silverlight application and will create the desktop and start menu short cuts. Try the installer from here, and you’ll see that it’ll get installed even in a machine with no Silverlight runtime already present.

When you create the installer from your own XAP file, make sure you have enabled Running your Silverlight Application out of browser. Also, always make sure you’ve the latest version of Silverlight runtime installer, Silverlight.exe (Normally what ever you get from this link )

Appendix – Licensing Issues

I asked Tim and Scott whether I can redistribute Silverlight runtime as part of my own custom installer. And this is the reply I got. There is a license available, but it depends on the situation. You should send your app details to Tim for the details Also, you might want to show the Silverlight license to the end users as part of your installer. I’m not pretty sure about this – the general recommendation is to fled Tim’s inbox.

Having said that, I really think MS should encourage developers to re-distribute Silverlight runtime as part of their custom installers, because that can definitely contribute towards increasing the Silverlight runtime penetration.