The Disposable Pattern in SharePoint Development

If you don’t properly dispose of objects in the SharePoint object model that implement IDisposable, you will have memory usage problems in your application. Under heavy load, SharePoint may perform poorly or even exit when memory allocation fails. So it is critical to properly dispose of these IDisposable objects. The objects to be most careful of are SPSite and SPWeb, which must be disposed of because they consume large amounts of unmanaged memory. But I Thought Garbage Collection Took Care of Memory Management? You might wonder why you must dispose of these objects yourself and why garbage collection doesn’t just take care of these things. The answer is that an object like SPSite uses a mix of managed and unmanaged code.

The memory usage of the managed side of SPSite is monitored by the .NET garbage collector, and when enough memory is used by the managed code, the garbage collector will kick in. The problem is  that the .NET garbage collector doesn’t watch the unmanaged code’s use of memory and the unmanaged memory use is much greater than the managed memory use. So you can quickly run out of memory on the unmanaged side without .NET ever feeling like it needs to do a garbage collection.

How to spot the problem?

The memory usage of Does your application pool recycle frequently, especially under heavy loads (assuming that the application pool is set to recycle when a memory threshold is reached)? (The memory threshold should be 800 MB–1.5 GB (assuming at least 2 GB of RAM). Setting the recycle of the application pool to occur closer to 1 GB gives the best results, but experiment to determine what settings work best for your environment. If the recycle setting is too low, you experience performance issues because of frequent application pool recycles. If the setting is too high, your system experiences performance problems because of page swapping, memory fragmentation, and other issues.) Does your system perform poorly, especially under heavy loads? (As memory usage begins to increase, the system must compensate, for example, by paging memory and handling memory fragmentation.) Does your system crash or do users experience unexpected errors such as timeouts or page-not-available errors, especially under heavy loads? Does your system use custom or third-party Web Parts or custom applications?

1st Approach

If your sites are displaying any of the unusual behaviors described previously, you can determine whether the cause is a memory leak due to incorrectly disposed objects by checking the ULS logs (available at C:\Program Files\Common Files\microsoft shared\Web Server Extensions\12\LOGS) for entries related to the SPRequest object.Each instance of SPSite and SPWeb contains a reference to an SPRequest object that,in turn, contains a reference to an unmanaged COM object that handles communications with the database server. Windows SharePoint Services monitors the number of SPRequest objects that exist in each specific thread and in parallel threads, and adds useful entries to the logs. For more information on this click here:

2nd Approach:

Microsoft provides a tool to help you detect and track down objects you aren’t disposing of properly called the SharePoint Dispose Checker tool. That tool is found here: http://code.msdn.microsoft.com/SPDisposeCheck

Coding Techniques to Ensure Object Disposal

You can employ certain coding techniques to ensure object disposal. These techniques include using the following in your code: Dispose method using clause try, catch, and finally blocks

Dispose method

The basic idea behind using the Dispose method is you call it on an IDisposable object when you are done with it. At the point you call Dispose on the object the managed and unmanaged memory associated with the object is reclaimed. The object is also no longer usable after you call Dispose on it—any subsequent calls to the object will result in an error.               Example                 SPSite mySite = new SPSite("http://mySite");                 //do something with mysite                 mySite.Dispose(); //disposes of memory used by mysite                //now don’t use mySite object as it will throw error

The using Clause

You can automatically dispose of SharePoint objects that implement the IDisposable interface by using the Microsoft Visual C# using statement.              Example              String str;              using(SPSite oSPsite = new SPSite("http://Myserver"))             {                   using(SPWeb oSPWeb = oSPSite.OpenWeb())                   {                           str = oSPWeb.Title;                           str = oSPWeb.Url;                    }             } It also makes your code more clear and makes it impossible for you to accidentally call into the object after it has been disposed because it also goes out of scope when you are done with it.

The try, catch, and finally Blocks

Using try, catch, and finally blocks obviously makes sense whenever you need to handle exceptions. Any code within a try/catch block should have a governing finally clause, which ensures that the objects that implement IDisposable are disposed. There are cases in your code where you may be creating objects that are IDisposable that may not be as obvious. For example, you may have a foreach loop that iterates over a collection that returns SPSite or SPWeb objects. For these cases you use a try, finally block in the iterator to ensure that each IDisposable object created in the foreach loop is disposed of properly.                  Example                   using (SPSite spSite = new SPSite('http://mysite/'))                  {                       foreach (SPWeb spweb in spSite.AllWebs)                        {                              try                              {                                    Console.WriteLine(spweb.Name);                              }                              finally                             {                                   if (spweb != null)                                   {                                            spweb.Dispose();                                   }                             }                        }                   }