MVC, EF-DataContext instance unique Per-Web-Request in Unity

à partir de Unity 3, Il y a déjà un gestionnaire lifetime intégré par requête http.

PerRequestLifetimeManager

un LifetimeManager qui s'accroche à l'instance qui lui est donnée pendant la durée de vie d'une seule requête HTTP. Ce gestionnaire lifetime vous permet de créer des instances de types enregistrés qui se comportent comme des singletons dans le cadre D'une requête HTTP. Voir les remarques pour d'importantes informations sur l'utilisation.

remarques de MSDN

bien que le gestionnaire perrequestlifetimemanager lifetime manager fonctionne correctement et puisse aider à travailler avec des dépendances stateful ou thread-unsafe dans le cadre D'une requête HTTP, ce n'est généralement pas une bonne idée de l'utiliser quand il peut être évité , car il peut souvent conduire à de mauvaises pratiques ou difficile de trouver des bogues dans le code d'application de l'utilisateur final lorsqu'il est mal utilisé.

il est recommandé que les dépendances que vous enregistrez soient apatrides et s'il y a un besoin de partager un État commun entre plusieurs objets pendant la durée de vie D'une requête HTTP, alors vous pouvez avoir un service apatride qui stocke et récupère explicitement cet état en utilisant la collection D'Articles de l'objet courant.

les remarques disent que même vous êtes forcé d'utiliser un seul contexte par service (service de façade), vous devriez garder vos appels de service apatrides.

Unity 3 est pour .NET 4.5 soit dit en passant.

je crois que l'exemple de code indiqué sur NerdDinner: DI dans MVC en utilisant un pour son HttpContextLifetimeManager devrait répondre à vos besoins.

Je ne veux pas vous décourager inutilement et par tous les moyens expérimenter mais si vous allez de l'avant et utilisez des instances de singleton de DataContext assurez-vous que vous clouez.

il peut sembler fonctionner correctement sur votre environnement dev mais il pourrait ne pas fermer les connexions correctement. Ce sera difficile à voir sans la charge d'un environnement de production. Dans un environnement de production avec une charge élevée, les connexions non disputées provoquent d'énormes fuites de mémoire et puis haut CPU essayant d'allouer une nouvelle mémoire.

avez-vous considéré ce que vous gagnez d'une connexion par motif de requête? Combien de performances y a-t-il à gagner à ouvrir/fermer une connexion une fois par exemple 3-4 fois dans une requête? En valeur la dispute? En outre, cela rend le chargement paresseux échoue (lire des requêtes de base de données dans votre vue) beaucoup plus faciles infractions à faire.

désolé si cela s'est avéré décourageant. Vas-y si tu vois vraiment le bénéfice. Je suis je vous préviens que ça pourrait se retourner contre vous si vous vous trompez, alors soyez prévenus. Quelque chose comme " entity profiler sera inestimable pour l'obtenir correctement - il vous indique le nombre de connexions ouvertes et fermées - entre autres choses très utiles.

j'ai vu question et réponse il y a quelques fois. Il est daté. Unité.MVC3 a life time manager comme Hiérarchicallifetimemanager.

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

et ça marche bien.

je proposerais de le résoudre comme ceci: http://forums.asp.net/t/1644386.aspx/1

meilleures salutations

j'ai résolu ceci en utilisant Castle.DynamicProxy. Il fallait que certaines dépendances soient injectées "à la demande", c'est-à-dire qu'elles devaient être résolues au moment de l'utilisation, et non au moment de l'accumulation de "Depender".

pour ce faire, je configure mon conteneur comme suit:

 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)));
 }

l'idée étant que je fournis une méthode pour récupérer l'instance "sur demande."La lambda est invoquée chaque fois que l'une des méthodes de l'instance est utilisée. L'objet Dépendant est effectivement une référence à un objet proxy, pas de l'objet lui-même.

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);
    }
}

dans Unity3, si vous voulez utiliser

PerRequestLifetimeManager

vous devez enregistrer UnityPerRequestHttpModule

je le fais en utilisant WebActivatorEx, le code est comme ci-dessous:

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();
        }
    }
}

PerRequestLifetimeManager et UnityPerRequestHttpModule les classes sont dans Unité.MVC paquet qui a une dépendance sur ASP.NET MVC. Si vous ne voulez pas avoir cette dépendance (par exemple, vous utilisez L'API Web), vous devrez les copier-coller dans votre application.

si vous faites cela, n'oubliez pas le registre le HttpModule.

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

Edit: Je vais inclure le classes ici avant CodePlex ferme:

// 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);
        }
    }
}