SPWeb.Site, should you call Dispose() on it

disposesharepoint

Updated 06/08/2009 15:52: Short answer NO. Original question:

I can't find any reference which gives guidance on SPWeb.Site regarding disposing. I've gone through some of the more popular best practises documentation on disposing SharePoint objects:

Unfortunately none of these guidelines mention SPWeb.Site. To give some context, I'm writing a public extension API which accepts an SPWeb as an argument to a method i.e.:

public static void GetWebPartFromCatalog(this SPWeb web, string webPartName)
{
     ......

     SPSite site = web.Site;
     ......

     **OR** ??

     using (SPSite site = web.Site)
     {
         ....
     }
}

I've looked as the Close() method in refelector for SPWeb, which is called by SPWeb.Dispose() and there is nothing in it to indicate the actual SPSite member field is disposed of.

Update: 06/08/2009 13:47

At Alex's suggestion

"Put it in a loop which runs 100 times and use the SPRequestStackTrace registry key described in Troubleshooting SPSite/SPWeb leaks in WSS v3 and MOSS 2007 to check that your test code is the source of the problem."

I ran the following piece of code included inside a webpart:

 for (int i = 0; i < 100; i++)
 {
     using (SPWeb web = SPContext.Current.Site.OpenWeb(""))
     {
            SPSite site = web.Site;
            Debug.WriteLine(site.Url);
     }
 }

Nothing appeared in the SharePoint logs.

Whilst I would hesitate to make any real conclusions from this naive experiment, It would suggest that it's not necessary to dispose of SPWeb.Site. It would be really nice to get a concrete answer from someone more informed on this subject.

Update: 06/08/2009 14:52
Prompted by Greg's Comment I worked out the assignments of m_Site and it appears it's ultimately always passed into SPWeb via the internal constructors. E.g. SPWeb.OpenWeb passes in this to new SPWeb(). So I'm more sure that SPWeb.Site should not be disposed, indeed could cause problems if it was.

Best Answer

Kirk's answer is correct. You must have some handle to an SPSite before an SPWeb can be created, and that is the same SPSite instance you will have when you call SPWeb.Site.

Let's think through the implications of that - if you do not control the creation of the SPSite, but one of its child webs is handed to you from external code, and you dispose the site, when control is returned to the calling code, you've disposed a Site they may not be done with! Put yourself in the calling code's shoes: you pass an SPWeb into a method, and when that method is done, the SPSite you were using has been closed. It is always the instanciator's responsibility to clean up resources they allocate. Do not dispose the SPSite in this case.

Related Solutions

R – Customizing default.master in WSS 3.0

WSS pages use Master Pages just like regular web apps. However, the value if the MasterPageFile attribute is a token, and is set to "~default.master". This token gets replaced with the actual reference to the master page in the page's PreInit method.

You can change the value of ~default.master to anything you like. But a better solution is to do the same type of thing that SharePoint does.

I added an HttpHandler to my SharePoint site. The handler attaches to the PreRequestHandlerExecute method, and changes the value of the master page file attribute before SharePoint starts rendering the page.

Add a line to the httpModules section of the web.config that looks like this:

Then create a class like this:

namespace MyClassLibrary.Utility { public class MasterPageHttpModule : IHttpModule { public void Init(HttpApplication context) { context.PreRequestHandlerExecute += new EventHandler(context_PreRequestHandlerExecute); }

    void context_PreRequestHandlerExecute(object sender, EventArgs e)
    {
        bool useCustomMasterPages = Convert.ToBoolean(ConfigurationManager.AppSettings["ShowCustomMasterPages"].ToString());
        if (useCustomMasterPages)
        {
            Page page = HttpContext.Current.CurrentHandler as Page;
            if (page != null)
            {
                page.PreInit += new EventHandler(page_PreInit);
            }
        }
    }

    void page_PreInit(object sender, EventArgs e)
    {
        bool useThreeColumnMaster = Convert.ToBoolean(ConfigurationManager.AppSettings["UseThreeColumnMasterOnDefaultPage"].ToString());

        try
        {
            Page page = sender as Page;
            if (page != null && SPContext.Current != null)
            {
                string url = page.Request.Url.AbsolutePath.ToLower();
                if (url.IndexOf("/public/") > -1)
                {
                    if (url.IndexOf("sitemap.aspx") == -1)
                    {
                        page.MasterPageFile = "~/_catalogs/masterpage/edge_con.master";
                    }
                    else
                    {
                        page.MasterPageFile = "";
                    }
                }
                else if (url.IndexOf("default.aspx") > -1)
                {
                    if (useThreeColumnMaster)
                    {
                        page.MasterPageFile = "~/_catalogs/masterpage/edge_con.master";
                    }
                    else
                    {
                        page.MasterPageFile = "~/_catalogs/masterpage/edge.master";
                    }
                }
                else if (url.IndexOf("sitemap.aspx") > -1)
                {
                    //
                    //  Sitemap pages should not have a master page
                    //
                    page.MasterPageFile = "";
                    page.Controls.Clear();
                }
                else if (url.IndexOf("/admin/") > -1)
                {
                    page.MasterPageFile = "~/_catalogs/masterpage/edge.master";
                }
                else if (url.IndexOf("/member/") > -1)
                {
                    page.MasterPageFile = "~/_catalogs/masterpage/edge.master";
                }
                else if (url.IndexOf("/supplier/") > -1)
                {
                    page.MasterPageFile = "~/_catalogs/masterpage/edge.master";
                }
                else if (page.MasterPageFile == "~masterurl/default.master")
                {
                    page.MasterPageFile = "~/_catalogs/masterpage/edge.master";
                }
            }
        }
        catch (Exception exception)
        {
            LogWriter logWriter = new LogWriter();
            logWriter.WriteToLog("Could  not set master page: " + exception.Message, LogType.MasterPage, DateTime.Now);
        }
    }

    public void Dispose()
    {
    }
}

}

Now you are dynamically choosing a mater page.

R – Cross Method Dispose Patterns in SharePoint

I consider the "Cross Method Dispose Pattern" to be the worst of the "Best Practices". It is almost always better to use dependency injection to provide an SPSite or SPWeb reference for your class to use, perhaps through the constructor. That way your class has no disposal concerns, it just consumes the SharePoint context.

That said, if you wish to proceed with this pattern, implementing IDisposable is the correct approach. However, you should track and dispose the SPSite rather than the SPWeb. I might implement it like this:

public class MyClass : IDisposable
{
    private string _url;
    private SPSite _site;
    private SPWeb _web;

    private SPSite RootSite
    {
        get 
        {
            if ( _site == null )
            {
                _site = new SPSite( _url );
            }

            return _site;
        }
    }

    private SPWeb RootWeb
    {
        get 
        {
            if ( _web == null )
            {
                _web = RootSite.OpenWeb();
            }

            return _web;
        }
    }

    void IDisposable.Dispose()
    {
        if (null != _site)
        {
            _site.Dispose();
        }
    }
}

Note that _web will be automatically disposed by the call to _site.Dispose().

Best Answer

Related Solutions

R – Customizing default.master in WSS 3.0

R – Cross Method Dispose Patterns in SharePoint

Related Topic