Argh. I'm going through an older application and replacing a somewhat complex scheme of user control templating with Master Pages today. For the most part this has been going real well until I hit a page that that relies on page inheritance where there's a common page base class that needs to have access to the controls on the page.
ASP.NET has never made this exactly easy, because the base class doesn't allow you access to the controls from the lower level as ASP.NET adds the properties higher up in the hierarchy. In the past I've been working around this by adding properties for the controls to the base class and then overriding these properties, but in ASP.NET 2.0 the control definitions are auto-generate with no chance to override the control definitions. The only workaround has been using FindControl() and dynamically retrieve the control definitions.
And this is where things get a bit tricky with MasterPages. The problem is that when you use MasterPages the page hierarchy drastically changes. Where a simple this.FindControl() used to give you a control instance you now have to drill into the container hierarchy pretty deeply just to get to the content container.
So in the past I might have done this in my C# base class:
protected Label lblError = null;
protected DataGrid dgItemList = null;
protected void AssignControls()
{
this.lblError = this.FindControl("lblError") as Label;
this.dgItemList = this.FindControl("dgItemList") as DataGrid;
}
you now have to drill into the containership with code like this:
protected void AssignControls()
{
this.lblError = this.Master.FindControl("Content").FindControl("lblError") as Label;
this.dgItemList = this.Master.FindControl("Content").FindControl("dgItemList") as DataGrid;
}
This isn't so bad, except when you're trying to figure out how to get to your controls <s>.
It really seems lame that Microsoft hasn't added a recursive FindControl() method to the Control class that drills into child containers. While this certainly isn't optimal in terms of performance it sure would make life a lot easier in a lot of situations, and this surely is one of them.
Not exactly rocket science to create a method that does this:
/// <summary>
/// Finds a Control recursively. Note finds the first match and exists
/// </summary>
/// <param name="ContainerCtl"></param>
/// <param name="IdToFind"></param>
/// <returns></returns>
public static Control FindControlRecursive(Control Root, string Id)
{
if (Root.ID == Id)
return Root;
foreach (Control Ctl in Root.Controls)
{
Control FoundCtl = FindControlRecursive(Ctl, Id);
if (FoundCtl != null)
return FoundCtl;
}
return null;
}
with this the code becomes:
/// <summary>
/// Assigns controls from the subclassed control to this instance so
/// we always can access the controls in our base class.
/// </summary>
protected void AssignControls()
{
this.lblError = wwWebUtils.FindControlRecursive(this.Master,"lblError") as Label;
this.dgItemList = wwWebUtils.FindControlRecursive(this.Master, "dgItemList") as DataGrid;
}
Although this is easier, I suspect it's better to do the explicit thing if that option is available to you as it probably has better performance. Also I suspect Microsoft didn't include this sort of a function in ASP.NET natively because there's potential ambiguity here – there could be more than one control Id that matches a name.
Other Posts you might also like