MVC、EF - Unity 中的 DataContext 单例实例 Per-Web-Request

Question

我有一个 MVC 3 Web 应用程序，我在其中使用实体框架进行数据访问。此外，我简单地使用了存储库模式，其中例如所有与产品相关的内容都在“ProductRepository”中处理，所有与用户相关的内容都在“UserRepository”中处理。

因此，我使用 UNITY 容器来创建 DataContext 的单例实例，并将其注入到每个存储库中。在 Google 上快速搜索一下，每个人都建议您不要使用 DataContext 的单例实例，因为它可能会在将来给您带来一些内存泄漏。

因此，受这篇文章的启发，为每个 Web 请求创建一个 DataContext 的单例实例就是答案（如果我错了，请纠正我！）

http://blogs.microsoft.co.il/blogs /gilf/archive/2010/05/18/how-to-manage-objectcontext-per-request-in-asp-net.aspx

但是，UNITY 不支持“Per-web-request”生命周期管理器。但是，可以实现您自己的自定义生命周期管理器，它会为您处理这个问题。实际上，这篇文章对此进行了讨论：

单例每个调用上下文（Web 请求） ）在Unity

问题是，我现在已经实现了上面帖子中描述的自定义生命周期管理器，但我不确定这是否是实现它的方法。我还想知道 datacontext 实例在提供的解决方案中的位置？我错过了什么吗？

实际上有更好的方法来解决我的“问题”吗？

谢谢！

** 添加了有关我的实现的信息 **

以下是来自我的 Global.asax、控制器和存储库的片段。这清楚地展示了我的实施情况。

Global.asax

  var container = new UnityContainer();
            container
                .RegisterType<ProductsRepository>(new ContainerControlledLifetimeManager())
                .RegisterType<CategoryRepository>(new ContainerControlledLifetimeManager())
                .RegisterType<MyEntities>(new PerResolveLifetimeManager(), dbConnectionString)

控制器

private ProductsRepository _productsRepository;
private CategoryRepository _categoryRepository;

public ProductsController(ProductsRepository productsRepository, CategoryRepository categoryRepository)
{
   _productsRepository = productsRepository;
   _categoryRepository = categoryRepository;
}

public ActionResult Index()
{
   ProductCategory category = _categoryRepository.GetProductCategory(categoryId);
   . 
   . 
   . 
}

protected override void Dispose(bool disposing)
{
    base.Dispose(disposing);
    _productsRepository.Dispose();
    _categoryRepository.Dispose();
}

产品存储库

public class ProductsRepository : IDisposable
{

private MyEntities _db;

public ProductsRepository(MyEntities db)
{
    _db = db;
}

public Product GetProduct(Guid productId)
{
    return _db.Product.Where(x => x.ID == productId).FirstOrDefault();
}

public void Dispose()
{
    this._db.Dispose();
}

控制器工厂

public class UnityControllerFactory : DefaultControllerFactory
{
    IUnityContainer _container;

    public UnityControllerFactory(IUnityContainer container)
    {
        _container = container;
    }

    protected override IController GetControllerInstance(RequestContext requestContext, Type controllerType)
    {
        if (controllerType == null)
        {
            throw new HttpException(404, String.Format("The controller for path '{0}' could not be found" +
                "or it does not implement IController.",
                 requestContext.HttpContext.Request.Path));
        }

        return _container.Resolve(controllerType) as IController;
    }

}

添加信息 您好，我将发布我遇到的有关相关问题和解决方案建议的其他链接：

1. https://github。 com/geersch/EntityFrameworkObjectContext
2. http://dotnetslackers.com/articles/ado_net/Managing-Entity-Framework-ObjectContext-lifespan-and-scope-in​​-n-layered-ASP-NET-applications.aspx
3. 将 linq to sql datacontext 附加到 httpcontext业务层
4. http://weblogs.asp.net/shijuvarghese/archive/2008/10/24/asp-net-mvc-tip-dependency-injection-with-unity-application-block。 aspx
5. http://msdn.microsoft.com/en-us /library/bb738470.aspx

Answer 1

从 Unity 3 开始，每个 http 请求已经有一个内置的生命周期管理器。

PerRequestLifetimeManager< /a>

一个 LifetimeManager，在单个 HTTP 请求的生命周期内保留给它的实例。此生命周期管理器使您能够创建注册类型的实例，这些实例在 HTTP 请求范围内的行为类似于单例。请参阅备注以了解重要的使用信息。

MSDN评论

尽管 PerRequestLifetimeManager 生命周期管理器可以正常工作，并且可以帮助处理 HTTP 请求范围内的有状态或线程不安全依赖项，在可以避免的情况下使用它通常不是一个好主意，因为如果使用不当，它通常会导致不良实践或很难在最终用户的应用程序代码中发现错误。

建议您注册的依赖项是无状态的，并且如果需要在 HTTP 请求的生命周期内在多个对象之间共享公共状态，那么您可以使用无状态服务来显式存储和检索此状态当前对象的 Items 集合。

评论说，即使您被迫为每个服务（外观服务）使用单个上下文，您也应该保持服务调用无状态。

顺便说一下，Unity 3 适用于 .NET 4.5。

Answer 2

我相信 NerdDinner：MVC 中的 DI 使用 Unity 来实现其 HttpContextLifetimeManager 应该可以满足您的需求。

Answer 3

我不想不必要地阻止您，并且一定要进行实验，但如果您继续使用 DataContext 的单例实例，请确保您能成功。

它看起来在您的开发环境中工作正常，但可能无法正确关闭连接。如果没有生产环境的负载，这一点将很难看到。在高负载的生产环境中，未处理的连接将导致巨大的内存泄漏，然后高 CPU 尝试分配新内存。

您是否考虑过从每个请求连接模式中获得什么？在请求中打开/关闭一次连接（例如 3-4 次）可以获得多少性能？值得这么麻烦吗？此外，这使得延迟加载失败（在您的视图中读取数据库查询）更容易犯错。

如果这令人沮丧，我很抱歉。如果您确实看到了好处，就去吧。我只是警告你，如果你弄错了，可能会产生严重的适得其反的后果，所以要小心。像 entity profiler 这样的东西对于正确操作来说是非常宝贵的 - 它会告诉你打开和关闭的连接数 - 除其他外非常有用事物。

Answer 4

我前几次看到问题和答案。它是过时的。 Unity.MVC3 的生命周期管理器为 HierarchicalLifetimeManager。

    container.RegisterType<OwnDbContext>(
                "",
                new HierarchicalLifetimeManager(),
                new InjectionConstructor(connectionString)
                );

而且效果很好。

Answer 5

我建议这样解决：
http://forums.asp.net/t/1644386.aspx/1

此致

Answer 6

我通过使用 Castle.DynamicProxy 解决了这个问题。我需要“按需”注入某些依赖项，这意味着它们需要在使用时解决，而不是在“依赖项”构建时解决。

为此，我像这样配置我的容器：

 private void UnityRegister(IUnityContainer container)
 {
    container.RegisterType<HttpContextBase>(new OnDemandInjectionFactory<HttpContextBase>(c => new HttpContextWrapper(HttpContext.Current)));
    container.RegisterType<HttpRequestBase>(new OnDemandInjectionFactory<HttpRequestBase>(c => new HttpRequestWrapper(HttpContext.Current.Request)));
    container.RegisterType<HttpSessionStateBase>(new OnDemandInjectionFactory<HttpSessionStateBase>(c => new HttpSessionStateWrapper(HttpContext.Current.Session)));
    container.RegisterType<HttpServerUtilityBase>(new OnDemandInjectionFactory<HttpServerUtilityBase>(c => new HttpServerUtilityWrapper(HttpContext.Current.Server)));
 }

我的想法是提供一种“按需”检索实例的方法。每当使用实例的任何方法时都会调用 lambda。依赖对象实际上持有对代理对象的引用，而不是对象本身。

OnDemandInjectionFactory：

internal class OnDemandInjectionFactory<T> : InjectionFactory
{
    public OnDemandInjectionFactory(Func<IUnityContainer, T> proxiedObjectFactory) : base((container, type, name) => FactoryFunction(container, type, name, proxiedObjectFactory))
    {
    }

    private static object FactoryFunction(IUnityContainer container, Type type, string name, Func<IUnityContainer, T> proxiedObjectFactory)
    {
        var interceptor = new OnDemandInterceptor<T>(container, proxiedObjectFactory);
        var proxyGenerator = new ProxyGenerator();
        var proxy = proxyGenerator.CreateClassProxy(type, interceptor);
        return proxy;
    }
}

OnDemandInterceptor：

internal class OnDemandInterceptor<T> : IInterceptor
{
    private readonly Func<IUnityContainer, T> _proxiedInstanceFactory;
    private readonly IUnityContainer _container;

    public OnDemandInterceptor(IUnityContainer container, Func<IUnityContainer, T> proxiedInstanceFactory)
    {
        _proxiedInstanceFactory = proxiedInstanceFactory;
        _container = container;
    }

    public void Intercept(IInvocation invocation)
    {
        var proxiedInstance = _proxiedInstanceFactory.Invoke(_container);

        var types = invocation.Arguments.Select(arg => arg.GetType()).ToArray();

        var method = typeof(T).GetMethod(invocation.Method.Name, types);

        invocation.ReturnValue = method.Invoke(proxiedInstance, invocation.Arguments);
    }
}

Answer 7

在Unity3中，如果要使用

PerRequestLifetimeManager

需要注册UnityPerRequestHttpModule

我是使用WebActivatorEx来实现的，代码如下：

using System.Linq;
using System.Web.Mvc;
using Microsoft.Practices.Unity.Mvc;
using MyNamespace;

[assembly: WebActivatorEx.PreApplicationStartMethod(typeof(UnityWebActivator), "Start")]
[assembly: WebActivatorEx.ApplicationShutdownMethod(typeof(UnityWebActivator), "Shutdown")]

namespace MyNamespace
{
    /// <summary>Provides the bootstrapping for integrating Unity with ASP.NET MVC.</summary>
    public static class UnityWebActivator
    {
        /// <summary>Integrates Unity when the application starts.</summary>
        public static void Start() 
        {
            var container = UnityConfig.GetConfiguredContainer();

            FilterProviders.Providers.Remove(FilterProviders.Providers.OfType<FilterAttributeFilterProvider>().First());
            FilterProviders.Providers.Add(new UnityFilterAttributeFilterProvider(container));

            DependencyResolver.SetResolver(new UnityDependencyResolver(container));

            // TODO: Uncomment if you want to use PerRequestLifetimeManager
            Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));
        }

        /// <summary>Disposes the Unity container when the application is shut down.</summary>
        public static void Shutdown()
        {
            var container = UnityConfig.GetConfiguredContainer();
            container.Dispose();
        }
    }
}

Answer 8

PerRequestLifetimeManager 和 UnityPerRequestHttpModule 类位于 Unity.Mvc 包，它依赖于 ASP.NET MVC。如果您不想拥有这种依赖关系（例如您正在使用 Web API），则必须将它们复制粘贴到您的应用程序中。

如果您这样做，请不要忘记注册 HttpModule。

Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));

编辑：
在 CodePlex 关闭之前，我将在此处包含这些类：

// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web;
using Microsoft.Practices.Unity.Mvc.Properties;
using Microsoft.Practices.Unity.Utility;

namespace Microsoft.Practices.Unity.Mvc
{
    /// <summary>
    /// Implementation of the <see cref="IHttpModule"/> interface that provides support for using the
    /// <see cref="PerRequestLifetimeManager"/> lifetime manager, and enables it to
    /// dispose the instances after the HTTP request ends.
    /// </summary>
    public class UnityPerRequestHttpModule : IHttpModule
    {
        private static readonly object ModuleKey = new object();

        internal static object GetValue(object lifetimeManagerKey)
        {
            var dict = GetDictionary(HttpContext.Current);

            if (dict != null)
            {
                object obj = null;

                if (dict.TryGetValue(lifetimeManagerKey, out obj))
                {
                    return obj;
                }
            }

            return null;
        }

        internal static void SetValue(object lifetimeManagerKey, object value)
        {
            var dict = GetDictionary(HttpContext.Current);

            if (dict == null)
            {
                dict = new Dictionary<object, object>();

                HttpContext.Current.Items[ModuleKey] = dict;
            }

            dict[lifetimeManagerKey] = value;
        }

        /// <summary>
        /// Disposes the resources used by this module.
        /// </summary>
        public void Dispose()
        {
        }

        /// <summary>
        /// Initializes a module and prepares it to handle requests.
        /// </summary>
        /// <param name="context">An <see cref="HttpApplication"/> that provides access to the methods, properties,
        /// and events common to all application objects within an ASP.NET application.</param>
        [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "Validated with Guard class")]
        public void Init(HttpApplication context)
        {
            Guard.ArgumentNotNull(context, "context");
            context.EndRequest += OnEndRequest;
        }

        private void OnEndRequest(object sender, EventArgs e)
        {
            var app = (HttpApplication)sender;

            var dict = GetDictionary(app.Context);

            if (dict != null)
            {
                foreach (var disposable in dict.Values.OfType<IDisposable>())
                {
                    disposable.Dispose();
                }
            }
        }

        private static Dictionary<object, object> GetDictionary(HttpContext context)
        {
            if (context == null)
            {
                throw new InvalidOperationException(Resources.ErrorHttpContextNotAvailable);
            }

            var dict = (Dictionary<object, object>)context.Items[ModuleKey];

            return dict;
        }
    }
}

---

// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.

using System;
using Microsoft.Practices.Unity.Mvc;

namespace Microsoft.Practices.Unity
{
    /// <summary>
    /// A <see cref="LifetimeManager"/> that holds onto the instance given to it during
    /// the lifetime of a single HTTP request.
    /// This lifetime manager enables you to create instances of registered types that behave like
    /// singletons within the scope of an HTTP request.
    /// See remarks for important usage information.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Although the <see cref="PerRequestLifetimeManager"/> lifetime manager works correctly and can help
    /// in working with stateful or thread-unsafe dependencies within the scope of an HTTP request, it is
    /// generally not a good idea to use it when it can be avoided, as it can often lead to bad practices or
    /// hard to find bugs in the end-user's application code when used incorrectly. 
    /// It is recommended that the dependencies you register are stateless and if there is a need to share
    /// common state between several objects during the lifetime of an HTTP request, then you can
    /// have a stateless service that explicitly stores and retrieves this state using the
    /// <see cref="System.Web.HttpContext.Items"/> collection of the <see cref="System.Web.HttpContext.Current"/> object.
    /// </para>
    /// <para>
    /// For the instance of the registered type to be disposed automatically when the HTTP request completes,
    /// make sure to register the <see cref="UnityPerRequestHttpModule"/> with the web application.
    /// To do this, invoke the following in the Unity bootstrapping class (typically UnityMvcActivator.cs):
    /// <code>DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));</code>
    /// </para>
    /// </remarks>
    public class PerRequestLifetimeManager : LifetimeManager
    {
        private readonly object lifetimeKey = new object();

        /// <summary>
        /// Retrieves a value from the backing store associated with this lifetime policy.
        /// </summary>
        /// <returns>The desired object, or null if no such object is currently stored.</returns>
        public override object GetValue()
        {
            return UnityPerRequestHttpModule.GetValue(this.lifetimeKey);
        }

        /// <summary>
        /// Stores the given value into the backing store for retrieval later.
        /// </summary>
        /// <param name="newValue">The object being stored.</param>
        public override void SetValue(object newValue)
        {
            UnityPerRequestHttpModule.SetValue(this.lifetimeKey, newValue);
        }

        /// <summary>
        /// Removes the given object from the backing store.
        /// </summary>
        public override void RemoveValue()
        {
            var disposable = this.GetValue() as IDisposable;

            if (disposable != null)
            {
                disposable.Dispose();
            }

            UnityPerRequestHttpModule.SetValue(this.lifetimeKey, null);
        }
    }
}

Answer 9

是的不共享上下文并为每个请求使用一个上下文。您还可以检查该帖子中的链接问题，以查看共享上下文引起的所有问题。

现在谈谈Unity。 PerCallContextLifetimeManager 的想法是可行的，但我认为提供的实现不适用于多个对象。您应该直接使用 PerHttpRequestLifetimeManager：

public class PerHttpRequestLifetime : LifetimeManager
{
    // This is very important part and the reason why I believe mentioned
    // PerCallContext implementation is wrong.
    private readonly Guid _key = Guid.NewGuid();

    public override object GetValue()
    {
        return HttpContext.Current.Items[_key];
    }

    public override void SetValue(object newValue)
    {
        HttpContext.Current.Items[_key] = newValue;
    }

    public override void RemoveValue()
    {
        var obj = GetValue();
        HttpContext.Current.Items.Remove(obj);
    }
}

请注意，Unity 不会为您处理上下文。另请注意，默认的 UnityContainer 实现永远不会调用 RemoveValue 方法。

如果您的实现在单个 Resolve 调用中解析所有存储库（例如，如果您的控制器在构造函数中接收存储库的实例并且您正在解析控制器），则不需要此生命周期管理器。在这种情况下，请使用内置 (Unity 2.0) PerResolveLifetimeManager。

编辑：

我在您提供的UnityContainer配置中发现了相当大的问题。您正在使用 ContainerControllerLifetimeManager 注册这两个存储库。这个生命周期管理器意味着每个容器生命周期的单例实例。这意味着两个存储库只会实例化一次，并且实例将被存储并重用于后续调用。因此，您为 MyEntities 分配的生命周期并不重要。它被注入到存储库的构造函数中，该构造函数仅被调用一次。两个存储库仍将使用在构建过程中创建的 MyEntities 的单个实例 = 它们将在您的 AppDomain 的整个生命周期中使用单个实例。这是你能实现的最糟糕的情况。

以这种方式重写您的配置：

var container = new UnityContainer();
container
  .RegisterType<ProductsRepository>()
  .RegisterType<CategoryRepository>()
  .RegisterType<MyEntities>(new PerResolveLifetimeManager(), dbConnectionString);

为什么这就足够了？您正在解析依赖于存储库的控制器，但不需要多次存储库实例，因此您可以使用默认的 TransientLifetimeManager ，它将为每个调用创建新实例。由于调用了存储库构造函数，并且必须解析 MyEntities 实例。但您知道多个存储库可能需要此实例，因此您将使用 PerResolveLifetimeManager => 设置它控制器的每次解析只会生成一个 MyEntities 实例。