There are clear distinctions and usages for both WPF and Silverlight with a clear roadmap from the product teams.  But do not take my word for it. Here are two very good videos from Microsoft about these technologies:  

The first from Scott Guthrie Inside Silverlight 3 and the second from Jeff Wilcox Sharing Skills and Code with Silverlight & WPF 

Now, before I jump on my soapbox on Server Page development and its demise it is probably important to clarify a few more distinctions between Silverlight 3 and WPF.   First, I am ecstatic that Microsoft is doing everything in their power to make the programming experience between their two XAML based platforms more seamless. But there are some big differences that help a developer decide between the two.

Silverlight 3 is an RIA (rich internet application) platform product and as such means that it has certain limitations by design, mainly the browser security sandbox. Yes, Silverlight 3 can run outside of the browser now, but it still has the same security restrictions applied, it cannot run as a full trust app, it cannot take advantage of ClinkOnce, which is very important for certain business needs.  The Silverlight framework is lean and mean which is awesome and needed for an RIA based application that has to compete and utterly destroy FLEX/AIR (that is the goal right).  However, these lean frameworks come at a price.  Silverlight or FLEX cannot achieve the same performance levels as WPF running under the full .Net framework in full trust mode.  Complex engineering/manufacturing/etc. systems will run much more performant, with a greater set of capabilities under WPF.  

At my particular place of employment almost all the systems we build are expert systems that at some point will require modules which need to import large amounts of data from other systems for local manipulation and processing.  We also find ourselves having to have local data stores with sync capabilities against the master DB i.e. our engineers and power users can work in the field for days at a time before reconnecting.  WPF has to be used for these scenarios.

All other scenarios Silverlight is more than adequate to handle and is preferred.   This is a total guess on my part but I bet it is at least a 20 to 1 ratio between Silverlight vs. full WPF in terms of applications produced.

My company has a very successful Adobe FLEX development team.  I have seen first hand how powerful the RIA FLEX/AIR platform has become.  They have successfully met all their deadlines and under budget.  More importantly, the quality of the applications produced by our FLEX team has been outstanding.  FLEX has not been able to replace any of the more complicated think client expert systems (as no RIA can) but our web apps are a whole other store.  They replaced all there classic Server Page based applications (JSP and PHP) with much more capable and performant FLEX apps. 

As the .Net team lead at my company I HAD grounds to be nervous.  These are not successes an old .Net programmer wants to see from the competition so to speak. 

What my team is actually doing at work is NOT choosing between the Silverlight and WPF platforms.  We build both a WPF and Silverlight client using the PrismV2 or I should say Composite WPF and Silverlight Guidance as well as the CSLA Business Object framework to make the job even easier when working between these products. 

We start with the WPF project.  That is where all the base classes and lower level API stuff is created, i.e. the Model(s), Controller(s), ViewModel(s) and Services.  Then we create the Silverlight project and reference all the libs from the WPF side of the solution.  In some cases we can even share the same XAML Views but in most each project will need its own set of views.  Using Prism and CSLA we can bridge the shortcomings of Silverlight, i.e. its commanding, tunnel eventing and data binding models do not quite match up with WPFs power.  Prism and CSLA make these differences negligible.  At the end of the day, I would say I am getting almost 85% to 90% code reuse between our WPF client app and its Silverlight counter part.  Our clients get the best of both worlds with very little extra expense. 

As unfortunate as it is, ASP.Net does not stand a chance in my case with competing with the FLEX/AIR power house.  However, with Microsoft’s two very powerful XAML based products WPF and Silverlight 3 I not only stand a chance but can out perform the Adobe counter part quite easily.         

With Silverlight 3 I have already told our director that we will never build another Server Page anything (thin client) again.  No offense to our JQuery and AJAX friends but it has totally been obsoleted with Silverlight 3 and FLEX/AIR.  In my future, I do not see a need for ASP.Net developers.  I only want XAML developers to build me Silverlight (lots of them) and WPF (less of a ratio) apps.

I’ll admit these are bold words, but in a shop like mine where corporate LOB (line of business) app development is the norm RIA platforms have become the new King of the Hill with the occasional thick client counter part.   

I am always amazed at the lack of personal responsibility many (the large majority) developers display.  Obviously skills that are learned act like building blocks and will carry you a long way.  The problem is that our industry is one of the most dynamic and rapid changing of any out there.  If you do not keep up with the ongoing industry innovations you can quickly find yourself being left behind and unmarketable.  It is nice when you work for a company that is training minded and helps develop their employees but that is not the norm, and even then you still need to make a personal effort to progress your development skills.  The only person that is going to truly look after your well being and future marketability is yourself. 

It has been interesting to observe over the past year or so how many open mid to senior level software engineer/developer positions are available.  Many of these positions have been open for quite some time too.  I have spoken to a few of these employers to ask how their recruiting efforts are going.  I consistently hear the same echo, we have plenty of applicants just not finding people with the skill set we are looking for. Sure enough, the skills they are looking for are technologies and methodologies that are relatively new to our industry.     

Some good news for the readers of this blog.  By the sole fact that you are reading this post means you are among the top 10% to 15% of developers who are actively engaged in developing your craft.  One of the departments I worked for had 68 software engineers.  Of that group I only knew of 9 (13%) that were active BLOG readers, attend user groups or local geek events,  frequently reviewed or read software books/journals/magazines,  earnestly downloaded and experiment with beta software just because they wanted to, not because you were required to, or was part of some open source project giving time to make something cool to better our industry.              

You can probably tell by now I am a strong advocate of employing people who are self motivated and will personally take charge of developing their skills.  I hire people for what they know not what I can teach them (entry level positions excluded from that). Unfortunately I still have to work with and manage the other 85% to 90% who need to be told what to do.        

NOW TO MY PLAN:

I changed companies several months back.  My new employer is training minded and very supportive, the unfortunate part is they have no formal training direction or requirements for the members of the IT department.  As one of the companies Solution Architects I am seeing huge discrepancies and lack of standards throughout our department.  One of the first things I want to implement is a mandatory book reading list.  There will be three (sounds like a good number) books that every engineer will be required to read and signed off on.  There will be an accompanying class/lab that goes along with each book to give some hands on reinforcement.

First Book:

Needs to target programming style and software construction.  I have already chosen this one, I could not think of anything better then  “Code Complete 2” by Steven McConnell, I am currently working on the class lab material for this book now.   I am hoping this book and accompanying lab material will help get the developers on the same page regarding software construction standards.                 

Second Book:

Will be on Design Patterns.  I have not solidified my choice here yet only the category.  There are lots of good titles to choice from here. Obviously there is the original design pattern book “Gang of Four” and newer pattern books like ”Head First Design Patterns”.  What are your thoughts here?

Third Book:

I have nothing slated here yet.

The question for you all is, if you were going to have three books with accompanying lab/presentation material which was going to be mandatory for all developers to read what would they be?  Like many corporations we are multi platform so the books do not necessarily need to target a particular language but we are striving to standardized most our systems/applications on the Microsoft development stack so .Net is going to be a big part of our future.       

Thanks

Scott Nichols

The Event Broker Extension QuickStart demonstrates how you can extend the Unity container by adding a custom extension. The QuickStart implements an Event Broker for the container as a container extension and demonstrates the new extension using the StopLight QuickStart application sample.

The Event Broker Extension QuickStart contains three projects:

• EventBroker. This project implements a simple publish and subscribe mechanism that supports multiple event publishers and multiple subscribers.
• EventBrokerExtension. This project implements the custom container extension that allows applications to publish and subscribe to events using attributes or explicitly using code.
• StopLight. This project is basically the same as that described in the Unity StopLight QuickStart, but it uses the custom container extension to manage the publishing of, and subscription to, two events within the application.

Now, why is this Unity EventBroker interesting? Well, if you have ever worked with CAB (Composite UI Application Block) or SCSF (Smart Client Software Factory) then you know one of its main pillars was the implementation of a nice Pub/Sub event subscription framework which Microsoft called Event Broker. This was one of the best things about CAB. Unfortunately with CAB it is an all or nothing deal. You really cannot use the CAB Event Broker without using the rest of the CAB underpinnings.

The Unity implementation of the Event Broker is similar to CABs so you should feel right at home if you have any experience with CAB or SCSF. The one huge benefit is that the Unity Event Broker can easily be integrated into any existing WinForm or WPF application where you would like an easy to manage Event bus to handle all your event traffic.

It really is easy to implement, lets take a look at what you need to do in order to integrate the Unity based Event Broker into your application.

1) Download Unity 1.0 install it and unzip the “Unity QuickStart” package found in the Unity start menu installation path.

2) Compile the EventBrokerExtention and SimpleEventBroker projects.  Then grab the following DLLs found in the EventBrokerExtention bin folder and reference them in your application.
  EventBrokerExtension.dll
  SimpleEventBroker.dll
  Microsoft.Practices.ObjectBuilder2.dll
  Microsoft.Practices.Unity.dll

3) Now open your WinForm application and modify your entry point usually the Program.cs file which in my demo calls the FormMain.cs using a Unity Container like so.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using EventBrokerExtension;
using Microsoft.Practices.Unity; 

namespace SampleWinApp
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false); 

            // Create parent container
            IUnityContainer mainContainer = new UnityContainer()
                  .AddNewExtension<EventBrokerBusExtension>(); 

            Application.Run(mainContainer.Resolve<FormMain>());
        }
    }
}

The important thing to notice is that I have wired up the EventBrokerExtention class through the Unity AddNewExtention method.  This will cause all the Events that are properly decorated with the correct attributes to be automatically registered in the EventBroker or SimpleEventBroker class.

You will also want to go and modified all the areas in your code where you are opening other forms to use a Unity container as well.  Here is an example opening a Form called FromA.cs 

//Create container
IUnityContainer myContainer = new UnityContainer()
           .AddNewExtension<EventBrokerBusExtension>();
//Open Form
FormA newForm = myContainer.Resolve<FormA>();
newForm.Show();

Oh, make sure you import the proper libraries on all your forms.

using Microsoft.Practices.Unity;
using EventBrokerExtension;
using SimpleEventBroker;

Now you need to setup all the Event publications and triggers. Let’s start simple, say we have a button on our FormMain that is used to force a data refresh in your application. You would need to add a publish event to your page like so.

//Using an attribute register an event in the EventBroker
[Publishes("RefreshData")]
public event EventHandler RefreshData ;
//Method you will call to trigger the event in the EventBroker 
public virtual void OnRefreshDataChange(object sender, EventArgs ea)
{
    EventHandler handlers = RefreshData ;
    if (handlers != null)
    {
        handlers(this, EventArgs.Empty);
    }
}

On your button click trigger the event like so.

private void buttonRefresh_Click(object sender, EventArgs e)
{
    //Trigger your event 
    OnRefreshDataChange(this, e);
}

Now you need to setup all your Event subscriptions, this is supper easy.  You will need to create a method on all the forms in your application that will handle your refresh command i.e. implements the functionality you wish for each form or control in your application.  So far in this contrived example I have two forms FormMain and FormA.  You would add a method like so to each page.    

[SubscribesTo("RefreshData")]
public void OnRefreshDataFired(object sender, EventArgs e)
{
         //Do something, we need to do a data refresh
}

Now anytime the RefreshData button is pushed the event is fired and all objects subscribed to that event in the EventBroker will be triggered. 

One important step you will want to do is unregister your subscribed events every time a modal form is closed.  Remember we are using the Unity IoC container to open a form which automatically registers all publisher and subscriber event handles on form_load (opened). 

// Unregister your subscription to help prevent runtime errors
private void FormA_FormClosing(object sender, FormClosingEventArgs e)
{
     EventBroker myEB = new EventBroker();
     myEB.UnregisterSubscriber("RefreshData", OnRefreshDataFired);
}

That is about it, I used this to clean up an old legacy application that had Window events thrown everywhere.  The SimpleEventBroker class has several methods you can use to monitor what is going on inside the EventBroker such as GetPublisher, GetSubscribers, etc.

Oh, in my implementation I modified the Dictionary in the SimpleEventBroker class which holds the registered published events to be static, makes it easier if you have lots of modal forms, just make sure the Keys (string values) are unique.

public class EventBroker
    {
        private static Dictionary<string, PublishedEvent> eventPublishers  

        = new Dictionary<string, PublishedEvent>();

For those of you who many be asking what is he talking about, Inline XML comments in your source?  Well, that would be (in C#) all those /// comments you see from time to time in source code like so.

namespace TestNamespace
{
/// <summary> 
///    Tests whether sandcastle can handle all c# tags as defined at 
///    http://msdn2.microsoft.com/en-us/library/5ast78ax.aspx. 
///    Comments of method "Increment (int step)" include almost all tags. 
///    Method "Swap" is used to test generics tags, such as "typeparam". 
///    <threadsafety static="true" instance="false"/> 
/// </summary> 
[Serializable()]
public class StoredNumber
{  

/// <summary> 
///    Initializes the stored number class with a starting value. 
/// </summary> 
public StoredNumber( int value )
{ number = value; }

However today, I have noticed that many open source projects and a good share of commercial applications do not bother marking up their source code with XML comments. Maybe one contributing factor is that nDoc died, ok you can still download version 1.3 but it is over two years old now and Microsoft’s answer to this solution Sandcastle is not quite as snazzy as nDoc was i.e. Command-line interface, or maybe propel are just not aware of their options. 

The following information outlines what you need to install so you can create proper Inline API (MSDN-style) documentation.  Here is a list of programs you need to install.

Sandcastle:

Microsoft home page for Sandcastle

You can download it from CodePlex http://www.codeplex.com/Sandcastle

Sandcastle, created by Microsoft, is a free tool used for creating MSDN-style documentation from .NET assemblies and their associated XML comment files. It is command-line based and has no GUI front-end, project management features, or an automated build process

SHFB (Sandcastle Help File Builder):

You can download SHFB from CodePlex http://www.codeplex.com/SHFB

SHFB is a GUI interface that almost looks identical to the NDoc interface so anyone familiar with NDoc should be quite comfortable using it.  It uses the underlining Sandcastle API to generate an HTML 1.x (.CHM) file, an HTML 2.x (.HxS) file, and/or a web site.

SHFB Requirements

In order to use SHFB you will need the following:

- The .NET 2.0 Framework

- The latest version of Sandcastle. 
- The HTML Help Workshop for building HTML Help 1.x (.CHM) help files

- The HTML 2.x compiler for building HTML Help 2.x (.HxS) help files

You can obtain the HTML builders by installing the Visual Studio 2008 SDK these are the latest builds.

XML Documentation Comments Guide:

Home page http://www.dynicity.com/downloads/default.aspx

Download the “Windows Installer” at http://www.dynicity.com/downloads/XMLDocCommentsGuide.exe

This is a help file with a very nice collection of information on how to use XML Comment tags properly in your source code, it has lots of links to some good tutorials and examples. 

DocProject for 2008:

Home page from CodePlex for DocProject

DocProject drives the Sandcastle help generation tools using the power of Visual Studio 2005/2008 and MSBuild. Choose from various project templates that build compiled help version 1.x or 2.x for all project references. DocProject facilitates the administration and development of project documentation with Sandcastle, allowing you to use the integrated tools of Visual Studio to customize Sandcastle’s output.

Example Links:

.NET Documentation Guidelines (version 2.5)

http://p3net.mvps.org/downloads/docs/DocGuidelines.doc 

XML Documentation in C# (Anson Horton, C# Compiler Program Manager)

http://cyrino.members.winisp.net/9112006/XMLDocs.doc

C# XML Documentation (Alan Dean)

http://thoughtpad.net/alan-dean/cs-xml-documentation.html

C# and XML Source Code Documentation

Documenting C# source code with XML Comments