Simple Injector Scope for specific LifeStyle

Question

Is there a way to define a scope for a specific lifestyle? I am attempting to implement my own scope that I want to persist across an application, but internally I also create another scope, and then a request to GetInstance returns the inner scoped instance instead.

I thought if I could define my lifestyle as:

public class MyScopedLifestyle : ExecutionContextScopeLifestyle
{
    public MyScopedLifestyle(bool disposeInstanceWhenScopeEnds)
        : base("MyScopedLifestyle", disposeInstanceWhenScopeEnds)
    {
    }

    protected override int Length
    {
        get
        {
            return 100;
        }
    }
}

And my usage is:

var container = new Container();
container.Register<IRequestData, RequestData>(new MyScopedLifestyle());

// i had hoped I could say
//   container.BeginExecutionContextScope(MyScopedLifestyle)
// or something similar
// this is controlled by me
using (var scope1 = container.BeginExecutionContextScope())
{
    // do some stuff
    container.GetInstance<IRequestData>().RequestMarket = "en-US";

    // this is done via the webapi execution scope (using simpleinjector dependency resolver)
    using (var scope2 = container.BeginExecutionContextScope())
    {
        Assert.Equal("en-US", container.GetInstance<IRequestData>().RequestMarket); // false
    }
}

But I'm unsure how to utilize my custom lifestyle when creating the inner execution scope.

What I really want to happen, is that my instance of IRequestData used in scope1, is the same instance of IRequestData inside of scope2. Is this something I can achieve with SimpleInjector?

Edit I removed the fact that I'm attempting to create an instance of an object per OWIN request, rather than per WebAPI request. Ideally I'm attempting to create:

container.RegisterOwinRequest<IRequestData, RequestData>();

So that when I resolve IFoo anywhere within my pipeline (be it an OWIN middleware, or in the WebAPI part, the same instance is returned for a particular request).

Edit 2 Swapped our IFoo/Foo/MyProperty for better names.

Answer 1

What you're trying to accomplish with a custom lifestyle is absolutely possible, but might not be that easy, because you will have to store that scope somewhere (probably in the CallContext) and need to create a BeginMyCustomScope method that creates a new scope and have a custom Scope implementation that removes itself from the CallContext when Dispose is called. I think this is too much work and too much complexity.

The problem exists because during the time you want to set the RequestMarket property, there is no Web API request scope started. The way to usually force such scope to be started is to call the GetDependencyScope method on the HttpRequestMessage:

message.GetDependencyScope();

Right after that you can resolve the IRequestData and it works as expected:

container.GetInstance<IRequestData>().RequestMarket = "en-US";

I'm unsure however, whether the HttpRequestMessage is available at that point in time, so if not, I think working with a DelegatingHandler as you expressed in the comments is a good alternative.

In the past, a good way to communicate data across the callstack was using thread-specific variables, but that obviously fails when using async/await models as with Web API and OWIN. So the new way to do this is using the CallContext. So instead of using a DelegatingHandler, you might be able to do something like this:

container.RegisterInitializer<IRequestData>(data =>
    data.RequestMarket = (string)CallContext.LogicalGetData("RequestMarketKey"));

And when the OWIN request starts, you do this:

CallContext.LogicalSetData("RequestMarketKey", "en-US");