如何使用城堡温莎在诸如PerWebRequest之类的范围内的生活方式中注册服务？

Question

I am working on self-hosted web api using OWIN and I need to register a service per scope lifestyle using Castle Windsor.

I know that using HttpContext I can achieve that using PerWebRequest or HybridPerWebRequestPerThread lifestyle but in my case I don't have HttpContext.

I have created the following owin middleware which will be the first and the last middleware will be executed during the request :

public class SetupMiddleware : OwinMiddleware
{

    public SetupMiddleware(OwinMiddleware next) : base(next)
    {
        if (next == null)
        {
            throw new ArgumentNullException("next");
        }
    }


    public override async Task Invoke(IOwinContext context)
    {
        IDisposable scope = null;
        try
        {
           //here I am starting new scope
            var container= IoCResolverFactory.GetContainer();
            scope = container.BeginScope();

            await Next.Invoke(context);

        }
        catch (Exception ex)
        {
        }
        finally
        {
            //here I am disposing it
            scope?.Dispose();
        }
    }

And when I Startup my application I register my service inside the IoC container as following:

container.BeginScope();
container.Register(Component.For<ICurrentRequestService>().ImplementedBy<CurrentRequestService>().LifestyleScoped());

The problem when I resolve instance of CurrentRequestService, it does not work as per scope which owin middleware will begin it when a new request comes and dispose it when it finishes.

Could you please guide me to how can I register services per scope to behave like PerWebRequest in my application?

Answer 1

There may be many scopes.

To use the scope that is controlled by SetupMiddleware you need to resolve ICurrentRequestService service somewhere deeper than SetupMiddleware during request processing (eg in controller action).

Thus, SetupMiddleware will create the scope, then in controller action ICurrentRequestService will be resolved inside that scope, finally SetupMiddleware will dispose ICurrentRequestService by calling scope.Dispose() .

As I understand, currently you have something like this:

// when application starts. Executes once
container.BeginScope(); // the 1st (application) scope beginning. 
container.Register(Component.For<ICurrentRequestService>().ImplementedBy<CurrentRequestService>().LifestyleScoped());
var service = IoCResolverFactory.GetContainer().Resolve<ICurrentRequestService>();

//in SetupMiddleware. This code executes on every web request
    var container = IoCResolverFactory.GetContainer(); 
    scope = container.BeginScope(); // the request scope beginning

    // here others middlewares 
    // here you can resolve ICurrentRequestService to use the request scope

    scope?.Dispose(); // the request scope end

Thus, service uses the application scope instead of the request scope.

Answer 2

As I expected that I should define a custom scope to be started and dispose within a middleware .

I have created the following custom scope accessor:

public class OwinWebRequestScopeAccessor : IScopeAccessor
{
    void IDisposable.Dispose() { }

    ILifetimeScope IScopeAccessor.GetScope(CreationContext context)
    {
        IOwinContext owinContext = HttpContext.Current.GetOwinContext();
        string key = SetupMiddleware.EnvironmentKey;
        return owinContext.Environment[key] as ILifetimeScope;
    }
}

Then I have modified my SetupMiddleware as followings:

public class SetupMiddleware : OwinMiddleware
{
    public const string EnvironmentKey = "WindsorOwinScope";

    public SetupMiddleware(OwinMiddleware next) : base(next)
    {
        if (next == null)
        {
            throw new ArgumentNullException("next");
        }
    }


    public override async Task Invoke(IOwinContext context)
    {

        ILifetimeScope lifetimeScope = new DefaultLifetimeScope();

        try
        {
            context.Environment[EnvironmentKey] = lifetimeScope;

            await Next.Invoke(context);
        }
        catch (Exception ex)
        {
        }
        finally
        {
            context.Environment.Remove(EnvironmentKey);
            lifetimeScope.Dispose();
        }
    }
}

Then I registered my service using the above scope :

container.Register(Component.For<ICurrentRequestService>().ImplementedBy<CurrentRequestService>().LifestyleScoped<OwinWebRequestScopeAccessor>());

PS:

SetupMiddleware should be the first middleware in the owin pipeline.

I hope my code will help others.