您应该处理整个工作单元。工作单元应涵盖您为获取视图模型所做的工作。
这样做可以避免在事务之外发生延迟加载。
它还允许您在出现错误时回滚整个工作单元。
并且它具有性能优势：NHProfiler 警告的原因之一是为每次数据访问打开事务的成本。 （还有其他的，比如二级缓存需要显式事务，否则在更新时会被禁用。）
您可以使用您找到的UnitOfWorkAction。
就个人而言，我觉得它太“宽泛”了。它甚至包括在事务中的结果执行。这允许在视图中使用延迟加载。我认为我们不应该使用实体作为视图模型，并且在我看来从视图触发数据库访问更糟糕。我使用的那个在OnActionExecuted结束交易。
此外，它的错误处理在我看来有点具体。对无效模型状态进行回滚可能没有意义：不应该尝试将无效数据保存在数据库中。不回滚处理的异常对于 less 来说很奇怪：如果 MVC 管道发现异常，这意味着操作或执行结果时出现问题，但其他一些过滤器已经处理了异常。通常，只是一个显示错误页面的错误过滤器，不是吗？那么这样的逻辑会导致提交失败的动作......
这是我使用的模式：
public class DefaultTransactionAttribute : ActionFilterAttribute
{
private static readonly ILog Logger =
LogManager.GetLogger(typeof(DefaultTransactionAttribute));
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
// IUnitOfWork is some kind of custom ISession encapsulation.
// I am working in a context in which we may change the ORM, so
// I am hiding it.
var uow = DependencyResolver.Current.GetService<IUnitOfWork>();
uow.BeginTransaction();
base.OnActionExecuting(filterContext);
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
base.OnActionExecuted(filterContext);
var uow = DependencyResolver.Current.GetService<IUnitOfWork>();
if (!uow.HasActiveTransaction())
{
// Log rather than raise an exception, for avoiding hiding
// another failure.
Logger.Warn("End of action without a running transaction. " +
"Check how this can occur and try avoid this.");
return;
}
if (filterContext.Exception == null)
{
uow.Commit();
}
else
{
try
{
uow.Rollback();
}
catch(Exception ex)
{
// Do not let this new exception hide the original one.
Logger.Warn("Rollback failure on action failure. (If the" +
"transaction has been roll-backed on db side, this is" +
"expected.)", ex);
}
}
}
}
有关最小 MVC 模式的分步说明，请参阅 Ayende 的这篇精彩博客系列：
- Refactoring, baseline
- Refactoring, global state
- Refactoring, session scope
- Refactoring, broken
- Refactoring, view model
- Refactoring, globals
- Refactoring, transactions
因为我的IUnitOfWork 有一些特殊的语义可以帮助我在 NHibernate 中使用 MVC 模式，所以这里是：
// This contract is not thread safe and must not be shared between threads.
public interface IUnitOfWork
{
/// <summary>
/// Save changes. Generally unneeded: if a transaction is ongoing,
/// its commit does it too.
/// </summary>
void SaveChanges();
void CancelChanges();
bool HasActiveTransaction();
void BeginTransaction();
/// <summary>
/// Saves changes and commit current transaction.
/// </summary>
void Commit();
void Rollback();
/// <summary>
/// Encapsulate some processing in a transaction, committing it if
/// no exception was sent back, roll-backing it otherwise.
/// The <paramref name="action"/> is allowed to rollback the transaction
/// itself for cancelation purposes. (Commit supported too.)
/// Nested calls not supported (InvalidOperationException). If the
/// session was having an ongoing transaction launched through direct
/// call to <c>>BeginTransaction</c>, it is committed, and a new
/// transaction will be opened at the end of the processing.
/// </summary>
/// <param name="action">The action to process.</param>
void ProcessInTransaction(Action action);
/// <summary>
/// Encapsulate some processing in a transaction, committing it if
/// no exception was sent back, roll-backing it otherwise.
/// The <paramref name="function"/> is allowed to rollback the transaction
/// itself for cancellation purposes. (Commit supported too.)
/// Nested calls not supported (InvalidOperationException). If the
/// session was having an ongoing transaction launched through direct
/// call to <c>>BeginTransaction</c>, it is committed, and a new
/// transaction will be opened at the end of the processing.
/// </summary>
/// <param name="function">The function to process.</param>
/// <typeparam name="T">Return type of
/// <paramref name="function" />.</typeparam>
/// <returns>The return value of the function.</returns>
T ProcessInTransaction<T>(Func<T> function);
}
public class UnitOfWork : IUnitOfWork
{
private static readonly ILog Logger =
LogManager.GetLogger(typeof(UnitOfWork));
private ISession Session;
public UnitOfWork(ISession session)
{
Session = session;
}
public void SaveChanges()
{
Session.Flush();
}
public void CancelChanges()
{
Session.Clear();
}
public bool HasActiveTransaction()
{
return Session.Transaction.IsActive;
}
public void BeginTransaction()
{
Session.BeginTransaction();
}
public void Commit()
{
Session.Transaction.Commit();
}
public void Rollback()
{
Session.Transaction.Rollback();
}
public void ProcessInTransaction(Action action)
{
if (action == null)
throw new ArgumentNullException("action");
ProcessInTransaction<object>(() =>
{
action();
return null;
});
}
private bool _processing = false;
public T ProcessInTransaction<T>(Func<T> function)
{
if (function == null)
throw new ArgumentNullException("function");
if (_processing)
throw new InvalidOperationException(
"A transactional process is already ongoing");
// Handling default transaction.
var wasHavingActiveTransaction = Session.Transaction.IsActive;
if (wasHavingActiveTransaction)
Commit();
BeginTransaction();
T result;
_processing = true;
try
{
result = function();
}
catch
{
try
{
if(Session.Transaction.IsActive)
Rollback();
}
catch (Exception ex)
{
// Do not let this new exception hide the original one.
Logger.Error("An additional error occurred while " +
"attempting to rollback a transaction after a failed " +
"processing.", ex);
}
// Let original exception flow untouched.
throw;
}
finally
{
_processing = false;
}
if (Session.Transaction.IsActive)
Commit();
if (wasHavingActiveTransaction)
BeginTransaction();
return result;
}
}