Was ist die beste NHibernate-session-management-Ansatz für die Anwendung in einer multithread-windows-Dienst-Anwendung?

Ich habe einen windows-Dienst-Anwendung, die die Arbeit mit Multithreading. Ich benutze NHibernate in data-access-layer der Applikation.

Was ist Ihr Vorschlag für das session-management in dieser Anwendung. Ich lese über UNHAddins, Ist es eine gute Lösung?

InformationsquelleAutor der Frage masoud ramezani | 2011-06-15

  1. 17

    Ich verwenden NHibernate integrierte kontextbezogene sessions. Sie können über Sie hier Lesen:

    http://nhibernate.info/doc/nhibernate-reference/architecture.html#architecture-current-session

    Hier ist ein Beispiel, wie ich dieses verwenden: 

    public class SessionFactory
{
    protected static ISessionFactory sessionFactory;
    private static ILog log = LogManager.GetLogger(typeof(SessionFactory));

    //Several functions omitted for brevity

    public static ISession GetCurrentSession()
    {
        if(!CurrentSessionContext.HasBind(GetSessionFactory()))
            CurrentSessionContext.Bind(GetSessionFactory().OpenSession());

        return GetSessionFactory().GetCurrentSession();
    }

    public static void DisposeCurrentSession()
    {
        ISession currentSession = CurrentSessionContext.Unbind(GetSessionFactory());

        currentSession.Close();
        currentSession.Dispose();
    }
}

    Zusätzlich zu dieser habe ich Folgendes in meinem hibernate-config-Datei: 

    <property name="current_session_context_class">thread_static</property>

    InformationsquelleAutor der Antwort Cole W

  2. 4

    habe ich nicht mal geschaut bei der unhaddins, aber hier ist, was ich für wcf-Sachen, dürfte für Multithread-Allgemeine Sachen die ich mir vorstelle.

    dies ist der session-Kontext:

    namespace Common.Infrastructure.WCF
{
    public class NHibernateWcfSessionContext : ICurrentSessionContext
    {
        private readonly ISessionFactoryImplementor factory;

        public NHibernateWcfSessionContext(ISessionFactoryImplementor factory)
        {
            this.factory = factory;
        }

        ///<summary>
        ///Retrieve the current session for the session factory.
        ///</summary>
        ///<returns></returns>
        public ISession CurrentSession()
        {
            Lazy<ISession> initializer;
            var currentSessionFactoryMap = OperationContext.Current.InstanceContext.Extensions.Find<NHibernateContextManager>().SessionFactoryMaps;
            if (currentSessionFactoryMap == null ||
                !currentSessionFactoryMap.TryGetValue(factory, out initializer))
            {
                return null;
            }
            return initializer.Value;
        }

        ///<summary>
        ///Bind a new sessionInitializer to the context of the sessionFactory.
        ///</summary>
        ///<param name="sessionInitializer"></param>
        ///<param name="sessionFactory"></param>
        public static void Bind(Lazy<ISession> sessionInitializer, ISessionFactory sessionFactory)
        {
            var map = OperationContext.Current.InstanceContext.Extensions.Find<NHibernateContextManager>().SessionFactoryMaps;;
            map[sessionFactory] = sessionInitializer;
        }

        ///<summary>
        ///Unbind the current session of the session factory.
        ///</summary>
        ///<param name="sessionFactory"></param>
        ///<returns></returns>
        public static ISession UnBind(ISessionFactory sessionFactory)
        {
            var map = OperationContext.Current.InstanceContext.Extensions.Find<NHibernateContextManager>().SessionFactoryMaps;
            var sessionInitializer = map[sessionFactory];
            map[sessionFactory] = null;
            if (sessionInitializer == null || !sessionInitializer.IsValueCreated) return null;
            return sessionInitializer.Value;
        }
    }
}

    dies ist der Kontext-manager :

    namespace Common.Infrastructure.WCF
{
    class NHibernateContextManager : IExtension<InstanceContext>
    {
        public IDictionary<ISessionFactory, Lazy<ISession>> SessionFactoryMaps = new Dictionary<ISessionFactory, Lazy<ISession>>();

        public void Attach(InstanceContext owner)
        {
            //We have been attached to the Current operation context from the ServiceInstanceProvider
        }

        public void Detach(InstanceContext owner)
        {
        }
    }
}

    Edit:

    klar zu sein, wie die andere Antwort besagt, der thread statischen Kontext funktioniert out of the box. der Hauptvorteil von dem, was ich hier habe, ist 1) Sie erhalten die Kontrolle, und 2) seine lazy-Implementierung, so dass Sie nicht haben, um eine Sitzung zu starten für jeden thread, wenn es nicht notwendig ist. weniger Verbindung zur db ist immer besser, imho.

    InformationsquelleAutor der Antwort nathan gonzalez

Schreibe einen Kommentar