如何在OWIN中使用Castle Windsor的PerWebRequest生命周期

Question

我正在将一个已有的ASP .Net Web API 2项目转换为使用OWIN。该项目使用Castle Windsor作为依赖注入框架，其中一个依赖项设置为使用PerWebRequest生命周期。

当我向服务器发出请求时，我会收到一个Castle.MicroKernel.ComponentResolutionException异常。该异常建议在配置文件的system.web/httpModules和system.WebServer/modules部分中添加以下内容：

<add name="PerRequestLifestyle"
     type="Castle.MicroKernel.Lifestyle.PerWebRequestLifestyleModule, Castle.Windsor" />

这并不能解决错误。

受SimpleInjector的OWIN集成示例的启发，我尝试在OWIN启动类中设置范围（以及更新依赖项的生命周期），使用以下方式：

appBuilder.User(async (context, next) =>
{
    using (config.DependencyResolver.BeginScope()){
    {
        await next();
    }
}

很不幸，这也没有起作用。

我该如何使用Castle Windsor的PerWebRequest生命周期或在OWIN中模拟它？

- Talon

Answer 1

根据Castle Windsor文档，您可以实现自己的自定义范围，需要实现Castle.MicroKernel.Lifestyle.Scoped.IScopeAccessor接口。然后在注册组件时指定您的范围访问器。

Container.Register(Component.For<MyScopedComponent>().LifestyleScoped<OwinWebRequestScopeAccessor >());

类OwinWebRequestScopeAccessor实现了Castle.Windsor的IScopeAccessor接口：

using Castle.MicroKernel.Context;
using Castle.MicroKernel.Lifestyle.Scoped;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Web.Api.Host
{
    public class OwinWebRequestScopeAccessor : IScopeAccessor
    {
        public void Dispose()
        {
            var scope = PerWebRequestLifestyleOwinMiddleware.YieldScope();
            if (scope != null)
            {
                scope.Dispose();
            }
        }

        public ILifetimeScope GetScope(CreationContext context)
        {
            return PerWebRequestLifestyleOwinMiddleware.GetScope();
        }
    }
}

正如您所看到的，OwinWebRequestScopeAccessor将调用委托给PerWebRequestLifestyleOwinMiddleware的GetScope和Dispose方法。

PerWebRequestLifestyleOwinMiddleware类是Castle Windsor ASP.NET IHttpModule PerWebRequestLifestyleModule的OWIN对应项。

这是PerWebRequestLifestyleOwinMiddleware类：

using Castle.MicroKernel;
using Castle.MicroKernel.Lifestyle.Scoped;
using Owin;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Web.Api.Host
{
    using AppFunc = Func<System.Collections.Generic.IDictionary<string, object>, System.Threading.Tasks.Task>;

    public class PerWebRequestLifestyleOwinMiddleware
    {
        private readonly AppFunc _next;
        private const string c_key = "castle.per-web-request-lifestyle-cache";
        private static bool _initialized;

        public PerWebRequestLifestyleOwinMiddleware(AppFunc next)
        {
            _next = next;
        }

        public async Task Invoke(IDictionary<string, object> environment)
        {
            var requestContext = OwinRequestScopeContext.Current;
            _initialized = true;

            try
            {
                await _next(environment);
            }
            finally
            {
                var scope = GetScope(requestContext, createIfNotPresent: false);
                if (scope != null)
                {
                    scope.Dispose();
                }
                requestContext.EndRequest();
            }
        }

        internal static ILifetimeScope GetScope()
        {
            EnsureInitialized();
            var context = OwinRequestScopeContext.Current;
            if (context == null)
            {
                throw new InvalidOperationException(typeof(OwinRequestScopeContext).FullName +".Current is null. " +
                    typeof(PerWebRequestLifestyleOwinMiddleware).FullName +" can only be used with OWIN.");
            }
            return GetScope(context, createIfNotPresent: true);
        }

        /// <summary>
        /// Returns current request's scope and detaches it from the request 
        /// context. Does not throw if scope or context not present. To be 
        /// used for disposing of the context.
        /// </summary>
        /// <returns></returns>
        internal static ILifetimeScope YieldScope()
        {
            var context = OwinRequestScopeContext.Current;
            if (context == null)
            {
                return null;
            }
            var scope = GetScope(context, createIfNotPresent: false);
            if (scope != null)
            {
                context.Items.Remove(c_key);
            }
            return scope;
        }

        private static void EnsureInitialized()
        {
            if (_initialized)
            {
                return;
            }
            throw new ComponentResolutionException("Looks like you forgot to register the OWIN middleware " + typeof(PerWebRequestLifestyleOwinMiddleware).FullName);
        }

        private static ILifetimeScope GetScope(IOwinRequestScopeContext context, bool createIfNotPresent)
        {
            ILifetimeScope candidates = null;
            if (context.Items.ContainsKey(c_key))
            {
                candidates = (ILifetimeScope)context.Items[c_key];
            }
            else if (createIfNotPresent)
            {
                candidates = new DefaultLifetimeScope(new ScopeCache());
                context.Items[c_key] = candidates;
            }
            return candidates;
        }
    }

    public static class AppBuilderPerWebRequestLifestyleOwinMiddlewareExtensions
    {
        /// <summary>
        /// Use <see cref="PerWebRequestLifestyleOwinMiddleware"/>.
        /// </summary>
        /// <param name="app">Owin app.</param>
        /// <returns></returns>
        public static IAppBuilder UsePerWebRequestLifestyleOwinMiddleware(this IAppBuilder app)
        {
            return app.Use(typeof(PerWebRequestLifestyleOwinMiddleware));
        }
    }
}

Castle Windsor的ASP.NET IHttpModule PerWebRequestLifestyleModule 使用HttpContext.Current 在每个web请求上存储Castle Windsor ILifetimeScope。而PerWebRequestLifestyleOwinMiddleware类使用OwinRequestScopeContext.Current。这是基于Yoshifumi Kawai的想法。

下面的OwinRequestScopeContext实现是我对Yoshifumi Kawai原始OwinRequestScopeContext的轻量级实现。

---

注意：如果您不想使用这个轻量级实现，可以通过在NuGet包管理器控制台中运行以下命令来使用Yoshifumi Kawai优秀的原始实现：

PM> Install-Package OwinRequestScopeContext

---

OwinRequestScopeContext的轻量级实现：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Text;
using System.Threading.Tasks;

namespace Web.Api.Host
{
    public interface IOwinRequestScopeContext
    {
        IDictionary<string, object> Items { get; }
        DateTime Timestamp { get; }
        void EndRequest();
    }

    public class OwinRequestScopeContext : IOwinRequestScopeContext
    {
        const string c_callContextKey = "owin.reqscopecontext";
        private readonly DateTime _utcTimestamp = DateTime.UtcNow;
        private ConcurrentDictionary<string, object> _items = new ConcurrentDictionary<string, object>();

        /// <summary>
        /// Gets or sets the <see cref="IOwinRequestScopeContext"/> object 
        /// for the current HTTP request.
        /// </summary>
        public static IOwinRequestScopeContext Current
        {
            get
            {
                var requestContext = CallContext.LogicalGetData(c_callContextKey) as IOwinRequestScopeContext;
                if (requestContext == null)
                {
                    requestContext = new OwinRequestScopeContext();
                    CallContext.LogicalSetData(c_callContextKey, requestContext);
                }
                return requestContext;
            }
            set
            {
                CallContext.LogicalSetData(c_callContextKey, value);
            }
        }

        public void EndRequest()
        {
            CallContext.FreeNamedDataSlot(c_callContextKey);
        }

        public IDictionary<string, object> Items
        {
            get
            {
                return _items;
            }
        }

        public DateTime Timestamp
        {
            get
            {
                return _utcTimestamp.ToLocalTime();
            }
        }
    }
}

在所有准备工作就绪后，您可以开始整理好各项内容。在您的OWIN启动类中调用appBuilder.UsePerWebRequestLifestyleOwinMiddleware();扩展方法来注册上述定义的OWIN中间件。请在appBuilder.UseWebApi(config);之前完成此步骤:

using Owin;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using System.Diagnostics;
using Castle.Windsor;
using System.Web.Http.Dispatcher;
using System.Web.Http.Tracing;

namespace Web.Api.Host
{
    class Startup
    {
        private readonly IWindsorContainer _container;

        public Startup()
        {
            _container = new WindsorContainer().Install(new WindsorInstaller());
        }

        public void Configuration(IAppBuilder appBuilder)
        {
            var properties = new Microsoft.Owin.BuilderProperties.AppProperties(appBuilder.Properties);
            var token = properties.OnAppDisposing;
            if (token != System.Threading.CancellationToken.None)
            {
                token.Register(Close);
            }

            appBuilder.UsePerWebRequestLifestyleOwinMiddleware();

            //
            // Configure Web API for self-host. 
            //
            HttpConfiguration config = new HttpConfiguration();
            WebApiConfig.Register(config);
            appBuilder.UseWebApi(config);
        }

        public void Close()
        {
            if (_container != null)
                _container.Dispose();
        }
    }
}

样例的WindsorInstaller类展示了如何使用OWIN每个Web请求范围：

using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Web.Api.Host
{
    class WindsorInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(Component
                .For<IPerWebRequestDependency>()
                .ImplementedBy<PerWebRequestDependency>()
                .LifestyleScoped<OwinWebRequestScopeAccessor>());

            container.Register(Component
                .For<Controllers.V1.TestController>()
                .LifeStyle.Transient);
        }
    }
}

我所提出的解决方案基于现有的/src/Castle.Windsor/MicroKernel/Lifestyle/PerWebRequestLifestyleModule.cs和Yoshifumi Kawai原始的OwinRequestScopeContext。

- Johan Boonstra

---

有意思 - 我看到这个代码将OwinRequestScopeContext存储在 System.Runtime.Remoting.Messaging.CallContext中。我的第一个想法是将其存储在Owin环境字典 (OwinContext.Environment)中。 - Andrew Shepherd

经过进一步的检查，我认为我可以看到一个原因：System.Runtime.Remoting.Messaging.CallContext具有全局可访问的静态成员，但是没有安全的方式来静态获取OwinContext。 - Andrew Shepherd

Answer 2

我尝试实现Johan Boonstra 的答案，但是发现在ASP.NET MVC控制器方法中它不起作用。

这里有一个更简单的解决方案：

首先，创建一些Owin中间件，这些中间件位于管道的开始位置，并创建一个DefaultLifetimeScope

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

    public WebRequestLifestyleMiddleware(OwinMiddleware next) : base(next)
    {
    }

    public override async Task Invoke(IOwinContext context)
    {
        ILifetimeScope lifetimeScope = new DefaultLifetimeScope();
        context.Environment[EnvironmentKey] = lifetimeScope;
        try
        {
            await this.Next.Invoke(context);
        }
        finally
        {
            context.Environment.Remove(EnvironmentKey);
            lifetimeScope.Dispose();
        }
    }
}

在启动配置文件的管道开头插入它：

public void Configure(IAppBuilder appBuilder)
{
    appBuilder.Use<WebRequestLifestyleMiddleware>();

    //
    // Further configuration
    //
}

现在，您需要创建一个实现IScopeAccessor接口的类，并获取WebRequestLifestyleMiddleware推入环境中的范围：

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

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

最后，在注册组件生命周期时，请使用此作用域访问器。例如，我有一个名为AccessCodeProvider的自定义组件，我想在一次请求中重复使用它：

container.Register(
      Component.For<AccessCodeProvider>()
               .LifestyleScoped<OwinRequestScopeAccessor>()
);

在这种情况下，AccessCodeProvider 将在首次请求时创建，并在整个 Web 请求过程中重复使用，最后在 WebRequestLifestyleMiddleware 调用 lifetimeScope.Dispose() 时被处理。

- Andrew Shepherd

---

我觉得这个对我很有帮助，但是我的情况是使用自己托管的，并且HttpContext.Current对我没用......相反，我使用了OwinRequestScopeContext nuget包(https://github.com/neuecc/OwinRequestScopeContext/)，然后我只需要修改一行代码来获取OwinContext:`IOwinContext owinContext = new Microsoft.Owin.OwinContext(OwinRequestScopeContext.Current.Environment);` 就可以了。 - GPW

对我来说工作得很好，除了我遇到了线程问题。由于这是一个多线程环境，应该将DefaultLifetimeScope替换为ThreadSafeDefaultLifetimeScope。 - Jony Adamit

Answer 3

我已经创建了一个名为PerScope的生命周期，它在使用owin中间件和castle windsor作为应用程序的IoC的Web API应用程序中的表现类似于PerWebRequest。

首先，让我们将我们的windsor容器作为Web API应用程序的IoC，如下所示：

    public class WindsorHttpDependencyResolver : IDependencyResolver
    {
        private readonly IWindsorContainer container;

        public WindsorHttpDependencyResolver(IWindsorContainer container)
        {
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }
            this.container = container;
        }

        public object GetService(Type t)
        {
            return this.container.Kernel.HasComponent(t)
             ? this.container.Resolve(t) : null;
        }

        public IEnumerable<object> GetServices(Type t)
        {
            return this.container.ResolveAll(t).Cast<object>().ToArray();
        }

        public IDependencyScope BeginScope()
        {
            return new WindsorDependencyScope(this.container);
        }

        public void Dispose()
        {
        }
    }//end WindsorHttpDependencyResolver 

  public class WindsorDependencyScope : IDependencyScope
    {
        private readonly IWindsorContainer container;
        private readonly IDisposable scope;

        public WindsorDependencyScope(IWindsorContainer container)
        {
            if (container == null)
                throw new ArgumentNullException("container");

            this.container = container;
        }

        public object GetService(Type t)
        {
            return this.container.Kernel.HasComponent(t)
                ? this.container.Resolve(t) : null;
        }

        public IEnumerable<object> GetServices(Type t)
        {
            return this.container.ResolveAll(t).Cast<object>().ToArray();
        }

        public void Dispose()
        {
            this.scope?.Dispose();
        }
    }

然后在应用程序启动期间，让我们注册它:

container.Register(Component.For<System.Web.Http.Dependencies.IDependencyResolver>().ImplementedBy<WindsorHttpDependencyResolver>().LifestyleSingleton());

现在，在第一个中间件（它将是第一个和最后一个执行的中间件）内，让我们在Web API收到新请求时开始作用域，并在请求结束时进行处理，如下所示：

public class StartinMiddleware : OwinMiddleware
{

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


    public override async Task Invoke(IOwinContext context)
    {

        this.Log().Info("Begin request");
        IDisposable scope = null;            
        try
        {
            // here we are using IoCResolverFactory which returns 
            // the instance of IoC container(which will be singleton for the 
            // whole application)
            var ioCResolver= IoCResolverFactory.GetOrCreate();
            //here we are starting new scope
            scope = ioCResolver.BeginScope();

            await Next.Invoke(context);

            this.Log().Info("End request");
        }
        catch (Exception ex)
        { 
          //here you can log exceptions
        }
        finally
        {
            //here we are desposing scope
            scope?.Dispose();
        }
    }
}

IoC工厂的代码将类似于以下内容：

public static class IoCResolverFactory
{
    public static IoCResolver iocResolver;

    public static IoCResolver GetOrCreate()
    {
        if (iocResolver != null)
            return iocResolver;

        iocResolver = new IoCResolver();
        return iocResolver;
    }
}// end IoCResolverFactory

public class IoCResolver
{
    private static WindsorContainer container;

    public IoCResolver()
    {
        container = new WindsorContainer();

        container.Register(Component.For<IoCResolver>().Instance(this).LifestyleSingleton());
        container.Register(Component.For<IWindsorContainer>().Instance(container).LifestyleSingleton());
    }


    public IDisposable BeginScope()
    {
        return container.BeginScope();
    }


    public IDisposable GetCurrentScope()
    {
        return Castle.MicroKernel.Lifestyle.Scoped.CallContextLifetimeScope.ObtainCurrentScope();
    }


    public T Resolve<T>()
    {
        return container.Resolve<T>();
    }

    public IList<T> ResolveAll<T>()
    {
        return container.ResolveAll<T>();
    }

    public void Dispose()
    {
        container.Dispose();
    }
}

在启动时注册您的服务时，您可以按以下方式将它们注册为每个范围解析：

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

- Simple Code