关于sharepoint 内存泄漏的好文章

 

http://www.cnblogs.com/try/admin/EditArticles.aspx

 

The New Definitive SPSite/SPWeb Disposal Article

December 6, 2008 — Keith Dahlby

As I’ve posted before, properly cleaning up your SPSite and SPWeb objects is an important yet confusing consideration in writing good SharePoint object model code. There are some decent articles out there already, but Stefan Goßner just posted the best guidance - by far - I’ve seen on the subject: Disposing SPWeb and SPSite objects. Seriously, go read it.

In my view, Stefan hit on four key points that bear repeating:

1. Ensure that you only dispose SPSite and SPWeb objects that your code owns.

Examples that you don’t own, most of which I have seen incorrectly disposed in various examples online:

• SPContext.Current.Web
• SPContext.Current.Site
• SPContext.Current.Site.RootWeb
• SPFeatureReceiverProperties.Feature.Parent for a Site- or Web-scoped feature receiver
• SPWebEventProperties.Web
• SPListEventProperties.Web
• SPListEventProperties.List.Web
• SPItemEventProperties.ListItem.Web
• UnsecuredLayoutsPage.Web (and LayoutsPageBase.Web)
• SPWebProvisioningProperties.Web
• SPControl.GetContextWeb()
• SPControl.GetContextSite()

In general, there are three common cases where you do own the object:

• When you new up your own SPSite object:
  SPSite site = new SPSite(url);
• When you explicitly call SPSite.OpenWeb():
  SPWeb web = site.OpenWeb(url);
• When you iterate through SPSite.AllWebs - this is an extremely expensive operation, so avoid if possible:
  foreach(SPWeb web in site.AllWebs) {
  // …
  web.Dispose();
  }

If you think of any other examples I should include in these lists, leave a comment and I’ll update the post.

2. An SPWeb or SPSite object you own should be disposed as soon as it is no longer needed.

Stefan’s post has a great explanation, which he neatly summarizes:

You should dispose a SPWeb or SPSite object after the last access to a child object of this object. Be aware that a sub site (SPWeb) is not a child object. But (e.g.) a list or a folder or list item is a child object for this scenario.

3. Using a disposed SPWeb or SPSite object (like might happen if you Dispose something that doesn’t belong to you) can cause exceptions.

While it’s great to Dispose properly, it’s dangerous to Dispose improperly: when in doubt, in my opinion, err on the side of caution and let SharePoint clean up the mess. For webs, that happens when the parent site is disposed. For sites, that happens when the thread ends. If you do have memory problems, check out Stefan’s post on Troubleshooting SPSite/SPWeb leaks in WSS v3 and MOSS 2007.

4. SPSite and SPWeb objects should be disposed in the same method they get allocated.

And as a corollary to this, I agree with Chris O’Brien’s conclusion, almost as an afterthought, in a recent post:

However, if the caller has to provide the IDisposable objects, it can then be responsible for calling Dispose() because it knows when they are no longer needed. Most often the caller will simply be passing a reference to SPContext.Current.Web, but if the caller happens to be a Feature receiver then SPFeatureProperties.ListItem.Parent.Web would be passed, or if no existing SPWeb object was available to the caller (e.g. console app) a new SPWeb object would have to be instantiated and passed. Disposals then become much simpler because they can always happen in the same place as any instantiations.

If the logic that utilizes the SPSite/SPWeb is encapsulated within a function that receives it as an argument, there is no risk of leaks. Most simply, there is little risk when the code looks like this:

using (SPWeb web = SPContext.Current.Site.OpenWeb()) {
DoSomethingWith(web);
}

Now, some developers like to encapsulate the SPSite/SPWeb retrieval logic in dedicated methods. A safe approach is to leverage delegates. Unfortunately, variations of an unsafe alternative are much more common (in this case, copied from an otherwise brilliant MVP’s blog):

public static SPWeb ReturnSPWeb(string url) {
using (var site = new SPSite(url)) {
using (SPWeb web = site.OpenWeb()) {
return web;
}
}
}

When you return from within a using block, the compiler will insert a Dispose on the used object before returning. Open your assembly in ildasm if you don’t believe me. So the above code is effectively equivalent to the following:

public static SPWeb ReturnSPWeb(string url) {
var site = new SPSite(url);
SPWeb web = site.OpenWeb();
web.Dispose();
site.Dispose();
return web;
}

Oops! Before they even got a chance to do anything, the objects were cleaned up, and more importantly any code that depends on the returned SPWeb is completely unsafe! The same would apply for child objects (SPList, etc) returned from within a using block around the parent object. Even if the code works most of the time, the bugs it could introduce would be nearly impossible to track down.

Thanks again to Stefan for the excellent post!

Last updated 12/8/2008

转载于:https://www.cnblogs.com/try/articles/1351637.html