Question

I’ve written a class as follows. I’ve written it taking into consideration that its mainly for use on the web (i.e. it will be used from aspx pages).

public class TestHelper
{    
    public TestHelper()
    {
        HttpContext ctxt = HttpContext.Current;
        IHttpHandler RequestHandler = ctxt.Handler;
        Page CurrentPage;
        CurrentPage = (Page)RequestHandler;
        CurrentPage.Unload += new EventHandler(CurrentPage_Unload); 
        Debug.Print("Open all connection here...");
    }

    void CurrentPage_Unload(object sender, EventArgs e)
    {
        Debug.Print("Close all connection here...");
    }
}

And I’ve written my aspx page’s code behind like this:

public partial class _Default : System.Web.UI.Page 
{    
    protected void Page_Load(object sender, EventArgs e)
    {
        TestHelper helper = new TestHelper();
        helper = null;
    }

}

In spite of assigning helper to ‘null’ I find that CurrentPage_Unload() gets executed. Why is this behaviour so? What is this behaviour generally called?

The reason why I’ve written the class in that style was because I thought I could best manage my db connections in a central fashion in the class. Usually people would call methods on the object like helper.IsValid() followed by helper.ProfileExists() in the aspx code behind. Each of those methods would have their own db connection objects(IDbConnection), and their corresponding Open() & Close() calls to open/close db connection. I just felt that we should only do this only once in code. Hence I used the constructor to open db connections, and the Page object’s unload event to close the connection objects. Are there any pitfalls to writing classes this way?

Answer 1

Assigning null to a variable does not end its actual lifetime. Because .NET uses a non-deterministic garbage collection system (where objects are periodically purged based on several criteria, rather than as soon as they fall out of scope), you cannot rely on an object ever being collected before the process that created it ends.

Furthermore, because you’re attaching an event handler (meaning a delegate, which includes a reference to your newly-constructed instance) to another object, you’re extending the viable lifetime of your object as well. As long as that event handler is attached, your object cannot be collected until the object it’s attached to is eligible.