0

FluentNHibernateとAutoMapperを使用するASP.NETMVCアプリケーションがあります。私は主にAutoMapperを使用して、モデルをViewModelsに、またはその逆にマップしています。

後者を実行するとき、ビューモデルからモデルにマッピングし直すと、これをDBから特定のインスタンスにマッピングする方法がわからないので、変更をDBにコミットするときに（NHibernateリポジトリレイヤーを使用して、サービスを介して）レイヤー）、変更は永続化されます。

例：

var advert = Mapper.Map<AdvertViewModel, Advert>(model);
_advertService.UpdateAdvert(advert); // then calls repo which commits current NHibernate trans * Nothing in the DB changes *

マッピングの一部としてアドバタイズメントに正しいキー/IDが割り当てられているにもかかわらず、DBでこのアドバタイズメントを更新するためにNHibernateセッションをコミットしようとすると、NHibernateセッションはこのアドバタイズメントインスタンスについて何も知らないためだと思います（？）変更を書き留めることはありません。

したがって、NHibernateと組み合わせてこのマッピングシナリオをどのように処理するのか疑問に思っていますか？

4

2 に答える 2

4

次のことができます。

// fetch the domain model to update
var domainModelToUpdate = _advertService.Get(viewModel.Id);

// Map the properties that are present in the view model to the domain model
// leaving other properties intact
Mapper.Map<AdvertViewModel, Advert>(viewModel, domainModelToUpdate);

// Update the domain model
_advertService.UpdateAdvert(domainModelToUpdate);

ただし、ビュー モデルに既にすべてが含まれている場合は、更新する前にドメイン モデルをフェッチする必要はありません。あなたがしなければならないことはunsaved-value、インスタンスが一時的であるかどうかを NHibernate が認識できるように ID 列のマッピングを指定してから、次を使用することだけSaveOrUpdateです。

Id(x => x.ID).WithUnsavedValue(0);

または、ID パスに null 許容整数を使用している場合null。

于 2012-06-27T07:31:19.963 に答える
1

それが本当にセッションの問題である場合 - 次のシングルトンがあなたを助けるかもしれません

/// <summary>
/// Handles creation and management of sessions and transactions.  It is a singleton because 
/// building the initial session factory is very expensive. Inspiration for this class came 
/// from Chapter 8 of Hibernate in Action by Bauer and King.  Although it is a sealed singleton
/// you can use TypeMock (http://www.typemock.com) for more flexible testing.
/// </summary>
public sealed class NHibernateSessionManager
{
    #region Thread-safe, lazy Singleton

    System.IO.StreamWriter ConsoleWriter = null;

    /// <summary>
    /// This is a thread-safe, lazy singleton.  See http://www.yoda.arachsys.com/csharp/singleton.html
    /// for more details about its implementation.
    /// </summary>
    public static NHibernateSessionManager Instance
    {
        get
        {
            return Nested.NHibernateSessionManager;
        }
    }

    /// <summary>
    /// Initializes the NHibernate session factory upon instantiation.
    /// </summary>
    private NHibernateSessionManager()
    {
        InitSessionFactory();
    }

    /// <summary>
    /// Assists with ensuring thread-safe, lazy singleton
    /// </summary>
    private class Nested
    {
        static Nested() { }
        internal static readonly NHibernateSessionManager NHibernateSessionManager =
            new NHibernateSessionManager();
    }

    #endregion

    private void InitSessionFactory()
    {
        // Hold the config var
        FluentConfiguration config = Fluently.Configure();

        // Set the DB config
        MsSqlConfiguration dbConfig = MsSqlConfiguration.MsSql2005.ConnectionString(ConfigurationManager.ConnectionStrings["iSearchConnection"].ConnectionString);
        config.Database(dbConfig);

        // Load mappings from this assembly
        config.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()));

        // Create session factory
        sessionFactory = config.BuildSessionFactory();
    }

    /// <summary>
    /// Allows you to register an interceptor on a new session.  This may not be called if there is already
    /// an open session attached to the HttpContext.  If you have an interceptor to be used, modify
    /// the HttpModule to call this before calling BeginTransaction().
    /// </summary>
    public void RegisterInterceptor(IInterceptor interceptor)
    {
        ISession session = ContextSession;

        if (session != null && session.IsOpen)
        {
            throw new CacheException("You cannot register an interceptor once a session has already been opened");
        }

        GetSession(interceptor);
    }

    public ISession GetSession()
    {
        return GetSession(null);
    }

    /// <summary>
    /// Gets a session with or without an interceptor.  This method is not called directly; instead,
    /// it gets invoked from other public methods.
    /// </summary>
    private ISession GetSession(IInterceptor interceptor)
    {
        ISession session = ContextSession;

        if (session == null)
        {
            if (interceptor != null)
            {
                session = sessionFactory.OpenSession(interceptor);
            }
            else
            {
                session = sessionFactory.OpenSession();
            }

            ContextSession = session;
        }

        return session;
    }

    /// <summary>
    /// Flushes anything left in the session and closes the connection.
    /// </summary>
    public void CloseSession()
    {
        ISession session = ContextSession;

        if (session != null && session.IsOpen)
        {
            session.Flush();
            session.Close();
        }

        if (ConsoleWriter != null)
        {
            ConsoleWriter.Flush();
            ConsoleWriter.Close();
        }

        ContextSession = null;
    }

    public void BeginTransaction()
    {
        ITransaction transaction = ContextTransaction;

        if (transaction == null)
        {
            transaction = GetSession().BeginTransaction();
            ContextTransaction = transaction;
        }
    }

    public void CommitTransaction()
    {
        ITransaction transaction = ContextTransaction;

        try
        {
            if (HasOpenTransaction())
            {
                transaction.Commit();
                ContextTransaction = null;
            }
        }
        catch (HibernateException)
        {
            RollbackTransaction();
            throw;
        }
    }

    public bool HasOpenTransaction()
    {
        ITransaction transaction = ContextTransaction;

        return transaction != null && !transaction.WasCommitted && !transaction.WasRolledBack;
    }

    public void RollbackTransaction()
    {
        ITransaction transaction = ContextTransaction;

        try
        {
            if (HasOpenTransaction())
            {
                transaction.Rollback();
            }

            ContextTransaction = null;
        }
        finally
        {
            CloseSession();
        }
    }

    /// <summary>
    /// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms 
    /// specific <see cref="CallContext" />.  Discussion concerning this found at 
    /// http://forum.springframework.net/showthread.php?t=572.
    /// </summary>
    private ITransaction ContextTransaction
    {
        get
        {
            if (IsInWebContext())
            {
                return (ITransaction)HttpContext.Current.Items[TRANSACTION_KEY];
            }
            else
            {
                return (ITransaction)CallContext.GetData(TRANSACTION_KEY);
            }
        }
        set
        {
            if (IsInWebContext())
            {
                HttpContext.Current.Items[TRANSACTION_KEY] = value;
            }
            else
            {
                CallContext.SetData(TRANSACTION_KEY, value);
            }
        }
    }

    /// <summary>
    /// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms 
    /// specific <see cref="CallContext" />.  Discussion concerning this found at 
    /// http://forum.springframework.net/showthread.php?t=572.
    /// </summary>
    private ISession ContextSession
    {
        get
        {
            if (IsInWebContext())
            {
                return (ISession)HttpContext.Current.Items[SESSION_KEY];
            }
            else
            {
                return (ISession)CallContext.GetData(SESSION_KEY);
            }
        }
        set
        {
            if (IsInWebContext())
            {
                HttpContext.Current.Items[SESSION_KEY] = value;
            }
            else
            {
                CallContext.SetData(SESSION_KEY, value);
            }
        }
    }

    private bool IsInWebContext()
    {
        return HttpContext.Current != null;
    }

    private const string TRANSACTION_KEY = "CONTEXT_TRANSACTION";
    private const string SESSION_KEY = "CONTEXT_SESSION";
    private ISessionFactory sessionFactory;
}

いくつかの NHibernate 教祖の Web サイトからこれを取得しました-どれを思い出せませんが-基本的に、あなたがいるアプリのコンテキストでセッションを追跡して再構築します-私のプロジェクトに最適です。

次に、マネージャーで標準メソッドを呼び出すだけです。

ISession ctx = NHibernateSessionManager.Instance.GetSession();

try
{
    ctx.BeginTransaction();
    ctx.Update(entity);
    ctx.CommitTransaction();
}

優れたセッション処理が既に実装されている可能性がありますが、情報によると、発生しているのはセッションの問題のように聞こえるので、それが役立つかどうか教えてください

于 2012-06-27T12:30:30.733 に答える