When using an Arrow Function, TypeScript automatically assigns this to a separate variable in the outer execution context (called _this), which can be accessed by the function that results of the compilation of the Arrow Function through its closure. As the previous sentence was probably not the simplest one to digest, take the following TypeScript code snippet as an example:

class MyClass {
    constructor() {
    }

    private add(a, b) {
        return a + b;
    }

    public partialAdd(a) {
        return (b) => {
            return this.add(a, b);
        }
    }

    public partialAdd2(a) {
        return function(b) {
            return this.add(a, b);
        }
    }
}

The resulting JavaScript is:

var MyClass = (function () {
    function MyClass() {
    }
    MyClass.prototype.add = function (a, b) {
        return a + b;
    };
    MyClass.prototype.partialAdd = function (a) {
        var _this = this;
        return function (b) {
            return _this.add(a, b);
        }
    };
    MyClass.prototype.partialAdd2 = function (a) {
        return function (b) {
            return this.add(a, b);
        }
    };
    return MyClass;
})();

As you can see, partialAdd stores this in the local _this variable which is accessible from the function that is returned through its closure. On the other hand, partialAdd2 uses this as the variable, but as I mentioned before this might not be “an instance of MyClass” but something completely different instead.

Complex Cases

You could (wrongly) deduce that every time you need access to the outer this inside the function you should use an Arrow Function, but what if you need to use both the outer this and the object on which the function was applied? That could be a usual situation in an event handler, which applies the callback functions to the target DOM elements when handling the event (for the sake of the example assume that there is no way to other way to access the DOM element other than this).

In these cases, it is important to understand what the compiler is doing underneath the hood. The two common approaches that would lead to errors are:

1. Using an Arrow Function: this would cause TypeScript’s this to shadow the compiled JavaScript’s this, not allowing you to access the DOM elements that was clicked inside the click handler.
2. Using a function literal: this would cause the outer this to not be accessible, which is unexpected for developers used to C#.

The Answer

One possible (and simple) solution to this is the usual workaround (that = this):

class MyClass {
    constructor() {
    }

    private add(a, b) {
        return a + b;
    }

    public partialAdd(a) {
        var that = this;
        return function(b) {
            // this is accessible inside the function
            // and points to the object to which the function was applied
            var _this = this;
            // that is accessible inside the function through the closure
            // and points to the object that had partialAdd called
            return that.add(a, b);
        }
    }
}

The following figures show that TypeScript’s type inference system confirms the comments from the previous code snippet:

this can be an instance of any type, as it depends on the object on which the function was called

that is an instance of MyClass

Conclusion

This is not a complex issue, but is one that I’ve seen a couple of times while working with TypeScript, so hopefully if you ever run into it you will be able to solve it in no time.

This approach successfully satisfied our requirements, but it required us to add additional migrations to specify the indexes. Thus, I started to research to see if there where other ways to do this, thinking that there was probably an available data annotation to get this done. To my surprise, I wasn’t able to find such an attribute when searching the web (for example, this is the list of available Data Annotations). Once I realized this, I decided to create the necessary components on my own.

Creating the components

I found a couple of StackOverflow questions (here and here) from where I got some really useful ideas, such as using the ExecuteSqlCommand method introduced in Entity Framework 4.1 and detecting the attributes in a DataBaseInitializer.

The attribute code is really simple. It forces you to define the index name and gives the possibility of specifying whether the index is unique or not.

using System;

[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
public class IndexAttribute : Attribute
{
    public IndexAttribute(string name, bool unique = false)
    {
        this.Name = name;
        this.IsUnique = unique;
    }

    public string Name { get; private set; }

    public bool IsUnique { get; private set; }
}

And the Initializer basically goes through the DbSet<> properties in the DbContext to retrieve the entity table names and check for the Index attribute in the properties in those entities.

using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity;
using System.Linq;
using System.Reflection;

public class IndexInitializer<T> : IDatabaseInitializer<T> where T : DbContext
{
    private const string CreateIndexQueryTemplate = "CREATE {unique} INDEX {indexName} ON {tableName} ({columnName})";

    public void InitializeDatabase(T context)
    {
        const BindingFlags PublicInstance = BindingFlags.Public | BindingFlags.Instance;

        foreach (var dataSetProperty in typeof(T).GetProperties(PublicInstance).Where(
            p => p.PropertyType.Name == typeof(DbSet<>).Name))
        {
            var entityType = dataSetProperty.PropertyType.GetGenericArguments().Single();

            TableAttribute[] tableAttributes = (TableAttribute[])entityType.GetCustomAttributes(typeof(TableAttribute), false);

            foreach (var property in entityType.GetProperties(PublicInstance))
            {
                IndexAttribute[] indexAttributes = (IndexAttribute[])property.GetCustomAttributes(typeof(IndexAttribute), false);
                NotMappedAttribute[] notMappedAttributes = (NotMappedAttribute[])property.GetCustomAttributes(typeof(NotMappedAttribute), false);
                if (indexAttributes.Length > 0 && notMappedAttributes.Length == 0)
                {
                    ColumnAttribute[] columnAttributes = (ColumnAttribute[])property.GetCustomAttributes(typeof(ColumnAttribute), false);

                    foreach (var indexAttribute in indexAttributes)
                    {
                        string indexName = indexAttribute.Name;
                        string tableName = tableAttributes.Length != 0 ? tableAttributes[0].Name : dataSetProperty.Name;
                        string columnName = columnAttributes.Length != 0 ? columnAttributes[0].Name : property.Name;
                        string query = CreateIndexQueryTemplate.Replace("{indexName}", indexName)
                            .Replace("{tableName}", tableName)
                            .Replace("{columnName}", columnName)
                            .Replace("{unique}", indexAttribute.IsUnique ? "UNIQUE" : string.Empty);

                        context.Database.CreateIfNotExists();

                        context.Database.ExecuteSqlCommand(query);
                    }
                }
            }
        }
    }
}

Trying it out

I created a simple console application and ran a couple of tests to see if the data base was correctly created. For example, when using the following entity:

using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

public class Customer
{
    [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public Guid Id { get; set; }

    [Index("NameIndex", unique: true)]
    [MaxLength(128)]
    public string Name { get; set; }
}

The following table is created.

If, for example the Table and Column name are customized:

[Table("Clients")]
public class Customer
{
    [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public Guid Id { get; set; }

    [Index("NameIndex", unique: true)]
    [MaxLength(128)]
    [Column("CustomerName")]
    public string Name { get; set; }
}

We get the following index:

What if I already have an Initializer?

Well, in this case, a simple approach would be to add the IndexInitializer logic to your own Initializer, but that is not the only way to support the IndexAttribute and keep your initialization logic. During the week I also put together a simple CompositeDatabaseInitializer that can be used to separate the logic in different initializers. You could, for instance, have the IndexInitializer and another one to generate data.

using System.Collections.Generic;
using System.Data.Entity;

public class CompositeDatabaseInitializer<T> : IDatabaseInitializer<T> where T : DbContext
{
    private readonly List<IDatabaseInitializer<T>> initializers;

    public CompositeDatabaseInitializer(params IDatabaseInitializer<T>[] databaseInitializers)
    {
        this.initializers = new List<IDatabaseInitializer<T>>();
        this.initializers.AddRange(databaseInitializers);
    }

    public void InitializeDatabase(T context)
    {
        foreach (var databaseInitializer in this.initializers)
        {
            databaseInitializer.InitializeDatabase(context);
        }
    }

    public void AddInitializer(IDatabaseInitializer<T> databaseInitializer)
    {
        this.initializers.Add(databaseInitializer);
    }

    public void RemoveInitializer(IDatabaseInitializer<T> databaseInitializer)
    {
        this.initializers.Remove(databaseInitializer);
    }
}

Wrapping up

There are a lot of improvement opportunities for this implementation (such as adding support for clustered indexes). Nevertheless, features such as support for custom database initializers and the ability to execute SQL statements from the DbContext provide really powerful extensibility capabilities.

I hope that you can either use the code as is or take some useful ideas out of it.

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.