How to Implement Castle Windsor IScopeAccessor to provide NHibernate Session Per ViewModel using LifestyleScoped

Question

I am looking for some help creating an implementation of IScopeAccessor, or finding a new solution, that will allow me to provide an NHibernate session per ViewModel.

I know that Windsor now supports scoped lifestyles as seen (here). However the example creates the special scope with a using block and calling container.resolve within the using.

    _container.Register(Component.For<A>().LifestyleScoped());

    using (_container.BeginScope())
    {
        var a1 = _container.Resolve<A>();
        var a2 = _container.Resolve<A>();
        Assert.AreSame(a1, a2);
    }

I can't think of a way to make this work because I don't want to pass around the container and I want the scope to be tied to the ViewModel that gets created, which will happen dynamically as they are needed.

As an alternative it looks like I can create an implementation of IScopeAccessor which, according to Krzysztof Koźmic (here) would allow me to

"... provide any scope you like. Scope is an abstract term here and it can be anything."

Unfortunately I cannot find an implementation of IScopeAccessor that isn't specific to a web based scenario and I am struggling to understand exactly what I need to do to turn "anything" into a valid scope.

I have found an example of exactly what I want to do using Ninject (http://www.emidee.net/index.php/2010/08/23/ninject-use-one-database-session-per-view-model/):

Bind<ISession>().ToMethod(ctx =>
{
    var session = ctx.Kernel.Get<....>().BuildSessionFactory().OpenSession();
    return session;
})
.InScope(context =>
{ 
    var request = context.Request;

    if (typeof(IViewModel).IsAssignableFrom(request.Service))
        return request; 

    while ((request = request.ParentRequest) != null)
        if (typeof(IViewModel).IsAssignableFrom(request.Service))
            return request;

    return new object(); 
});

In Ninject, the InScope indicates that any instances created by the binding should be reused as long as the object returned by the call back remains alive. Essentially, this call back returns the root level ViewModel (since ViewModels can be nested).

Any thoughts on how I can do the same thing or get the same result using Windsor?

have you found a solution for this issue ? I have a similar question : http://stackoverflow.com/questions/25064516/dependency-injection-lifestyle-service-shared-instance-between-2-coupled-insta — eran otzap, Aug 03 '14 at 17:19

Andreas H. · Answer 1 · 2013-01-02T08:47:03.130

The problem seems to be the place of creation. If it's all about dependencies of viewmodels being constructed, you could maybe use boud lifestyle, as described in What's new... Or you could alternatively use your own scope accessor, that is sensitive to viewmodels. for example like this:

public class ViewModelScopeAccessor : IScopeAccessor
{
    private IDictionary<Guid, ILifetimeScope> scopes = new Dictionary<Guid, ILifetimeScope>();
    private ILifetimeScope defaultScope;

    public ViewModelScopeAccessor()
        : this(new DefaultLifetimeScope())
    { }

    public ViewModelScopeAccessor(ILifetimeScope defaultScope)
    {
        this.defaultScope = defaultScope;
    }

    public ILifetimeScope GetScope(CreationContext context)
    {
        var creator = context.Handler.ComponentModel.Implementation;
        var viewModel = creator as IViewModel;
        if (viewModel != null)
        {
            ILifetimeScope scope;
            if (!scopes.TryGetValue(viewModel.UID, out scope))
            {
                scope = new DefaultLifetimeScope();
                scopes[viewModel.UID] = scope;
            }

            return scope;
        }
        else
        {
            return defaultScope;
        }
    }

    public void Dispose()
    {
        foreach (var scope in scopes)
        {
            scope.Value.Dispose();
        }

        defaultScope.Dispose();
        scopes.Clear();
    }
}

for the following viewmodel interface :

public interface IViewModel
{
    string DisplayName { get; }

    Guid UID { get; }
}

You of course could compare the viewmodels in other ways, it's just an example.

The drawback of both, the bound lifestyle and that scope accessor, is, that it won't work, if you use a typed factory inside your viewmodel, to lazily construct objects, since the scope accessor has no idea, from which object/method its factory method was called. But I think is is a general .NET issue, since a method does actually never know, from where it has been called.

So, you could then use your own factories, that produce only one instance per factory instance and make them scoped to your viewmodels too.

Hope this helps.

creator is of type System.Reflection.MemberInfo how could it implement IViewModel ? — eran otzap, Aug 03 '14 at 17:56

How to Implement Castle Windsor IScopeAccessor to provide NHibernate Session Per ViewModel using LifestyleScoped

1 Answers1