I had a great time talking to Scott, who is an excellent host, but one thing I did not get an opportunity to do was to extend my gratitude to the awesome people that are forming up a community around the project, everybody from the people that blog, tweet, screencast or in some other way help Nancy grow into an awesome framework – so thank you to all of you!

The following people have all contributed to the Nancy repository and have helped us get many of the awesome features and bug fixes (if your name should be on this list, but it not, please drop me a line and I will get sorted out!)

Andy Pike, Bjarte Djuvik Næss, Chris Nicola, David Hong, Graeme Foster, Guido Tapia, Hernan Garcia, Ian Davis, Jonas Cannehag, José F. Romaniello, Karl Seguin, Luke Smith, James Eggers, Jason Mead, Jeremy Skinner, João Bragança, Johan Danforth, John Downey, Maciej Kowalewski, Martijn Laarman, Mindaugas Mozûras, Patrik Hägne, Pedro Felix, Piotr Wlodek, Phil Haack, Robert Greyling, Simon Skov Boisen, Steven Robbins, Thomas Pedersen, Troels Thomsen, Vidar L. Sømme

I would like to extend a special thank you and shout out to my friend and co-conspirator Steven Robbins a.k.a @GrumpyDev on Twitter. He is a continuous source of awesome for Nancy and the project is better for having him onboard, that is one thing I am certain on. Thank you buddy!

If the movement (if you can call it that) is truly dead, then what? Do we just roll over and play dead, or do we add more value to it and help breath new life in to it? If your answer is the former then you are simply not an open-source kind of guy. Now imagine that it’s is, in fact, a vibrant and thriving community, full of goodies to choose from. What should be do then? Stop adding value to it since it’s already doing well, or do we keep on pushing to add even more value into it? We keep adding value, of course, if it wasn’t already obvious that would be my answer.

Alright then, how do we inject move value into it? Contribute to an already active project or start a new one? It truly depends on your visions. First of all let me make it perfectly clear that I think diversity is not only a good thing, but a sign of a healthy community. There is no single “silver bullet” that will solve all problems or in a way that out domain requires them to. It’s very rare for a “all-in-one” solution is the best for your scenario and that’s why I believe opinionated solutions is required.

Everybody won’t agree to a single opinion, it’s just not ever going to happen, so how could a single framework or product be the solution to all problems we face in our industry? It can’t.

The first thing you should get out of your head is that your source code is where the gravy is. Sticking to that story won’t get your very fare. Any decent programmer can probably reproduce any functionality with their own implementation. It might not be as fancy as your solution, but I’ll bet you that it would work well enough to solve the problem they were facing – they’d see to that.

So if the value is not in the source code, that you’ve spent weeks, maybe months, perfecting and to work just the way you wanted it to, with all the fancy solutions and patterns in place, then were is it? It’s in the vision of the source code. The vision is the heart and soul of your project and it’s what will ensure that the project can live on even if you loose interest. It’s your opinions on how things should be done.

Now, of course, if you vision is nearly the same as the next guy and all you do is pinch his source code and call it your own thing, then you’re just being an asshole. I’m sorry, but you are. If you have a clear idea on how you thing a certain set of problems should be solved, that’s when you have the foundation for a nice opinionated solution…that’s the vision of your project.

The vision of the project should be set in stone before you make the first public release. Be careful not to be blinded by the massive amount of suggestions and contributions that you might be getting. If they will lead you down a path that is not true to your vision – ignore them. Send them a “thank you, but this is not for this project” and if they don’t like that then they should distil their visions into their own project. It’s impossible to say which would be the better solution – heck, why can’t both be just as good but suite different people? Diversity.

If you nurture the vision of your project well enough and attract equal minded people then you have started a community and they will make sure the project stays true to the original vision, trust me. Should you suddenly loose interest in the project, or for some other reason not be able to commit to the cause anymore, the community can simply fork and create a new authorities branch. This has happened time and time again in many of the big open-source projects.

I’m happy to say that I keep seeing the diversity in the .NET open-source community grow as we speak. I keep seeing more and more small, opinionated, projects pop up and that they are being embraced by a subset of our community as a whole. Sure, the .NET community has probably quite a bit more to invest in open-source, but it’s getting there and the only way to get there faster is to be part of the ride!

Once you get beyond the basic requirements, the “basic video player” becomes very involved.  A few questions that will need attention are:

• “How do you handler markers?”
• “How is streaming video handled?”
• “What do you do an an error?”
• “What’s the strategy for buffering?”
• “Can the video player support Smooth Streaming content?” (this is a whole different conversation)
• “How does the video player handle Closed captioning?”

And on and on the list goes.  At some point (hopefully in the analysis phase) you should ask is it better to build or buy.  If you decide to build, give me a call , but before you do I would encourage you to take a look at the following open-source (free) Silverlight video player options.  If nothing else, these players are great place to start.

I’ll start off with the three best options, then highlight other projects I am less familiar with.

Silverlight Media Framework (SMF)

http://smf.codeplex.com/

This is so much more than a video player, it’s an entire framework.  Developed by Vertigo in coordination with Microsoft, SMF has been used on the largest, most watched, Silverlight video players to date.  Wimbledon, NFL’s Sunday Night Football, PDC live keynote, and the NBC’s Vancouver Olympics video players, to name a few, all use SMF.  To say it’s robust would be an understatement.

Other than the standard video player controls, here are additional highlights of SMF:

• Smooth Streaming support – includes the Microsoft.Web.Media.SmoothStreaming.dll
• Great base classes like MergeableCollection, SimpleEventArgs and ObservableObject
• A light weight data project
• Logging
• Blendability – the player is easily skinned
• InStream markers
• Bitrate – the ability to show bitrate

For a more detailed list of features, and the code, check out SMF’s site.

Silverlight Video Player

http://slvideoplayer.codeplex.com/

If you have ever watched a video on Channel 9 (if you haven’t check out Silverlight TV) the player being used is this video player.  It was developed by Tim Heuer (Microsoft) and Joel Nuebeck (Silverlight MVP).  Although SVP does not the feature set the SMF player has, this is still a solid and proven video player.  It’s is probably the best option for a standard, light weight, feature rich video player.

Silverlight HyperVideo player (HVP)

http://slhvp.com/

A new video player to the scene is the Silverlight Hyper-Video Player (HVP).  This offering is from Jesse Liberty (Microsoft) and the Community.  Targeting Silverlight 4, HVP takes advantage of the MEF framework and is rooted in best development practices.  Although the project is young, there is a lot of traction and Jesse is doing an amazing job of documenting each step.  Keep on eye on HVP as this maybe the most scalable offering.

Others

The above three video players I have personally used, dug through the code, and/or evaluated.  The following projects I am not as familiar with, but could be possible options for your scenario:

Sharepoint video player – http://svp.codeplex.com/

Silverlight Media Player http://silverlight30.codeplex.com/

xLite player - http://xliteplayer.codeplex.com/

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>();

The argument for writing your own container was simplicity and the learning curve for new developers on the team. I strongly disagree.

I can’t think of anything simpler than downloading an existing IOC container that has a near flat-line learning curve, like the Castle Windsor container. About a year ago, I introduced it into the team. No learning problems whatsoever. Just read two blog posts about it and you are on your way

But the main reason I disagree is that I strongly believe that we have to provide business value instead of writing yet-another-IOC-container. We have to solve the problems of our customers. They simply don’t care about IOC containers.

Scott Hanselman has a nice list of Dependency Injection Containers. Pick, choose and get over it!

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

The NHibernate FAQ
Craig Neuwirt
Hibernating Rhinos

I have to admit that even though my plans for this machine are all about getting Windows Vista installed as soon as my Leopard CDs arrive, this OS X thing is intriguing. Although it is frustrating not knowing my way around as I o in Windows, the obvious beauty and attention to aesthetic are really nice to work with. Frankly, the darn windows are just nice to look at.

I want to make it perfectly clear before I go into the next part of this article that I did not buy this machine for the OS X capabilities, although I am giving them due diligence. I bought the machine for the hardware performance and unparalleled form factor. Frankly, it is one of the most beautiful pieces of hardware I have ever seen and I don’t regret it a bit.

That said, all is not perfect in MacVille. I am pretty used to hearing all about how Macs kick chicken and OSX is the greatest thing since peanut butter, so let me offer some observations.

When I tried joining my wireless network I had the stupidest issue I can imagine. The network connection utility kept telling my my password was wrong. I double and triple checked it. I even plugged in a wire and then copied and pasted the password from my router’s management screen. No dice. Ultimately I learned somewhere in the bowels of a newsgroup that when you are inputting a hex password you must prefix that password with a $ dollar sign as a signal to the connection gods that your password is in hex. What the…? That is the weirdest thing I have ever heard of. My mom would never have gotten that to work.

Next, Apple is making this great play with BootCamp, the revolutionary dual booting technology that Windows users have enjoyed for the last 10 years? Well anyway, what you don’t get with OSX is virtualization software. Or baked in remote desktop technology. Or 2 mouse pad buttons on the touchpad when right-click is a feature of the Apple OS (I simply don’t understand that one).

I can’t believe I am saying this, but I am getting the idea that it is cheaper to outfit a Windows machine with all the software you need. There is so darn much Windows software in the world, much of it open source or freeware. I could run all the same Java applications on both platforms, but I just have to have Visual Studio, Live Writer, Enterprise Architect, TextPad, and several other things that go along with the MS stack.

Non of this really matters, of course, because the reason I got this machine was to run Windows like a flaming pig runs downhill. Since Apple understandably pulled BootCamp from beta in preparation for the Leopard launch Friday I will have to tell you how that goes sometime next week. Once my Leopard upgrade arrives I will get Vista on here. Now there is some irony for you.

My last OSX comment of the day? This thing is prettier than a bag of redheads. I could get used to it if I’m not careful. After all, I can type ls on the command line for the first time since college.

I am currently casting about for at open source web portal frameworks written in .Net. I would like my first concern to be the architecture of the UI plug-in modules, security providers, and data models. Unfortunately, it looks like my first concern must first be the license model of the software. To be fair, I am looking to embed this software in a for-profit, redistributable, and re-branded application.

There is actually very little to complain about with free software even if it is free like a puppy.

So, what license is the most conducive to an embedding scenario? I don’t know. I will have to get someone in legal to start to plow through these things, I think. Any feedback on your experiences would be most appreciated.

Any other frameworks you suggest, by the way?

Is this Open Source snobbery?  Is it scheduled for the next version? What’s the deal?

Hands down, the user experience of NUnit+ReSharper beats MSUnit (MSTest) + Visual Studio Test Runner.  The one thing that I love being able to do with MSTest is not present in ReSharper (at least I haven’t found it); The ability to generate a test fixture class based on an a pre-existing class file.  This is such a time saver and while not strictly TDD conformant it is very useful functionality.  Let’s see some of that baked in for NUnit support.