There may come a time in your SharePoint development that you will need to update a list item during an ItemUpdated event. For instance, have a look at this code:

 public override void ItemUpdated(SPItemEventProperties properties)
 {
 base .ItemUpdated(properties);
 SPListItem listItem = properties.ListItem;
 listItem["Title" ] = "A cool new title!" ;
 listItem.Update();
 }

In this ItemUpdated event, we are simply assigning the current ListItem to a new SPListItem object, changing its "Title" property, and updating it. Pretty simple. However, this simple piece of code will cause an endless loop, as each time you call listItem.Update(), the ItemUpdated event receiver fires. As you can see, we need a way to prevent this loop from occuring.

Luckily there is an easy and elegant solution with a little custom code. We'll create a class called DisabledEventsScope:

 class DisabledEventsScope : SPItemEventReceiver , IDisposable 
 {
 // Boolean to hold the original value of the EventFiringEnabled property 
 bool _originalValue;
 
 public DisabledEventsScope()
 {
 // Save off the original value of EventFiringEnabled 
 _originalValue = base .EventFiringEnabled;
 
 // Set EventFiringEnabled to false to disable it 
 base .EventFiringEnabled = false ;
 }
 
 public void Dispose()
 {
 // Set EventFiringEnabled back to its original value 
 base .EventFiringEnabled = _originalValue;
 }
 }

This class is simple and to the point. We inherit SPItemEventReceiver and IDisposable, SPItemEventReceiver will give us access to the base properties in the event receiver and IDisposable will give us a Dispose method (which comes in handy in a moment).

SPItemEventReceiver has a property called EventFiringEnabled, which simply indicates whether event firing is enabled. We can turn this off to prevent our loop from occuring. First, we declare a boolean to hold the original value of the EventFiringEnabled property. Now, in our constructor we save off the EventFiringEnabled value, then set it to false. Next, in our Dispose method, we simply set the value back and you're done.

Now you may ask, why not just set it to false in the constructor and set it to true in the Dispose. This will most likely work for 99.9% of all implementations, but why take the risk. There may be other code working some magic here as well, and by saving off the value and setting it back you do not interfere with anything else that may be going on.

Now, implementing this code is even more simple. All we need to do is wrap our previous code in a Using statement:

 public override void ItemUpdated(SPItemEventProperties properties)
 {
 base .ItemUpdated(properties);
 using (DisabledEventsScope scope = new DisabledEventsScope ())
 {
 SPListItem listItem = properties.ListItem;
 listItem["Title" ] = "A cool new title!" ;
 listItem.Update();
 }
 }

Viola! Now once the listItem.Update() fires, we are inside the scope of our DisabledEventsScope class which has disabled event firing. Once our update takes place, event firing will be restored and everything works appropriately.

Enjoy!