Locking SPListItem for entirely server-side update

Question

I am using code similar to the following to apply an update to an SPListItem, after necessarily elevating to System privileges on said item.

Because this can be called multiple times for the same item, possibly concurrently, I have a lock from opening the item to updating it. This means concurrent updates do not cause a save conflict, but wait for the previous update to finish.

private static string lockMe = "lockMe";
public static void AffectListItem(SPListItem listItem)
{
    // Elevate
    using (SPSite site = new SPSite(listItem.Web.Site.ID, SPUserToken.SystemAccount))
    {
        using (SPWeb web = site.OpenWeb(listItem.Web.ID))
        {
            SPList list = web.Lists[listItem.ParentList.ID];

            lock(something) // lockMe or listItem, see below
            {
                SPListItem cleanItem = list.GetItemById(listItem.ID);

                // Perform a small server-side update.
                MakeChanges(cleanItem);
                cleanItem.Update();
            }
        }
    }
}

However, I'm not sure exactly what I should be locking on. If I lock on a private, static variable of the class containing this method, then I lock when any items are updated concurrently, not just when the same item is updated twice concurrently. If I lock on listItem, I get no lock at all, because the different listItems are different objects.

Is there something I can lock against that will provide this per-ListItem locking that I need? Alternatively, is this a bad idea, or is there a totally different method of going about it?

Answer 1

The lock() statement you are using will only lock that section of your code, and only within the same application domain (ie AppPool. It won't lock across multiple servers in a farm environment). As James said, it will also not lock the list item so that other code cannot update the list item.

As far as I know, for regular list items there isn't a way to lock the record in the way you want to, BUT if the item is a document/file in a document library there is a way. The following code sample will show you how you can lock a file (which will also prevent it's related SPListItem from being modified for the duration of the lock)

      string lockId = "MyLock";
      SPList list = GetList();
      SPListItem item = GetListItem();

      if (list is SPDocumentLibrary)
      {
           //check if the item has a file, and that it is not already locked
           if (item.File != null && item.File.LockType == SPFile.SPLockType.None)
           {
               //lock for exclusive use, for 5 minutes
               item.File.Lock(SPFile.SPLockType.Exclusive, lockId, TimeSpan.FromMinutes(5));
               //ensure the lock is our lock
               if (item.File.LockId == lockId)
               {

                    //do updates here   


                   //make sure we release the lock
                   item.File.ReleaseLock(lockId);
                }
            }
       }

This is a similar mechanism SharePoint uses to lock a document for editing when an file is opened in MS Office for example.

Answer 2

Have you tried changing the signature of your MakeChanges method to MakeChanges(ref cleanItem)? Thinking, that the object passed in will be handled differently in memory and the lock might take more effect.

Though, something is telling me that using locks might not be all that affective, as there's nothing stopping another thread, in another assembly, or even another process, opening up an SPListItem to the same item and modifying it.

Have you had any problems to date? SharePoint uses SQL Server locking on the records when performing updates on ListItems anyway.