• [0:42] MSR shows off IllumiRoom
• [2:10] VS/TFS 2012 Release Candidate expiring (Brian Harry)
• [2:44] Git-TF 2.0.1 Released (Brian Harry)
• [3:28] OData Service for Team Foundation Server v2 (Brian Keller)
• [4:33] TFS Source Control History Visualization (Alexandr Biryukov)
• [5:57] Apache Cordova [fka PhoneGap] and Windows Phone 8 (Jesse MacFadyen)
• [6:37] MEF 2.0 TOC (Bnaya Eshet)
• [7:52] Gemicon Icon Set (600 PNG Icons + PSD Source) (Smashing Editorial), The Noun Project
• [8:51] Recent Updates to the Windows Azure SDK - .NET 4.5, Windows Server 2012 and more (Mohit Srivastava, Dennis Angeline)
• [9:31] Codecademy adds API training with YouTube, NPR, Bit.ly, and 6 other services to help new devs build actual products (John Koetsier)

Picks of the week!

• [10:40] Clint's and Dan's Pick of the Week

Cocoon

Cocoon is a framework to support the development of .Net Windows 8 Metro-style applications, in particular those that link to web services. It simplifies accessing, displaying and editing data using standard Metro controls, and allows easy application of the MVVM pattern.

For more details, and news on the latest releases visit http://andyonwpf.blogspot.com

Current Features

• A navigation framework with,
  • Attribute based page and view model discovery using MEF
  • Automatic creation and wiring up of page and view model
  • Passing of parameters to view models upon activation
  • Persistence of navigation and state upon application suspension

• A data framework with,
  • Support for observable collections and data virtualization
  • An extensible framework for the retrieval, processing and display of data from the cloud

Documentation

• Introduction
• Base Types
  • ObservableVector<T>
  • VirtualizingVector<T>
• Cocoon Navigation Framework
  • Defining pages and view models
  • More to follow...
• Cocoon Data Framework (IDataListSource<T> and data lists)
  • Introduction
  • Example Code
  • SimpleDataListSource<T>
  • PagedDataListSource<T>
  • VirtualizingDataList<T>

Cocoon – A new framework for Windows 8 Development

To assist with Windows 8 Metro-style applications I would like to announce the Cocoon framework (http://cocoon.codeplex.com/). This aims to build on top of the learning from the Chrysalis project to provide a simple way to develop Metro-style applications in a manner that fits naturally with the MVVM design pattern.

It is likely that many Metro-style apps will be connected applications, downloading data from across the internet in response to user navigation. Modern applications are expected to do this in a seamless manner, retrieving data on demand and populating the user interface in response. In some ways this is at odds with the web API programming model that is based upon individual request-response calls, with paging used to retrieve large datasets. One of the first targets of the Cocoon framework is to simplify this process – bridging the world of stateless web API calls, with the “fast and fluid” interfaces expected by users.

 Navigation in Cocoon – MVVM for Metro-style apps

Navigation in Cocoon

Although not limited to this, the Cocoon framework is designed to work great with the Model-View-ViewModel (MVVM) pattern that has become common when designing XAML based applications. One problem when using this pattern is that you need some way of associating a view with a view-model. Often this is done by navigating directly to a page, and using a “ViewModelLocator” to identify and wire up the respective view-model.

In Cocoon a slightly different approach is used. Here, rather than navigating directly to a view, you navigate to a named page. Although the behaviour is extensible, by default Cocoon will use MEF (the built in composition framework included in .Net) to locate both the view and view-model associated with this page name, create and initialise instances of these and wire them together.

...

The Navigation Manager

In order to navigate between pages, Cocoon includes a navigation manager that can be accessed by importing the INavigationManager interface through MEF (simplified by the fact that all views and view models in Cocoon are themselves are composed by MEF).

Getting Started with Cocoon Navigation – The Cocoon Bootstrapper

Since the Cocoon navigation framework is built on top of the Managed Extensibility Framework (MEF), the application is composed with the required dependencies as the user navigates through the application. MEF is a composition framework that is built into the .Net framework, that enables the construction of loosely-coupled, easily maintainable and testable applications to be composed automatically at run time. An introductory guide for those who are not familiar with MEF is available here.

What I have not covered previously however was how to navigate to the application’s first page when it is launched,

Launching Navigation Using The Cocoon Bootstrapper

To simplify the initialization of Cocoon based applications the framework includes the ‘CocoonBootstrapper’ class that can be used at startup. This manages the configuration of MEF for the most common scenarios, initialization of services and activation of the application.

...

Here's a snip of the sample app running.

Note, to get the sample app to run, you'll need your own Flickr API Key.

Here's a snap of the Solution;

And some snaps of the code, showing a little bit of how MEF is used.

If you've thought, "I love MEF and I wonder if I can use it to compose Metro Style App's, without messing up navigation" or looking for a new data handling framework or just want to check out a cool framework, Cocoon, and all its source, is ready for you...

In this video, you'll see how you can get MEF running in an ASP.NET MVC site and how to successfully decouple the controller layer from the service infrastructure and allow for reuse of the service layer across multiple controllers. The Microsoft.MEF.CompositionProvider NuGet package put forth by the MEF team makes MEF an irresistible DI/IoC option for MVC developers.

Let Brady Gaster show you how to inject your MVC site using Visual Studio 11 and MEF 2.0 and quickly have more SOLID code.

Specific topics covered: Async across the framework, read-only collections, ETW APIs,  Reflection Context, MEF, WeakReference<T> and more.

Tune in. Meet the BCL 4.5 team.

Great work going on in MEF world! Tune in. Enjoy.

This session is presented by Mike Taulty during Microsoft DevDays 2010 in The Hague in The Netherlands.

Follow @SilverlightTV on Twitter for the latest updates.

Follow @SilverlightTV on Twitter for the latest updates.

Follow @SilverlightTV on Twitter for the latest updates.

Follow @SilverlightTV on Twitter for the latest updates.

MEF is a framework that simplifies the design of extensible applications and components. It can flexibly and dynamically discover a set of loosely coupled components and analyse their dependencies in order to compose them together at run time.

In this screencast we take a look at how we can provide defaults in a CompositionContainer such that an application can be sure that it has an implementation of a plug-in if no additional plug-in is discovered by MEF. This leads to a discussion about ExportProviders and how they provide an extensibility point for MEF.

Tips for viewing:

• Each video in this series has a 3.5 minute standard introductory "header" on it so once you have seen that header you may like to skip it on subsequent videos
• For the time pressured - I find that I speak so slowly that you can speed me up to approximately 1.5-2.0 times normal speed and still listen comfortably.

I'm working to get together a Live Meeting in early 2010 with people from the MEF team in order that people can chat more about MEF in Silverlight. Stay tuned.

The next screencast in this series is ( not yet available ). "That's all folks!" but subscribe to the feed above for notifications when more come online...

MEF is a framework that simplifies the design of extensible applications and components. It can flexibly and dynamically discover a set of loosely coupled components and analyse their dependencies in order to compose them together at run time.

In this screencast, we look at an additional catalog in the Silverlight Toolkit Preview for Silverlight Beta 4, the PackageCatalog. This catalog adds the key ability of being able to download XAPs dynamically at runtime and ask MEF to discover and compose the types contained within those XAPs into a pluggable application.

Tips for viewing:

• Each video in this series has a 3.5 minute standard introductory "header" on it so once you have seen that header you may like to skip it on subsequent videos
• For the time pressured - I find that I speak so slowly that you can speed me up to approximately 1.5-2.0 times normal speed and still listen comfortably.

I'm working to get together a Live Meeting in early 2010 with people from the MEF team in order that people can chat more about MEF in Silverlight. Stay tuned.

The next screencast in this series is here.

MEF is a framework that simplifies the design of extensible applications and components. It can flexibly and dynamically discover a set of loosely coupled components and analyse their dependencies in order to compose them together at run time.

In this screencast, we look at how composition of component parts in MEF is not necessarily a static or "one-time" process and that as changes are made to MEF's CompositionContainer it can re-compose components to take account of those changes.

Tips for viewing:

• Each video in this series has a 3.5 minute standard introductory "header" on it so once you have seen that header you may like to skip it on subsequent videos
• For the time pressured - I find that I speak so slowly that you can speed me up to approximately 1.5-2.0 times normal speed and still listen comfortably.

I'm working to get together a Live Meeting in early 2010 with people from the MEF team in order that people can chat more about MEF in Silverlight. Stay tuned.

The next screencast in this series is here.

MEF is a framework that simplifies the design of extensible applications and components. It can flexibly and dynamically discover a set of loosely coupled components and analyse their dependencies in order to compose them together at run time.

In this screencast, we start to take a look at catalogs which provide one way in which MEF discovers the components that it can compose. We take a look at the catalogs built into the framework and what they do for us and also how MEF uses them to populate a default CompositionContainer & how you can take control of that.

Tips for viewing:

• Each video in this series has a 3.5 minute standard introductory "header" on it so once you have seen that header you may like to skip it on subsequent videos
• For the time pressured - I find that I speak so slowly that you can speed me up to approximately 1.5-2.0 times normal speed and still listen comfortably.

I'm working to get together a Live Meeting in early 2010 with people from the MEF team in order that people can chat more about MEF in Silverlight. Stay tuned.

The next screencast in this series is here.

MEF is a framework that simplifies the design of extensible applications and components. It can flexibly and dynamically discover a set of loosely coupled components and analyse their dependencies in order to compose them together at run time.

In this screencast, we take a deeper look around using the MEF attributed programming model. We look at what we can import & export, required and optional imports, cardinality, creation policies and also how we can add our own metadata for differentiation.

Tips for viewing:

• Each video in this series has a 3.5 minute standard introductory "header" on it so once you have seen that header you may like to skip it on subsequent videos
• For the time pressured - I find that I speak so slowly that you can speed me up to approximately 1.5-2.0 times normal speed and still listen comfortably.

I'm working to get together a Live Meeting in early 2010 with people from the MEF team in order that people can chat more about MEF in Silverlight. Stay tuned.

The next screencast in this series is here.

MEF is a framework that simplifies the design of extensible applications and components. It can flexibly and dynamically discover a set of loosely coupled components and analyse their dependencies in order to compose them together at run time.

In this screencast, we talk briefly around the idea of components having imports and exports and then we drop into Visual Studio 2010 and do a quick, "magic" demo of how MEF can plug together a couple of components for us. In later videos, we'll attempt to dig deeper into what MEF is doing and how we can take more control of it.

Tips for viewing:

• Each video in this series has a 3.5 minute standard introductory "header" on it so once you have seen that header you may like to skip it on subsequent videos
• For the time pressured - I find that I speak so slowly that you can speed me up to approximately 1.5-2.0 times normal speed and still listen comfortably.

I'm working to get together a Live Meeting in early 2010 with people from the MEF team in order that people can chat more about MEF in Silverlight. Stay tuned.

The next screencast in this series is here.

Introduction

It's been a number of months since I released the first version of my Utility Runner application.  Utility Runner makes it possible to run system utilities with as little overhead as possible: Instead of lots of tray icons, numerous EXE's, and the associated memory and startup time overhead, this application manages multiple utilities from one place.

To open this solution, you'll need Visual Studio 2008 Express Edition (Visual C# or Visual Basic), at least.  If you don't have it yet, you should get it!

Working with MEF

Little has changed functionally from the last version of the application, beyond some refactoring that's taken place since the new version of MEF was released.  For one thing, the attribute for marking an export is no longer sealed, so you can now create a subclassed attribute that encompasses the export name and any other metadata included with it.  Consumers can simply use your new custom attribute for a stronger-typed experience.  In my case, I created a WpfServiceMetadata class.  Read on for more information.

Managing Addins

My big challenge was figuring out how to implement an addin manager to support multiple utility addins, like in Firefox.  MEF lets you easily mark what classes are addins and where they should fit into your overall code, but I wanted to take it further.  I decided that my goals were:

• The ability to load an addin through the UI
• The ability to disable/enable addins
• The ability to remove an addin 

There are a number of ways to achieve these goals.  Mine isn't the ideal way, but it works pretty well nonetheless.

Loading Addins

Loading addins is mostly handled by the MEF Framework itself, but there is some manual work involved as well.  I decided that instead of scanning a folder for DLL's like in the first version, I'd take things a step further:  I came up with a simple packaging format to contain the addin and its associated files.

The packaging format is simply a Zip file renamed with the .util extension.  The file contains at least the DLL of the addin itself, but might also include associated libraries, images, sounds, or other resources.  I toyed with creating a manifest file to help supply addin information that didn't require class loading, but I kept it simple for now.

Before loading DLL's with addins, the AddinManager class will scan the addins folder for .util files and unzip them to same-named folders.  Each of these folders gets added to the list of folders in which MEF searches.  The original file then gets deleted.

Adding an addin

An application that uses addins needs a way for users to add new ones.  The easiest method would be to have the user just drag new .util files into the Addins folder, but this isn't very user-friendly.  I wanted to make it easy for a user to click something in the application to install an addin.

If the user clicks the Add New Addin From File button, they use a file browse button to locate the file.  The application then copies that file to the Addins folder and notifies the user that it will be loaded on next startup.  It would be great to load the addin immediately, and MEF supports that, but I decided to skip dynamic addin control for simplicity.

Instead of going through the dialog when loading an addin, it would be nice to support double-clicking. To do this, an association needs to be made from the .util extension to the executable.  If you launch the executable with a file argument and it's the right format, it will automatically copy it to the Addins folder.  If an instance is already running, the new instance will just exit.  Similarly, if you launch the executable when another instance is running, the existing instance will show itself and the new instance will exit.

It's important to note that standard users don't have write access to the Program Files folder.  For this reason, addins need to be stored in the user's local profile folder.  System-level addins can be stored in the ProgramData folder.  Addins could be in the user's roaming profile folder, but I haven't thought through all of that yet.  (For example, if a user logs into different machines, an addin might not run on each system due to different hardware configurations.)

Disabling an addin

Disabling an addin should be a simple matter of renaming the addin folder.  You can't do this at runtime though, since the DLL's are locked and loaded.  As an alternative, I create a file (zero-length) with the same name and add the .disable extension to it.  I check for this upon startup and before loading, and can handle it properly.

Enabling and removing addins are handled similarly, using .enable and .delete extensions on the zero-length files.

Creating Addins

To create an addin, you need to 1) implement the IWpfService interface, and 2) add the WpfServiceMetadata attribute with a name for your addin.  From there, be sure to implement all the methods in the interface.  The Start method is called at initialization (you shouldn't take much time in the constructor), and Stop is called at the end, for cleanup.  Any time you want to update the Status, be sure to raise the StatusChanged event.

[WpfServiceMetadata("SampleAddin")]
public class SampleAddinImpl : IWpfService
{
}

The final thing you'll need to do is copy your addin DLL to a folder with your addin name, plus the .util extension (Yes, an extension on the folder name.  I do this in Visual Studio with a post-build event.  If you debug the application, it looks for an Addins folder under the current directory.  When started normally (such as when installed) it uses the local user profile.

When you're ready to distribute the addin, compress the DLL and any supporting files into the top-level of a ZIP file, then rename the .zip extension to .util.  You can load this from the Addins page of the app settings, or manually move it to the MefUtilRuner\Addins folder in your local profile folder (c:\users\{USERNAME}\AppData):

TimedQueue

Message boxes, balloon help, status bars—these are all great ways to display a message to the user, but they all only show one string at a time.  If you call it again before the reader has the chance to see it, it's just gone.  There are some nice message managers that make it easy to manage stacking alerts, but I decided to stick with the built-in balloon help provider, and just manage how often I send changes.  It's basically a buffered balloon provider that will only show messages every x number of seconds, regardless of how many attempts the application makes.  To use it, simply add items to the collection.  An event is raised whenever an item is available.  If an item has exceeded the maximum time-to-live threshold, the users of the collection never see it.

// Repeat while there are items (one pulse may occur with several items ready)
while (item != null)
{
    // If this is an old item, no event is raised.  This could happen if
    // a process goes into a loop and dumps a large number in a very short
    // amount of time.  
    if (DateTime.Now.Subtract(item.TimeStamp).TotalMilliseconds < _maxTTL)
    {
        RaiseEvent(item.Item);
        Thread.Sleep(_interval);
    }

    item = default(ItemWrapper<T>);

    lock (_lock)
    {
        if( _items.Count > 0 )
            item = _items.Dequeue();
    }
}

The main window creates an instance of the TimedQueue class.  Every time an addin wants to display a message, it's added to the collection.  When ItemAvailableEvent fires, it's dispatched to the UI thread to be displayed.  Dispatching prevents cross-threading issues between the background TimedQueue thread and the UI thread.

void statuses_ItemAvailableEvent(object sender,
    ItemAvailableEventArgs<StatusMessage> e)
{
    Dispatcher.BeginInvoke((ThreadStart)delegate() {
        StatusUpdatedHandler(e.Item); }
        , DispatcherPriority.Background);
}

Though this instance is being used for status messages, you can also use TimedQueue for other purposes, when you are willing to lose old messages.  One example would be to throttle user input, such as a game that doesn't want constant firing or jumping as fast as the user clicks a button.

Next Steps

There are a number of things that would be nice to have in this application.  It would be good to allow utilities to extend the context menu to enable or disable something, or at least to jump straight to their configuration page.

Using ClickOnce to deploy utilities would also be nice since it's so clean for the user, but there is a cost:  ClickOnce is very strict about how applications can interact with the system.  They are always per-user, and they live in “secret” folders.  Developers can't read or write to the hard drive except to protected storage (similar to the iPhone I suppose).  I'm not sure if they are restricted in other ways, but it could cause a hardship.

It would also be nice if addins could be added at runtime.  This is a fairly simple case, but I didn't get to it yet.  Furthermore, if you add, you might expect to enable/disable/remove at runtime too.  Unfortunately, disabling and removing aren't really possible.  Sure, I could call Stop on a utility and remove it from the UI (and not call Start on it next time), but that's not really disabled since it could still be running until the next restart.  I couldn't force it to die unless I used separate application domains, which I'm loath to do.

Finally, I'd really like to get an “app store” type of repository going.  I imagine being able to publish utilities like Sidebar Gadgets or Windows Live Writer Plugins so users can browse, read information, and click-and-install.  That could be a really great way to make the idea take off.

Conclusion

There are definitely some rough edges at this point, but it's getting there.  The source code is fully available and I'd be willing to give commit access to anyone interested in moving things forward.  Just drop me a line!

About Arian

Arian Kulp is a software developer living in Western Oregon.  He creates samples, screencasts, demos, labs, and articles; speaks at programming events; and enjoys spending time with his family.

Resources from this episode:
- [Nicholas Blumhardt] Analyze MEF Assemblies from the Command Line
- [Laurent Bugnion] MVVM Light Toolkit

For more 10-4 episodes, be sure to visit:
http://channel9.msdn.com/shows/10-4

10-4! Over and out!

Source code for demo: http://cid-1b51ad25aad8fc86.skydrive.live.com/self.aspx/.Public/ManagedExtensibilityFramework.zip

For more 10-4 episodes, be sure to visit:
http://channel9.msdn.com/shows/10-4

10-4! Over and out!