如何基于密钥同步代码块

我有一个通过WCF MSMQ传输公开的服务。

该服务所做的部分工作是基于关键字（source，item_id）查找项。如果它找到一个，它将检索数据库标识符，并使用该标识符来更新记录。如果找不到，则插入新记录。

我注意到两个项目可能同时进入，两个项目都看到数据库中不存在一个项目，他们都试图插入，但其中一个项目因约束错误而失败。

我想限制对数据库查找的访问，并根据键（source，item_id）跟踪代码，以便一次只有一个线程可以为该特定键执行工作。

我已经编写了一些代码来实现这一点，但我想得到一些反馈，看看这是否有效，或者是否有更好的方法。

使用LockManager类的代码：

public class ItemService
{
   private static LockManager lockManager = new LockManager();
   public void AddItem(Item item){
      var itemKey = item.Source + ":" + item.ItemId;
      lockManager.Work(itemKey, delegate(){ do stuff });
   }
}

LockManager类：

public class LockManager
{
    private readonly IDictionary<string, LockObject> _lockTable = 
        new Dictionary<string, LockObject>();
    public void Work(string key, Action work)
    {
        var lockObject = BorrowLockObject(key);
        try
        {
            lock (lockObject)
            {
                work();
            }
        }
        finally
        {
            ReturnLockObject(lockObject);
        }
    }
    private LockObject BorrowLockObject(string key)
    {
        lock (_lockTable)
        {
            LockObject lockObject = null;
            if (_lockTable.ContainsKey(key))
            {
                lockObject = _lockTable[key];
            }
            else
            {
                lockObject = new LockObject(key);
                _lockTable[key] = lockObject;
            }
            lockObject.Open();
            return lockObject;
        }
    }
    private void ReturnLockObject(LockObject lockObject)
    {
        lock (_lockTable)
        {
            if (lockObject.Close())
            {
                _lockTable.Remove(lockObject.GetKey());
            }
        }
    }
}

LockObject类：

public class LockObject
{
    private readonly string _key;
    private int _count;
    public LockObject(string key)
    {
        _key = key;
        _count = 0;
    }
    public string GetKey()
    {
        return _key;
    }
    public void Open()
    {
        lock(this)
        {
            _count++;    
        }    
    }
    /// <summary>
    /// Closes this lock object.
    /// </summary>
    /// <returns>True if this Lock Object is no longer in use.</returns>
    public bool Close()
    {
        lock(this)
        {
            _count--;
            return _count == 0;
        }
    }
}