PLINQO 和事务问题

Question

我刚刚开始使用 PLINQO 在我的 n 层分布式系统中实现存储库层和数据层。

数据层由以下几层组成：存储库、数据提供者、数据服务

存储库层负责从数据库获取数据并在数据库中设置数据。

数据提供者层是存储库和服务层之间的门户。

数据服务层保存所有业务逻辑和规则。

使用事务时，我在此架构中遇到问题：我经常收到 InvalidOperationException 错误消息：“无法附加已存在的实体。”。

究其原因，是因为repository层的设计。所有存储库方法中的常见步骤是：

MyDataContext context;
if(InTransaction == true)
    context = GetExistingContext();
else
    context = GetNewContext();

//Do some database operation for example:
var user = context.User.GetByKey("username");

//Detach from context
user.Detach();

if(InTransaction == false)
    context.Dispose();

当 InTransaction 为 true 并且我调用对同一实体进行操作的两个方法时，会发生 InvalidOperationException。由于 InTransaction 为 true，因此这两个方法使用相同的数据上下文。第一个方法附加实体并最终分离，第二个方法也尝试附加，然后发生异常。

我做错了什么以及如何防止这种情况发生？

谢谢，

科比

Answer 1

我找到了解决问题的方法。

当我尝试附加已附加到数据上下文的实体时，发生了异常，这是因为我的 Update() 方法中没有指示该实体是否已附加到该方法使用的数据上下文。

当我删除附件时，我没有得到异常，但实体有时没有更新（如果数据上下文是新的）。

所以我想如何在这两种冲突的情况之间架起桥梁，解决方案是 TransactionScope。

我创建了 TransactionScope 类，它允许方法加入和离开范围。

Join() 方法创建新的数据上下文并初始化使用计数器，因此对此方法的任何连续调用都会使该计数器加一。

Leave() 方法会递减使用计数器，当它达到零时，数据上下文将被释放。

还有返回数据上下文的属性（而不是每个方法都尝试获取自己的上下文）。

我将需要数据上下文的方法从问题中描述的方法更改为：

_myTranscationScope.Join();

try
{
  var context = _myTransactionScope.Context;

  //Do some database operation for example:
  context.User.GetByKey("username");

}
finally
{
    _myTranscationScope.Leave();
}

此外，我重写了数据上下文的 Dispose 方法，并将实体的分离移到那里，而不是在每个方法中执行此操作。

我需要确保的是我有正确的事务范围，并确保每次调用 join 也调用离开（即使在异常情况下）

这现在使我的代码可以完美地适应所有场景（包括单个数据库操作、复杂事务） ，使用序列化对象）。

这是 TransactionScope 类的代码（我删除了取决于我正在处理的项目的行代码，但它仍然是完全有效的代码）：

using System;
using CSG.Games.Data.SqlRepository.Model;

namespace CSG.Games.Data.SqlRepository
{
    /// <summary>
    /// Defines a transaction scope
    /// </summary>
    public class TransactionScope :IDisposable
    {
        private int _contextUsageCounter; // the number of usages in the context
        private readonly object _contextLocker; // to make access to _context thread safe

        private bool _disposed; // Indicates if the object is disposed

        internal TransactionScope()
        {
            Context = null;
            _contextLocker = new object();
            _contextUsageCounter = 0;
            _disposed = false;
        }

        internal MainDataContext Context { get; private set; }

        internal void Join()
        {
            // block the access to the context
            lock (_contextLocker)
            {
                CheckDisposed();

                // Increment the context usage counter
                _contextUsageCounter++;

                // If there is no context, create new
                if (Context == null)
                    Context = new MainDataContext();
            }
        }

        internal void Leave()
        {
            // block the access to the context
            lock (_contextLocker)
            {
                CheckDisposed();
                // If no one using the context, leave...
                if(_contextUsageCounter == 0)
                     return;

                // Decrement the context usage counter
                _contextUsageCounter--;

                // If the context is in use, leave...
                if (_contextUsageCounter > 0)
                    return;

                // If the context can be disposed, dispose it
                if (Context.Transaction != null)
                    Context.Dispose();

                // Reset the context of this scope becuase the transaction scope ended
                Context = null;
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            lock (_contextLocker)
            {
                if (_disposed) return;

                if (disposing)
                {
                    if (Context != null && Context.Transaction != null)
                        Context.Dispose();

                    _disposed = true;
                }
            }
        }        

        private void CheckDisposed()
        {
            if (_disposed)
                throw new ObjectDisposedException("The TransactionScope is disposed");
        }

    }
 }