You can play with the new version at http://videoeditor.cloudapp.net/.

The downloadable packages of the new release are:

• MMP Video Editor 2.0 Source Code: Useful in case you want to know how the different features are implemented.
• MMP Video Editor 2.0 Binaries: If you don’t care about the source and just can’t wait to host it.
• MMP Video Editor 2.0 Documentation: Updated documentation, including the “New Features in the MMP Video Editor 2.0” that provides a brief overview of the brand new features.
• MMP Video Editor 2.0 Overlays & Rubberbanding Plugin Sample: Two plug-ins for the “Microsoft Media Platform Player Framework (formerly SMF)” were created to manage overlays and rubber-banding in CSMs (see new features document). The sample includes the source code for the plug-ins and a sample player that showcases the plug-ins’ capabilities.

New Features

The full list of new features included in this version are:

• Silverlight 5 based
• Out-of-Browser capabilities
• Floating Windows
• Playback Model: CSM Based
• Multiple Sequences
• Sub-clip Tool
  • Asset Preview
  • Multiple Video Cameras selection
  • Multiple Audio Tracks selection
  • Metadata Support
• Multiple clips selection and locking
• Enhanced Overlays Support
• Markers and Ads Browser
• Rubber banding and multiple audio tracks
• Keyboard Layout Configuration
• Jog wheel support

I recommend you to go over the new features document before you start editing clips, as there are a lot changes in most of the major features of the application.

If you have comments, questions, suggestions or any issue, please visit the MMP Video Editor community site.

We hope enjoy this new version and have a lot of fun editing!!!

First things first, why do I want fluency?

This is of course a matter of appreciation, but I personally relate fluency to both ease of use and readability. Interestingly enough one of them is important before writing the code, and the other one after doing so. The idea is that a fluent API will give you a small set of options when performing a particular operation, each of them will be presented at the correct moment, and that once the code has been written, you can explain it to your non-tech grandma.

Our fluent scenario, mapping types

A really common operation that needs to be performed when working with DI containers is mapping types, which involves configuring the container to determine the type you want to get when requesting another type. This is commonly used by mapping an interface to a concrete implementation.

Let’s say we have an IForceEnlightened interface, and a Jedi class which implements that interface. If we wanted to get a Jedi whenever we request an instance of IForceEnlightened from the container, we can write the following code:

INeedleContainer needleContainer = new NeedleContainer();
needleContainer
    .Map<IForceEnlightened>() // when we request an IForceEnlightened
    .To<Jedi>() // provide a Jedi
    .Commit(); // save the mapping

One really important thing about the fluent API is that, in every step of the way, IntelliSense only shows us the relevant members:

Transactional Operations

The Commit() method call might have caught your eye in the previous code sample. This call is necessary, because Needle uses a transactional operation model. When performing a configuration operation with Needle, a committable object is created, which you must commit back to the container for the operation to take place.

This can also be useful in situations where you need to perform a certain configuration in a component, but want to wait until that configuration takes place. In this cases, keeping a reference to the ICommitable object until you want the configuration to take place does the trick.

Each thing by its own name

Let’s say we have another scenario, in which we could need either a Jedi or a Sith when requesting a force enlightened subject. In this case, the following code would do the trick:

needleContainer
    .Map<IForceEnlightened>()
    .To<Jedi>()
    .WithId("Jedi")
    .Commit();

needleContainer
    .Map<IForceEnlightened>()
    .To<Sith>()
    .WithId("Sith")
    .Commit();

After that the container will have both mappings, which can be injected into another component using, for example, Constructor or Property injection.

Lifetime Management

In case we want to get the same Jedi instance each time we request a force enlightened subject, we can change the default lifetime registration from Transient (a different instance each time we request an IForceEnlightened subject)  to Singleton (returns the same instance every time).

needleContainer
    .Map<IForceEnlightened>()
    .To<Jedi>()
    .UsingLifetime(RegistrationLifetime.Singleton)
    .Commit();

Singleton registrations are commonly used with services in most applications.

Putting it all together

Of course, we can both name and determine the scope of a registration. If we want fast and simple access to Master Yoda (and who doesn’t), we can name the mapping and set its lifetime to Singleton:

needleContainer
    .Map<IForceEnlightened>()
    .To<Jedi>()
    .WithId("Yoda")
    .UsingLifetime(RegistrationLifetime.Singleton)
    .Commit();

Wrapping Up

I hope you found this post fun, and that you try out Needle and its fluent API sometime. You can download Needle from here or through Nuget:

PM> Install-Package NeedleContainer

• Using some kind of binding helper as a View’s resource.
• Having a View Model wrap the entity of each collection item, and add the command to the View Model.

Although these are perfectly valid approaches, they require extra work compared to the good old {Binding} syntax we are all used to.

Now that Silverlight 5 Beta is out, we can take advantage of the XAML Markup Extensions to help is in this kind of tasks, using a simpler and more intuitive approach.

I have created a RootBindingExtension, which can be used as follows:

<Grid x:Name="LayoutRoot" Background="White">
    <ListBox ItemsSource="{Binding Names}">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <StackPanel Orientation="Horizontal">
                    <TextBlock Text="{Binding}"/>
                    <Button Content="{current:RootBinding Path=ButtonContent}" Command="{current:RootBinding Path=MessageBoxCommand}"/>
                </StackPanel>
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>
</Grid>

The RootBindingExtension uses the Path property to create a Binding that binds to a property of that name in the View’s DataContext.

public class RootBindingExtension : IMarkupExtension<Binding>
{
    public string Path { get; set; }

    public Binding ProvideValue(IServiceProvider serviceProvider)
    {
        IRootObjectProvider rootProvider = (IRootObjectProvider) serviceProvider.GetService(typeof(IRootObjectProvider));

        var view = rootProvider.RootObject;
        var fe = view as FrameworkElement;

        if (fe == null)
        {
            throw new InvalidOperationException("Root element must have data context");
        }

        var binding = new Binding();
        binding.Path = new PropertyPath(this.Path);
        binding.Source = fe.DataContext;

        return binding;
    }
}

You can download the RootBindingExtension and a sample that uses it from here.

Let me know if you have used it.

This version includes all the new features and bug fixes that were included in SP1, an important fix for an issue that occurs when playing live smooth streaming videos and a minor fix in the Composite Stream Manifest generator.

Full descriptions of the issues are provided below in case you have run into them.

Issues Description

Live Smooth Streaming Videos without text tracks fails on playback

When playing a live smooth streaming video without any text tracks, a message is shown explaining that the video can’t be played.
The log has the following related entry: “Exception: Failed to parse manifest: Index was out of range. Must be non-negative and less than the size of the collection.”

First chunk duration are not generated sometimes

In some scenarios, the duration of the first chunk of the video and audio streams is not generated.

The error message when playing the generated CSM is the following: “Caught exception trying to parse main manifest: First audio chunk in clip 1 [start time = X, duration = Y] does not contain clip start position Z]“, where X, Y and Z are values that depend on your clips. For more information on common issues when generating and using CSMs, please check this blog post.

Hopefully, you will find this new release useful.

If you have comments, questions, suggestions or any issue, please visit the MMP Video Editor community site.

Needle is a lightweight dependency injection container. Initially the project came up as something to do on weekends and boring afternoons with practicing goals (TDD, reflection), but after that I started putting more work into it, by adding documentation in code, and basic features that are commonly found in other containers such as Autofac or Unity.

You can download the Nuget package using the following command, which will automatically include a reference to the container’s assembly.

PM> Install-Package NeedleContainer

Some of the features that are part of this release are:

• Constructor Injection
• Property Injection
• Type mapping using lifetime scopes and Ids
• Storing instances using various Ids
• Asynchronous object resolution
• Fluent API
• Support to inject factories using Func<T>
• Support to inject instances for all stored registrations using IEnumerable<T>

After I come back from my holidays, I expect to be adding more functionality to it in my free time (collaborators are welcome, contact me through codeplex), as well as doing a couple of posts on the most relevant features, for instance how the Fluent API works and how to perform asynchronous resolution.

If you try it out, let me know what you think of it. You can use the discussions boards to do so.

To work with MMC, you need the Microsoft.ManagementConsole.dll assembly, which comes as part of the Windows SDK 6.1 for Windows Server 2008. This is important because versions 7.0 and 7.1 do not include this assembly. Additionally,  “MMC is one of the very few extensibility point in the OS that will not support .NET 4. MMC ” (from this thread), which is why MEF went out the door and in came Unity.

The MMC documentation, explains the basics on how to get started, so if you have never coded an MMC plug-in, I recommend you to start there. To summarize things, you are required to inherit from a couple of classes, override some methods, and put some attributes in place to get the ball rolling.  The Hello World Sample goes over this.

Implementation Details

One of the decisions I had to take was there to make the calls so Unity would resolve and inject the necessary objects. This can be challenging, specially because we have no control over when our Views are instantiated. As you can see in the following code, MMC makes us set a ViewType for a particular description, but gives to control over how the view itself is created.

public ConnectionsSnapIn()
{
    ...
    var lvd = new MmcListViewDescription(MmcListViewOptions.ExcludeScopeNodes);
    lvd.DisplayName = "Options";
    lvd.ViewType = typeof(ConnectionListView);
    ...
}

How does the View get a reference to the presenter? I decided to use the Tag property of the SnapIn class to store the container. The View can then access the Tag property, make the necessary cast and resolve the presenter.

public ConnectionsSnapIn()
{
    ConfigureContainer();
    this.Tag = container;
    ...
}

After that, Unity is in the game, so we can resort to constructor injection and normal object resolution. Below is some code from the constructors of the View and Presenter classes.

public class ConnectionListView : MmcListView, IConnectionListView
{

    private readonly IConnectionListPresenter presenter;

    public ConnectionListView()
    {

        var container = this.SnapIn.Tag as IUnityContainer;

        if (container != null)
        {
            this.presenter = container.Resolve<IConnectionListPresenter>();
            this.presenter.View = this;
        }

    }
    ...
}

public class ConnectionListPresenter : IConnectionListPresenter
{

    private readonly IConnectionsService connectionsService;

    public ConnectionListPresenter(IConnectionsService connectionsService)
    {
        this.connectionsService = connectionsService;
    }

    ...
}

Alternative Approaches

Another possible approach I though of could be using a WinForm View  instead of a List View, but having it as a placeholder for the real views we want to show depending on the Node that is clicked. This approach leaves the instantiation of the placeholder form to MMC, but would give us control for the instantiation of the other views. This is just an idea, and I might get deeper into this without getting the expected results.

Getting the Code and Plug-in

You can download the source code from here, and the plug-in (built assembly) from here. To install the plug-in, open the Windows SDK console, cd to the directory where the assemblies are, and run InstallUtil.exe MMCSpike.dll (as shown below).

That’s all for this post. If I get any deeper with the sample or find other interesting approaches I’ll let you know.

I created this sample a couple of months ago, and I thought might be useful for others. Here you can download the sample I put together using the Modularity QS from Prism 4. You can also download the necessary files separately (OOBModuleManager.cs and CachingXapModuleTypeLoader.cs)

The following are the highlights and steps to follow to run the sample:

1. Open the solution is under PrismV4\Quickstarts\Modularity\Silverlight\ModularityWithUnity.
2. Make sure the Web Site project is set as startup project.
3. Open the CachingXapModuleTypeLoader and OOBModuleManager to see how they work. Also check out how the OOBModuleManager is registered in the Bootstrapper’s ConfigureContainer method.
4. Run the application. Load all 6 modules.
5. Install the application (add to Desktop and Start Menu).
6. Close web browser and OOB window.
7. Check in Systray that http://localhost:portX is not running. If it is, stop the site.
8. Open OOB App from desktop.
9. Load modules, they should load correctly.

I hope this is useful for you in case you are required to implement this scenario.



I really recommend downloading this release, as we put a lot of effort in getting out there what we believed would be the most useful content. You can get a set of detailed updates and features in Guido’s blog, but to summarize the main changes are:

1. Updated Modularity, Bootstrapper, Dependency Injection, Communication and UI Composition labs to Prism 4.0.
2. Created new labs for MEF and Navigation.
3. Fixed bugs from first version of the Training Kit.

The reason we “left out” the MVVM training is that Karl Shifflett has released the “In the box” training which does a great job covering MVVM scenarios.

If you have any feedback about the PrismTK, you can use the site’s discussion list, issue tracker or this blog.

We hope that you find it really useful.

The old e-mail client only allowed users to send e-mails using a Hotmail or a Gmail account. Let’s say we our application to support new e-mail providers without having to restart it. When discussing this with Martin Salias, he suggested me to use a FileSystemWatcher, which is the approach I decided to take.

The first thing we need to do is create a FileSystemWatcher instance in the ViewModel’s constructor and have it listen to changes in the directory where the Python modules are obtained from. As we only want to get updates when a python module is updated, we specify that filter as well:  

private void InitializeFileSystemWatcher()
{
    this.fsWatcher = new FileSystemWatcher(PythonModulesPath, "*.py");
    this.fsWatcher.EnableRaisingEvents = true;
    this.fsWatcher.Changed += FileSystemChanged;
}

Now we need to re-load the modules being used by our application once a change in the path specified occurs and update the UI accordingly:

private void FileSystemChanged(object sender, FileSystemEventArgs e)
{
    this.LoadPythonModules();

    //update all bound properties
    this.RaisePropertyChanged(string.Empty);
}

To check how this is working follow these steps:

1. Open the solution provided in the .zip file and run it.
2. Expand the Combobox control to verify that only Gmail and Hotmail are supported.
3. Find the New Modules folder inside the .zip file and copy the emailDispatcher.py module to the WPFClient\bin\Debug\Python Code directory. Replace the existing file.
4. Expand the Combobox control to verify that Yahoo has been added as a provider.
5. (Optional) If you have a yahoo account send an e-mail to test that it works correctly.

Although this sample is quiet simple, I think it is a great way to illustrate the flexibility of having this kind of application.

Dependency Matrix

NDepend’s Dependency Matrix is a really useful asset, which can be used to quickly determine the complexity of a particular application/library. Unlike a graph, which simply shows the connections between the different components, the matrix displays how dependent a component is on others in a simple way.

To view the Dependency Matrix, after enabling NDepend for the solution, one must simply point to the NDepend menu and click Dependency Matrix.

As the figure above depicts, the matrix shows (in this case) how many dependencies there are between an assembly (column) and each of the other ones (rows). Additionally, it does not only show dependencies to assemblies from within the solution, but to .Net Framework assemblies as well. In this case the unit of measure being displayed is members, but it can also show methods, fields, etc.

From the matrix, there are different ways to dig deeper into each of the dependencies. One I find particularly useful (for low amounts) is using a graph.

If the amount is large, you can also zoom in to the particular assembly pair and get a look at the dependencies one by one.

CQL (Code Query Language)

Another great NDepend feature (my favorite so far) is its support for the Code Query Language. Let’s say that for API clean-up purposes I want to find all methods that can be made private, you might use something like the following:

SELECT METHODS WHERE CouldBePrivate 

Which outputs these results:

As you can see there are many methods from assemblies related to Unit Tests. We don’t care about those so we can get rid of them by adding some extra filters to the query:

SELECT METHODS FROM ASSEMBLIES “AlgoHero.Files”,“AlgoHero.Game”,“AlgoHero.Interface”,“AlgoHero.MusicEntities” ,“AlgoHero.Screens”WHERE CouldBePrivate AND ! IsConstructor

We get the desired output which does not include any method from test assemblies. The fact that this query returned 12 results means that some methods have a higher level of exposure than required.

We can access the method directly from the query’s results and update its accessibility.

The best thing about this, is that this query can be added as a CQL rule so every time the solution is built the query will verify this condition:

I believe this level of customization, which can be achieved through some really simple syntax can provide great value to maintain large code bases across development teams with many developers compliant with a set of rules.

You can download the NDepend trial (which does have less features than the Pro version) to give it a try. I know I’ll keep using it.