ASP.NET - Dynamic Control Mapping

• Download source (7.13 KB)

I already posted here about Tag Mapping and how helpful it can be, but naturally there are a few improvements that I would like to see available in the future framework release.

The one I expect the most is about the capability of mapping dynamic created controls using the same rules as Tag Mapping uses when interpreting the page markup.

Without this capability, we can never use widely the tag mapping because whenever we need to create dynamic controls, they will be strongly coupled to a specific control implementation.

Imagine this scenario:

1. First you have built a web application that uses standard ASP.NET TextBox control, some of them dynamically created.
2. Now, imagine that you want to reuse that application, as is, but instead of ASP.NET Textbox control, you want to use your own Textbox implementation.

This task could be easily accomplished using Tag Mapping if no dynamic controls were used, but in this scenario ASP.NET gives us no solution, so the application cannot be reused without modifications.

Naturally, you can copy/paste your application and make the necessary changes, or even add a few if statements, but that will only increase complexity and maintenance effort.

Until the .NET team provides us with such capability, we must do the magic ourselves.

My proposal is a help class (DynamicControlBuilder) that provides us two methods: GetMappedType and CreateControl.

/// <summary>
/// Gets the mapped <see cref="System.Web.UI.Control"/> type.
/// </summary>
/// <param name="type">The <see cref="System.Web.UI.Control"/> type to be mapped</param>
/// <param name="prefix">The namespace prefix.</param>
/// <returns>A <see cref="System.Type"/> object.</returns>
public static Type GetMappedType(Type type, string prefix)
{    
    if (!typeof(Control).IsAssignableFrom(type))    
    {          
         throw new ArgumentOutOfRangeException("type", "Must inherit from Control.");    
    }    
    Type mappedtype;    
    if (!string.IsNullOrEmpty(prefix))    
    {        
        TagPrefixInfo prefixinfo;        
        if (!m_prefixes.TryGetValue(prefix, out prefixinfo))        
        {            
            throw new ArgumentException("prefix", "No prefix found.");        
        }        
        else        
        {            
            type = BuildManager.GetType(string.Format("{0}.{1}, 
            {2}", prefixinfo.Namespace, type.UnderlyingSystemType.Name, 
	   prefixinfo.Assembly), false);            
            if (type == null)            
            {                
                throw new ArgumentException("type", 
		"Control not found within specified prefix.");            
            }        
        }    
    }    
    if (m_tagMappings.TryGetValue(type.UnderlyingSystemType, out mappedtype))    
    {        
        return mappedtype;    
    }    
    return type;
}
/// <summary>
/// Creates a dynamic mapped <see cref="System.Web.UI.Control"/>.
/// </summary>
/// <param name="type">The <see cref="System.Web.UI.Control"/> type to be mapped</param>
/// <param name="prefix">The namespace prefix.</param>
/// <returns>A <paramref name="T"/> object.</returns>
public static Control CreateControl(Type type, string prefix)
{    
    Type mappedType = GetMappedType(type, prefix); ;    
    return (Control)Activator.CreateInstance(mappedType);
}

The main goal is to enable any of the following usages:

this.Page.Controls.Add(DynamicControlBuilder.CreateControl
	<System.Web.UI.WebControls.TextBox>("foo"));
this.Page.Controls.Add(DynamicControlBuilder.CreateControl
	(typeof(System.Web.UI.WebControls.TextBox), "foo"));
this.Page.Controls.Add(DynamicControlBuilder.CreateControl
	(typeof(System.Web.UI.WebControls.TextBox)));

Try it!