There’ve been numerous times I’ve been involved with projects where there was a need for dynamically generating email content and sending it on its way.  Throughtout these projects, I’ve seen various different approaches to solving this business need, some of which include:

1. Shoving markup within resource files with token placeholders such as “@@FirstName@@”, followed by a round of regular expression replacing throughout before sending.
2. Using the more recent T4 text templates, which I personally found to be rather cumbersome for such a simple concept.  These might be more useful for non-webby types of needs.
3. A varied flavor of #1, but replace resource file with database table (don’t ask).

Needless to say I was recently faced with a project in need of such a task.  In this particular situation, I had wired up some front-end logic to quietly call a WCF web service via jquery through ajax.  I thought about some alternatives for generating the final email output that would lend themselves to be both flexible yet lightweight and came up with a nifty compromise that works excellently.  Please keep in mind that I’ve trimmed some aspects of the code down, as not to divulge project-specific information but the core concepts are present.

Code within WCF service

//Creating an instance of a basic page and adding our emailTemplate control to it
Page page = new Page();
EmailTemplate emailTemplate = (EmailTemplate)page.LoadControl("/UserControls/General/EmailTemplate.ascx");

//Setting data within our emailTemplate
emailTemplate.FromName = fromNameClean;
emailTemplate.GroupName = groupNameClean;
//......

//Telling our control to bind the data to its view layer
emailTemplate.BindData();

//Retrieving the final rendered markup from our control (body of the email in HTML format)
string body = emailTemplate.RenderControl();

Code for our custom extention method RenderControl()

/// <summary>
/// Provides an overload for web controls to return the html representation of the final rendered output in string format.
/// </summary>
public static string RenderControl(this Control control)
{
	StringBuilder sb = new StringBuilder(); 

	using (StringWriter sw = new StringWriter(sb))
		using (HtmlTextWriter tw = new HtmlTextWriter(sw))
			control.RenderControl(tw); 

	return sb.ToString();
}

Code for our EmailTemplate user control code behind

public partial class EmailTemplate : System.Web.UI.UserControl
{
	public void BindData()
	{
		fromName.Text = FromName;
		groupName.Text = GroupName;
		//......
	}

	public string FromName
	{
		get
		{
			return _fromName;
		}
		set
		{
			_fromName = value;
		}
	}

	private string _fromName;

	public string GroupName
	{
		get
		{
			return _groupName;
		}
		set
		{
			_groupName = value;
		}
	}

	private string _groupName;
}

For my more astute readers, you might have noticed that there’s no page lifecycle methods in our user control, as there’s really no need since this user control is being treated very similarly to the MVC view model construct, albeit slightly varied due to the nature of web forms.

As for the markup layer of our EmailTemplate control, there’s nothing particularly special to notate, just some basic html with your server controls you plan on binding your data to.

Some of the benefits to this approach that come to mind include:

1. Extremely low overhead in terms of code.
2. Ability to adjust markup without rebuilding your code (compared to solutions such as resource files), unless of course your changes include additional dynamic data that needs binding.
3. Ease of understanding across developers, as the email templates are represented as simple light-weight user controls.

Cheers,
Chris