@PCSWebLabs

Use LINQ to Query ASP.Net Control Data

ramon_tristani — Wed, 08 Jul 2009 00:15:42 +0000

Overview

[inline][/inline]

The purpose of this article is to demonstrate the use of LINQ for the purpose of searching and manipulating elements from repeating controls such as an ASP.Net CheckboxList. This exercise will consist of a simple WebForm that allows the user to select a series of checkbox list items by searching within the list for all items containing a user defined string value. If you haven't done so already, please load Visual Studio and create a new web site or web application project.

The User Interface

We begin by creating a WebForm in the application. You may also opt for using the Default.aspx WebForm created by default. We will need to add the following controls:

A TextBox
A Button
A CheckboxList

I have, for demonstration purposes, created the user interface with Ajax support using the built in Ajax functionality of ASP.Net. The resulting markup is as follows:


	
		
			Select items containing:

Now that we have the basics, we can move on to the fun part of this exercise; the LINQ implementation that will add search based selection of the checkbox ListItem elements we've added to the list.

Implementation

We begin by creating an event handler method for the "selectFromList" button in the code behind class. This method should perform the following steps:

Clear previously checked items
Retrieve all items that contain text as entered by the user
Loop through all found items and change their state to "Selected"
Clear search criteria

Having established the necessary steps to fully implement our search and select functionality, we are now ready to write each step in code in the search button click event handler method as follows:

/// 
/// Handles search button click events
/// 
/// 
/// 
protected void selectFromList_Click(object sender, EventArgs e)
{
	// Clear all selections
	testList.ClearSelection();

	// Check for a valid string prior to executing 
	// any searches
	if (!string.IsNullOrEmpty(containsText.Text))
	{
		// Fetch all list items that match the search criteria
		// NOTE: Checkbox ListItem and search criteria text is
		// converted to lower case
		List results = (from ListItem item in testList.Items
				   where item.Text.ToLower().Contains(containsText.Text.ToLower())
				   select item).ToList();

		// When we've foound matches...
		if (results.Count > 0)
		{
			// ...loop through the results and change the checkbox state to selected
			foreach (ListItem item in results)
				item.Selected = true;
		}

		// Finally, we clear the search field
		containsText.Text = string.Empty;
	}
}

As described by the code within the search button's click event handler, the first step of our implementation deal with clearing all previously selected items by invoking the "ClearSelection" method exposed by the CheckboxList control. After verifying that a valid search string was entered by the user, we execute a LINQ query against the CheckboxList control items collection and return our matches as a list of ListItem objects with the following:

List results = (from ListItem item in testList.Items
	where item.Text.ToLower().Contains(containsText.Text.ToLower())
	select item).ToList();

It is important to note that the object qualifier withing the query, "item", is indeed given a type reference of ListItem. Without this, the query simply would not work, and further, our code would not compile. All the query is responsible for at this point is to fetch all items that contain the search string specified by the user in the "containsText" TextBox control. If we have found matches, we can then process each match by changing its checked state to checked and clearing the search field with the following:

// When we've foound matches...
if (results.Count > 0)
{
	// ...loop through the results and change the checkbox state to selected
	foreach (ListItem item in results)
		item.Selected = true;
}

// Finally, we clear the search field
containsText.Text = string.Empty;

Our implementation is now complete

Conclusion

In this article we have demonstrated the versatility of LINQ and used it to query control data. As shown, LINQ is a powerful tool in your arsenal that can help you write shorter, more efficient code without having to depend on complex looping and searching of item collection data.

Get the source code for this article.

JSON Parameter String Builder

ramon_tristani — Tue, 07 Jul 2009 23:14:21 +0000

Overview

[inline][/inline]

In continuing my love affair with code generation or using code to create code, we will be creating a small jQuery based utility for creating JSON parameter strings that can be used as parameter strings to page/web methods when making Ajax calls with jQuery. While creating these strings is mostly a trivial task, the formatting that is required between parameter names and values could be error prone when build manually due to the mixing of double quotes, single quotes and the concantenation of parameter names and values. The utility we will be creating will accept two comma delimited strings, one containing parameter names and the other their matching values, combine them and output these together in JSON data parameter format.

The User Interface

The UI for this utility is rather simple. I have added some styling to make things look "nice-a-little", but you may chose to style things to fit your needs. The UI consists of

a fieldset
a table
two label elements
two text boxes
a button
a div element where the output will be shown

I have used the following markup to create the UI for the utility:


	
		
			JSON Parameter Format Builder
		
	
	
		
			
				
					
						Parameter Names (P1,P2,P3):
					
				
				
					
				
			
			
				
					
						Parameter Values (V1,V2,V3):

Once the UI has been created, we can move to the implementation details

The Implementation

The implementation of our utility is very simple because it is 100% coded with JavaScript using jQuery. In order for the utility to work correctly, it will need to do the following:

Determine whether both, the parameter names string and parameter values string contain the same number of elements when split by their delimiter; in this case a comma character.
Fetch the value of the parameter names field.
Fetch the value of the parameter values field.
If both strings do not contain the same number of elements when split into arrays, the user should be alerted of the input error
If both strings contain the same number of elements when split into arrays, then begin formatting the return string value by attaching required characters by the JSON parameter string syntax and attach parameter to value by way of a looping control structure.
Return the string

The following JavaScript code implements our requirements:

$(document).ready(function() {
	// Returns a parameter string in json format
	function retrieveParamFormat(paramNames, paramValues) {
		var format = "";
		var lengthsMatch = paramNames.split(",").length == paramValues.split(",").length;

		if (lengthsMatch) {
			var names = paramNames.split(",");
			var values = paramValues.split(",");

			// Prefix parameter string
			format = "{";

			// Build parameter string
			for (var i = 0; i < names.length; i++) {
				format += "'" + names[i] + "':'" + values[i] + "'";

				if (i < (names.length - 1)) {
					format += ",";
				}
			}
			
			// Close parameter format
			format = format + "}"
		}else{
			format = 'Parameter vs. Value mismatch';
		}

		return format;
	}

	// Retrieves a json formatted parameter string
	$('#getParameterFormat').click(function() {
		var paramNames = $('#parameterNamesField').val();
		var paramValues = $('#parameterValuesField').val();

		if ((paramNames == '') || (paramValues == ''))
			alert('Parameter Names and Parameter Values are required');
		else
			$('#parameterFormatValue').html(retrieveParamFormat(paramNames, paramValues));
	});
});

Demo

JSON Parameter Format Builder

Parameter Names (P1,P2,P3):
Parameter Values (V1,V2,V3):

Use Case

Now that we have a function that will create JSON parameter strings for us all we have to do is utilize its output with an actual Ajax call to a web service. The following is a sample of how this can be achieved:

var serviceUrl = 'http://www.someservicehost.com/someservice.asmx/somemethod';

// Get parameter format
var format = retrieveParamFormat('name,age,address', 'Ramon E. Tristani,39,some address in the beautiful state of WA');

// Execute Ajax call
$.ajax({
	type: 'POST',
	url: serviceUrl,
	data: format,
	contentType: 'application/json; charset=utf-8',
	dataType: 'json',
	success: function(result) {
		$('#<%= pageMethodNameGreetingField.ClientID %>').val(result.d);
	},
	error: function() {
		alert('An error occurred while accessing the the following web service:\n'
			+ serviceUrl);
	}
});

In the aove sample I have provided hard-coded strings. In a real life situation however, these values should come from data input elements within the HTML document

Conclusion

In this article we have created a simple utility to automate the creation of data parameter strings used in Ajax calls. Having quick utility functions like these that handle repetitive tasks is important as it will reduce the amount of debugging and application showstopping points, while increasing application maintainability.

Get the source code for this article.

Web Service Calls With jQuery Ajax

ramon_tristani — Mon, 06 Jul 2009 03:28:35 +0000

Overview

[inline][/inline]

In this article we will explore web service calls with jQuery Ajax from ASP.Net webforms. We will be doing this without the use of an ASP.Net UpdatePanel by performing all Ajax calls directly with jQuery. In my opinion, Ajax calls are far more efficient when making the Ajax call directly because we bypass the overhead of update panels, refreshing the HTML we want to refresh directly, rather than refreshing all the content of the UpdatePanel ContentTemplate HTML on every partial postback. While there is JavaScript code to be written to accomplish this, the impact is minimal and with some usage and experience, the task becomes trivial over time.

The User Interface

We begin by creating an ASP.Net web application in Visual Studio .Net. By default, the project template will create the Default.aspx WebForm which will be a suitable WebForm to use for the purposes of this tutorial. Once the project is created, make sure a reference to the jQuery Library has been made by adding the appropriate script tags to the HEAD element of the Default.aspx WebForm. Let's begin by creating the following user interface:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="WebServiceCallsArticleUI.aspx.cs" Inherits="jQueryWebServicesAndPageMethods.WebServiceCallsArticleUI" %>



	Web Service Calls With jQuery Ajax
	
	
	


	
	
		
			Using jQuery Ajax
		
		
			Web Service Calls with Ajax
			
				
					From Web Service:
				
				
				
				
				
			
		
		
			Web Service Calls with Ajax (with parameters)
			
				
					First Name:
				
				
				
				
				
					Greeting:
				
				
				
			
		
		
			Adding Items to a List From a WebService
			
				
					List Items:

Once the UI is created, we should end up with something similar to the following screen capture:

User Interface

While we are at it, do save the progress indicator image shown in the screen capture by right clicking the image below and saving it to the images folder in your web application. We will be using this image as a progress indicator for each of our fieldset elements as we execute each Ajax call.

Progress Indicator

Now that we have a UI to work with we can assume that we will be making 3 different Ajax calls. These are:

A call to retrieve a greeting from a web service similar to "Hello World"
A call to retrieve a greeting from a web service by passing a first name parameter
A call to retrieve a list of greetings from a web service that will populate a dropdown list

The web methods we will be calling have been made extremely simple just for the purpose of demonstrating the concepts involved in making these Ajax calls. However, using this methodology, you are certainly able to create more complex methods that return more complex data. That said, the first two calls will be returning simple strings, while the last call we will use for populating the dropdown list, will return an object of type

List

Let's get started!

Web Service Implementation

The first thing that we must do is create a web service application in the same solution where we created our web application. I chose to name this project

SampleServices

Once the web service application project has been created, the application should be converted to an IIS web application if IIS is available in the development system. To do so, follow these steps:

Right click the web service application project and select "Properties" from the context menu
In the properties window, select the "Web" tab on the left side of the properties window.
Click the "Use Local IIS server" option towards the bottom of the options window
While I chose to use "http://localhost/SampleServices" for my virtual directory, you may chose an URL of your choice.
Save the properties and close the properties window

Now that we have a local IIS site, we are able to provide this address to the URL parameter of the ajax call within the jQuery code. By default, when the web service application was created, Visual Studio created a default web service called

Service1.asmx

Go ahead an delete that service and add a new one called

SimpleService.asmx

Once the new service class has been created, right click the file and select "View Code" from the context menu and add the following code:

namespace SampleServices
{
	/// 
	/// Summary description for SimpleService
	/// 
	[WebService(Namespace = "http://tempuri.org/")]
	[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
	[System.ComponentModel.ToolboxItem(false)]
	[System.Web.Script.Services.ScriptService]
	public class SimpleService : System.Web.Services.WebService
	{
		[WebMethod]
		public string HelloWorld()
		{
			System.Threading.Thread.Sleep(500);
			return "Hello World From Web Service";
		}

		[WebMethod]
		public string HelloWho(string name)
		{
			System.Threading.Thread.Sleep(500);
			return string.Format("Hello {0}!", name);
		}

		[WebMethod]
		public List GreetingList()
		{
			System.Threading.Thread.Sleep(500);
			List retVal = new List();
			retVal.Add("Jim");
			retVal.Add("John");
			retVal.Add("Joe");

			return retVal;
		}
	}
}

We now have three web methods with the following names and purpose:

HelloWorld: Will return a hard coded greeting string
HelloWho: Will return a formatted string with a parameter passed into it by the caller
GreetingList: Will return a string array containing names that will be further formatted to show greetings in list fashion

Once the service is complete, build the project and if all goes well, close the web service class editor as we have now fully implemented the web service itself and will be focusing on the JavaScript we need in order to bring the UI and the web service work together.

jQuery Implementation

If not already open for editing, open the Default.aspx webform in source view and locate the following empty script tag we created along with the UI:

We will be doing the bulk of our work inside of the "$(document).ready" event. One of the nicest things about jQuery is the way that it wires up all page control events when the document first loads. This way, we are not constrained into coding events into our html elements and thus truly separating UI implementation from UI behavior. We will then take advantage of this functionality and begin wiring up a set of element events that when fired, will in turn execute Ajax calls against the web service we have already created. Let's begin by adding the following code inside of the "$(document).ready" event carefully noting the variable "indicatorID which resides outside of "$(document).ready":

// Progress indicator placeholder var
var indicatorID = '';

$(document).ready(function() { 
	// Hide all progress indicators
	$('.progressIndication').hide();
			
	// Clears reseting of web service value
	$('#serviceValueReset').click(function() {
		if ($('#serviceGreetingTextField').val() == '')
			alert('The field is empty');
		else
			$('#serviceGreetingTextField').val('');
	});

	// Retrieves a greeting from a web service
	$('#serviceMethodGetGreeting').click(function() {
		// Set indicator id
		indicatorID = '#serviceGreetingIndicator';

		// Clear field value
		$('#<%= serviceGreetingTextField.ClientID %>').val('');

		// Ajax URL
		var serviceUrl = 'http://localhost/SampleServices/SimpleService.asmx/HelloWorld';

		// Execute Ajax call
		$.ajax({
			type: 'POST',
			url: serviceUrl,
			data: '{}',
			contentType: 'application/json; charset=utf-8',
			dataType: 'json',
			success: function(result) {
				$('#<%= serviceGreetingTextField.ClientID %>').val(result.d);
			},
			error: function() {
				alert('An error occurred while accessing the the following web service:\n'
				+ serviceUrl);
			}
		});
	});
});

Outside of the "$(document).ready" event add the following code:

// Progress indicator
$(document).ajaxStart(function() {
	if (!(indicatorID == '')) {
		$(indicatorID).show();
	}
}).ajaxStop(function() {
	if (!(indicatorID == '')) {
		$(indicatorID).hide();
		indicatorID = '';
	}
});

We have accomplished three things here:

$('#serviceValueReset').click: We have created an event for the reset button on the first fieldset element that will clear any data already present in any of the fields located within the first fieldset.
$('#serviceMethodGetGreeting').click: We have created an event that will execute the Ajax call against the web service method that will in turn return a value that will populate the "serviceGreetingTextField" textbox.
$(document).ajaxStart().ajaxStop(): We have created the necessary plumbing that will allow our webform to display a progress indicator next to the elements that will be affected by the Ajax call

...and this is how this works:

$('#serviceValueReset').click references the textbox element and detects whether it is necessary to clear it or not, alerting the user of this fact. If the field has content, it simply clears it by setting its value to an empty string.
$('#serviceMethodGetGreeting').click responds to click events fired by the "serviceMethodGetGreeting" button. Next it sets the "indicatorID" variable to the indicator image ID associated with the element being updated by the ajax call to the web service. After this is done, the textbox is cleared of any content by setting its value to an empry string. Now that the form is ready to be updated, the web service URL along with the method we intend to call is stored in string format into a variable. It is important to make sure this URL is formatted correctly or else the call will simply fail.
$.ajax is given all the options it needs in order to execute the call to the web service by setting the following options
- type: Since we are using JSON, this value is set to use the "POST" form method.
- url: This is the web service [URL + "/" + METHOD_NAME]
- data: Since we are not passing parameters to the web service, we pass the JSON equivalent of NULL "{}"
- contentType: The application content type which happens to be "application/json; charset=utf-8"
- dataType: THis value is set to "json" since this is the format in which we are making the call to the web service
- success: This is a callback function that will be executed if the Ajax call was successful and therefore the function we use in order to update the form elements
- error: This is the callback function that will be executed in the unfortunate event an error occurs. It simply displays an alert to the user stating that an error has occurred.
$(document).ajaxStart().ajaxStop(): This is where our progress indicators are shown or hidden. They are displayed when the Ajax call is initiated and hidden upon termination. This is why the "indicatorID" variable is set when the "serviceMethodGetGreeting" is fired. In this way, the "$(document).ajaxStart().ajaxStop()" events are aware of which indicator to show or hide and when.

jQuery Implementation... The Rest

Having now implemented the support code for the first fieldset element on the webform, we can now add the rest of the code and go through the highlights of what it is doing differently from the code we've just implemented. Add the following code below the "$('#serviceMethodGetGreeting').click" event block:

// Retrieves a greeting from a web service by passing parameters
$('#getServiceNameGreeting').click(function() {
	var firstName = $('#<%= serviceNameField.ClientID %>').val();
	if (firstName != '') {
		// Set indicator id
		indicatorID = '#serviceNameGreetingIndicator';

		// Clear field value
		$('#<%= serviceNameGreetingField.ClientID %>').val('');

		// Ajax URL. 
		var serviceUrl = 'http://localhost/SampleServices/SimpleService.asmx/HelloWho';

		// Get parameter format
		var format = "{'name':'" + firstName + "'}";

		// Execute Ajax call
		$.ajax({
			type: 'POST',
			url: serviceUrl,
			data: format,
			contentType: 'application/json; charset=utf-8',
			dataType: 'json',
			success: function(result) {
				$('#<%= serviceNameGreetingField.ClientID %>').val(result.d);
			},
			error: function() {
				alert('An error occurred while accessing the the following web service:\n'
					+ serviceUrl);
			}
		});
	} else {
		alert('First Name is required');
	}
});

// Clears reseting of web service value
$('#resetServiceNameGreeting').click(function() {
	if ($('#serviceNameField').val() == '' || $('#serviceNameField').val() == '')
		alert('The field is empty');
	else {
		$('#serviceNameField').val('');
		$('#serviceNameGreetingField').val('');
	}
});

$('#testListAddItems').click(function() {
	// Set indicator id
	indicatorID = '#testListIndicator';

	// Ajax URL. 
	var serviceUrl = 'http://localhost/SampleServices/SimpleService.asmx/GreetingList';

	// Execute Ajax call
	$.ajax({
		type: 'POST',
		url: serviceUrl,
		data: '{}',
		contentType: 'application/json; charset=utf-8',
		dataType: 'json',
		success: function(result) {
			$.each(result.d, function(i, text) {
				$('#<%= testList.ClientID %>').append($('').val(i).html('Hello ' + text));
			});
		},
		error: function(xmlHttpRequest, status, error) {
			var errorStatus = xmlHttpRequest.status;
			var errorText = xmlHttpRequest.responseText;
			var statusText = xmlHttpRequest.statusText;

			alert('Error Status: ' + errorStatus + '\n'
				+ 'Error Message: ' + errorText + '\n'
				+ 'Status Info: ' + statusText + '\n');
		}
	});
});

// Resets the test list
$('#testListReset').click(function() {
	$('#<%= testList.ClientID %> >option').remove();
	$('#<%= testList.ClientID %>').append($('').val('-1').html('-- Select --'));
});

And now the highlights...

As seen in the first example, an event is attached to each of the buttons that will trigger an Ajax call. In this case, the "$('#getServiceNameGreeting').click" event is attached to the "getServiceNameGreeting" button. In addition to the usual boiler-plate code in which we set up the service URL and Ajax parameters, we created a parameter format variable that contains the "parameter name/value" pair that must be passed to the web service for the intended web service call. This parameter format is very important because a simple typo will force the Ajax event to fire the "error" callback instead of the "success" callback and therefore failing the exacution of the web service call. The syntax for this format is not very complicated but rather easy to mess up, especially when more than one parameter must be used. In short, if the WebMethod signature contains parameters "p1, p2, p3" then our parameter string should look like the following:

{'p1':'v1','p2':'v2','p3':'v3'}

As seen above, good attention to detail should be exercised when building these strings because even though it is a very simple string format, it is even simpler to get mess up. Once we get passed the parameter format, the Ajax call is exacuted against the web service in much the same fashion as before

The last part of the implementation deals with binding a dropdown list from yet another web service method. In this case, the web service call is nearly identical to the first service call in our implementation. The one difference is that while the first two code implementations dealt with string results being returned from the web services, the last web method we will call will return an object of type List as an array of strings. We must remember that this Ajax call is of type JSON and as such, these list items will be return as arrays; remembering that JavaScript is type agnostic.

Understanding this, all that remains is the addition tof the

Conclusion

In this we have covered the very basic concepts of executing Ajax calls against web services, returning values, arrays, passing parameters and manipulating UI elements to respond to Ajax activity. Additionally we have explored the flexibility that making these calls manually will give you as you dig deeper and move away from the usual update panel here and update progress there pattern of ASP.Net Ajax controls. While these methods are useful and certainly worth learning, learning how not to depend on those controls will be a skill you will thank your self over and over again for learning when blackbox code such as that of ASP.Net Ajax fails or behaves buggy and erratic.

Get the source code for this article.

Code Generation Part II – Creating a Code Generator With C#, XML and XSLT

ramon_tristani — Sat, 06 Jun 2009 22:16:02 +0000

Overview

[inline][/inline]

This article is the second in a series of Code Generation articles that will demonstrate the basic concepts of using code in combination with freely available tools to generate code and eliminate hours of tedious and repetitive work. This article builds on the previous article in both knowledge and code and is recommended reading prior to moving forward. In this article we will examine key concepts in generating code from XML metadata with XML related objects from the System.Xml.Xsl assembly of the Microsoft .Net Framework. This article will deal with the following and build upon:

Specifying new elements in the App.config file, wrapping the keys in the LibraryConstants class, and new properties to the CoreBase class that will expose values set in the App.config file
Add support enumerations and classes to the CodeGenerator.Core assembly
Creating the CodeBuilder class that will derive from MetadataGenerator in order to create a single point of execution for code generation purposes
Create basic templates for the generation of stored procedures based on our database schema
Modifying the CodeGenerator application to make use of the finished CodeGenerator.Core assembly

Review

At this stage in the Code Generation project we have a basic console application that is able to extract SQL Server database metadata from the code generation target and display this data in XML format to the output screen. The application is able to do this by way of the CodeGenerator.Core assembly. It is this assembly that we will continue to expand further and give the assembly the ability to not just retrieve required metadata, but use this metadata for code generation purposes.

Configuration Options

We begin this section with the App.config file in the console application. We must edit this file in order to add information about XSL template file paths as well as generator output paths. Once the App.config has been fully modified, we will add the configuration keys to the LibraryConstants class and further modify the CoreBase class to expose these configuration elements as properties to all derived classes. Before we do so, let's first modify the console application project and add stub files (empty files) for the XSL templates. We will code these templates last as doing so now will become a distraction from our main goal which is to build a code generator. Let's begin by adding a folder to the console application project and naming it "Templates". Once done, add the following stub XSL files and name them as shown here:

Templates
- DeleteProcedure.xsl
- InsertProcedure.xsl
- SearchProcedure.xsl
- SelectProcedure.xsl
- UpdateProcedure.xsl

We are now ready to modify the App.config file and add template path information. To do so, load the configuration file in Visual Studio and add the following elements to the "appSettings" section:

Next, we need to modify the path to the XSL templates in the configuration elements. We do this by deleting the data in the "value" attribute of the element and from the solutions explorer, drag and drop the XSL template file into the value attribute. The result of this operation will be the inclusion of the file path directly into the value attribute of the configuration element.

The next task at hand will be to modify the CodeGenerator.Core.LibraryConstants class. Load this class and modify the file by adding the following constants:

/// 
/// Code file output root directory key
/// 
public const string OUTPUT_ROOT = "OutputRoot";
/// 
/// Delete procedure template path
/// 
public const string TEMPLATE_PATH_DELETE_PROCEDURE = "DeleteProcedureTemplatePath";
/// 
/// Insert procedure template path
/// 
public const string TEMPLATE_PATH_INSERT_PROCEDURE = "InsertProcedureTemplatePath";
/// 
/// Search procedure template path
/// 
public const string TEMPLATE_PATH_SEARCH_PROCEDURE = "SearchProcedureTemplatePath";
/// 
/// Select procedure template path
/// 
public const string TEMPLATE_PATH_SELECT_PROCEDURE = "SelectProcedureTemplatePath";
/// 
/// Update procedure template path
/// 
public const string TEMPLATE_PATH_UPDATE_PROCEDURE = "UpdateProcedureTemplatePath";
/// 
/// Stored procedures folder name
/// 
public const string FOLDER_NAME_STORED_PROCEDURE = "Stored Procedures";

These are the constants that we will use against the properties being exposed by the CoreBase class. Load the CoreBase class and modify the class by adding the following properties:

/// 
/// Gets OutputFolderRoot
/// 
protected string OutputFolderRoot
{
	get
	{
		return ConfigurationManager.AppSettings[LibraryConstants.OUTPUT_ROOT];
	}
}
/// 
/// Gets DeleteProcedureTemplatePath
/// 
protected string DeleteProcedureTemplatePath
{
	get
	{
		return ConfigurationManager.AppSettings[LibraryConstants.TEMPLATE_PATH_DELETE_PROCEDURE];
	}
}
/// 
/// Gets InsertProcedureTemplatePath
/// 
protected string InsertProcedureTemplatePath
{
	get
	{
		return ConfigurationManager.AppSettings[LibraryConstants.TEMPLATE_PATH_INSERT_PROCEDURE];
	}
}
/// 
/// Gets SearchProcedureTemplatePath
/// 
protected string SearchProcedureTemplatePath
{
	get
	{
		return ConfigurationManager.AppSettings[LibraryConstants.TEMPLATE_PATH_SEARCH_PROCEDURE];
	}
}
/// 
/// Gets SelectProcedureTemplatePath
/// 
protected string SelectProcedureTemplatePath
{
	get
	{
		return ConfigurationManager.AppSettings[LibraryConstants.TEMPLATE_PATH_SELECT_PROCEDURE];
	}
}
/// 
/// Gets UpdateProcedureTemplatePath
/// 
protected string UpdateProcedureTemplatePath
{
	get
	{
		return ConfigurationManager.AppSettings[LibraryConstants.TEMPLATE_PATH_UPDATE_PROCEDURE];
	}
}

As seen in the CoreBase code we added, all new element values from the configuration file have been properly exposed by way of the CoreBase class and therefore being made available to all derived classes within the CodeGenerator.Core assembly and concludes the configuration support for the purposes of this article.

Support Enumerations

Before we create the CodeBuilder class, we will need two enumerations

FolderTypes
TemplateTypes

These enumerations will control and identify necessary generation operations and help the assembly determine paths for generated outputs. Usage of these enumerations will become more clear as we move along. Add a new class file to the CodeGenerator.Core assembly and name it "FolderTypes". When loaded in the editor, modify the file to contain the following code:

#region Using namespaces...
using System;
#endregion

namespace CodeGenerator.Core
{
	/// 
	/// FolderTypes enumeration
	/// 
	public enum FolderTypes
	{
		/// 
		/// StoredProcedureOutput folder type enumeration member
		/// 
		StoredProcedureOutput
	}
}

The next enumeration to create will be the TemplateTypes enumeration. Again, add a new class file to the CodeGenerator.Core assembly, name it "TemplateTypes" and add the following code to the file:

#region Using namespaces...
using System;
#endregion

namespace CodeGenerator.Core
{
	/// 
	/// TemplateTypes enumeration
	/// 
	public enum TemplateTypes
	{
		/// 
		/// StoredProcedureTemplates template type enumeration member
		/// 
		StoredProcedureTemplate
	}
}

All necessary support plumbing should be in place now and therefore, we are now able to move on to the CodeBuilder class.

On to Code Generation

Code generation is a process that involves many smaller steps and while it might seem like a complex process, in reality it is a very simple process depending on how the process is divided and data is organized. We begin organizing these code generation tasks with the creation of the CodeBuilder class in the CodeGenerator.Core assembly. Once loaded add the following code to the file:

#region Using namespaces...
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Xml.Linq;
using System.Collections;
using System.IO;
using System.Xml.Xsl;
using System.Xml;
using System.ComponentModel;
#endregion

namespace CodeGenerator.Core
{
	/// 
	/// CodeBuilder class
	/// 
	public class CodeBuilder : MetadataGenerator, INotifyPropertyChanged
	{
		#region Events
		/// 
		/// PropertyChanged event
		/// 
		public event PropertyChangedEventHandler PropertyChanged;
		#endregion

		#region Members
		/// 
		/// Metadata field
		/// 
		private string metadata = string.Empty;
		/// 
		/// OutputMessage field
		/// 
		private string outputMessage = string.Empty;
		#endregion

		#region Properties
		/// 
		/// Gets Metadata
		/// 
		private string Metadata
		{
			get
			{
				// Retrieve XML
				if (metadata.Equals(string.Empty))
					metadata = GetMetadataXml();
				
				return metadata;
			}
		}

		/// 
		/// Gets/Sets OutputMessage
		/// 
		public string OutputMessage
		{
			get
			{
				return outputMessage;
			}
			set
			{
				outputMessage = value;

				// Notify of change
				NotifyPropertyChanged(outputMessage);
			}
		}
		#endregion

		#region Constructors
		/// 
		/// Default class constructor
		/// 
		public CodeBuilder() { }
		#endregion

		#region Utility Methods
		/// 
		/// Handles property change eventing
		/// 
		/// 
		private void NotifyPropertyChanged(String info)
		{
			if (PropertyChanged != null)
			{
				PropertyChanged(this, new PropertyChangedEventArgs(info));
			}
		}		
		#endregion
	}
}

What we have done here is create the basic skeleton of the class that will be responsible for processing the combined extracted metadata and the XSL template data into useful output that will meet our code generation requirements. As seen in the class signature and class implementation, the CodeBuilder class derives from MetadataGenerator and INotifyPropertyChanged. We derive from MetadataGenerator as a way to maintain the inheritance tree within the classes in the assembly and to provide an in memory persisting mechanism for the retrieved metadata without having to access the generation target database continuously throughout the process of creating our file output. We also implement INotifyPropertyChanged as a way to provide message notifications to the application consuming our assembly about the step the code generation process is engaged in. While this isn't strictly necessary, it is a nice feature to have as it maintains the end user informed about the inner happenings of the component executing within the context of the application. For this purpose, every single time that the string property "OutputMessage" is modified, "NotifyPropertyChanged" is invoked and the "PropertyChanged" event is raised sending whatever message we want to the user about the current executing process.

The Code Generation Process

Before we begin writing the necessary code to support code generation against the metadata, we will need a series of support methods and a class that will allow us to write to the file system. We will begin by creating a static public class called "FileSystemUtility". This class will expose two static methods:

CreateDirectory: Will create an output folder and return its path to the caller
SaveTransformedSourceToFile: Will parse generated XML and output the content of the "codefile" nodes to the file system

At this point you might be thinking: "More XML and codefile nodes?". A brief explanation is in order. The job of the code generator is to make use of XSL templates that will transform XML metadata belonging to the generation target database. Once the transformation process has completed, the transformed data will be in XML format. The beauty of this approach is that prior to saving and as part of the output to disk, this generated XML data, which contains all of the files we will output, can be queried by using LINQ to XML, ripped apart and saved to files. The following schema represents the output of the XSL transformation against the database we have created on Part I of this code generation series:

As seen in the XML schema fragment, all file content will be safely stored within the CDATA section of the "codefile" element, and the generated file name of the resulting file will be stored in the "filename" attribute of the codefile element. Armed with this knowlege, we are ready to begin coding!

Add a new static class file to the CodeGenerator.Core assembly and name it "FileSystemUtility". After the class file is added, right-click on the references folder of the assembly and add a reference to the System.Web assembly. We do this because we will make use of the HttpUtility.HtmlDecode method to decode the conversion that occurs during the transformation process of characters into HTML entities. Once done with that step, add the following code to the class:

#region Using namespaces...
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml.Linq;
using System.Web;
#endregion

namespace CodeGenerator.Core
{
	/// 
	/// FileSystemHandler class
	/// 
	static public class FileSystemUtility
	{
		#region Utility Methods
		/// 
		/// Handles the creation of output folders
		/// 
		/// 
		static public string CreateDirectory(string outputFolder, FolderTypes folderType)
		{
			// Pre-allocate return value
			string retVal = string.Empty;

			// Create output root folder if it does not exist
			if (!Directory.Exists(outputFolder))
				Directory.CreateDirectory(outputFolder);

			string folderPath = string.Empty;

			// Create output folder
			switch (folderType)
			{
				case FolderTypes.StoredProcedureOutput:
					// Set path
					retVal = Path.Combine(outputFolder, LibraryConstants.FOLDER_NAME_STORED_PROCEDURE);

					// Create folder
					if (!Directory.Exists(retVal))
						Directory.CreateDirectory(retVal);
					break;
			}

			return retVal;
		}

		/// 
		/// Handles saving the transformed XML into separate files to the file system
		/// 
		/// 
		static public void SaveTransformedSourceToFile(string path, byte[] sourceBytes)
		{
			// Build sources from XML
			string stringFromSourceBytes = HttpUtility.HtmlDecode(Encoding.ASCII.GetString(sourceBytes));
			XElement source = XElement.Parse(stringFromSourceBytes, LoadOptions.PreserveWhitespace);

			// Retrieve codefile nodes
			List codeFiles = (from elements in source.Descendants("codefile") select elements).ToList();

			// Parse result
			foreach (XElement element in codeFiles)
			{
				// Retrieve file name from element attribute
				string fileName = element.Attribute("filename").Value;

				// Write file to disk
				if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(fileName))
				{
					// Create file stream object
					using (FileStream stream = new FileStream(Path.Combine(path, fileName), FileMode.OpenOrCreate, FileAccess.ReadWrite))
                    {
                    	// Get data bytes
						byte[] writeData = Encoding.ASCII.GetBytes(element.Value);

						// Flush data to disk
						stream.Write(writeData, 0, writeData.Length);
						stream.Flush();
						stream.Close();
                    }
				}
			}
		}
		#endregion
	}
}

Let's examine the "CreateDirectory" method. This method will receive as a parameter the root output folder path. This is the path were all of our files will be stored. This method however does attempt to organize the output structure by also creating a sub-folder for stored procedures. This method can be further edited to include folders for many more objects as templates are created for more than just stored procedures, but C# and even UI's objects as well. For the purposes of this article however, we will only focus on generating stored procedures. Therefore, this method, though it accept a parameter of FolderTypes type, will only handle FolderTypes.StoredProcedureOutput enumeration members. Essentially, the method will simply combine the path of the output folder with the folder name of the stored procedure folder, create the path if not available, and return the path regardless of whether the path exists or not.

Let's now briefly examine the "SaveTransformedSourceToFile" method. This method will accept the path of where the generated files should be saved and a byte array that contains the HTML encoded data that we will be converting back to decoded form and then saving to file. This data, when converted back to a decoded string will look much like the XML schema shown. It is then the responsibility of this method to query the decoded XML string, get the output file name and the codefile node data and then save it to file. There really isn't much more than that to this method and therefore, we can move now to the "CodeBuilder" class that will perform the bulk of the metadata transformation required by the "SaveTransformedSourceToFile" method of the "FileSystemUtility" class.

If not already loaded, open up the CodeBuilder class. We will now add a series of support methods to the class that will allow the object to create output folders, create special data tables to store the generated XML output, retrieve XSL template paths, transform output, and act as a single entry point into the code generation process. To do this, we need to add the following methods to the class:

/// 
/// Performs code generation process
/// 
/// 
public void PerformCodeGeneration(List templateTypesList)
{
	// Retrieve codeStore
	OutputMessage = "Setting up code store data table...";
	DataTable codeStore = GetTransformCodeStore(templateTypesList);
	OutputMessage = "Code store data table setup is complete... Preparing to save data";

	// Process table data
	if (codeStore.Rows.Count > 0)
	{
		OutputMessage = "Processing generated data...";
		foreach (DataRow row in codeStore.Rows)
		{
			// Create output folder
			string outputPath = CreateOutputFolderIfNotExists((TemplateTypes)row["TemplateType"]);
			OutputMessage = string.Format("Created/Verified folder: {0}...", outputPath);

			// Save files to disk
			OutputMessage = "Preparing to save data to disk...";
			if (!string.IsNullOrEmpty(outputPath))
				FileSystemUtility.SaveTransformedSourceToFile(outputPath, (byte[])row["OutputBytes"]);

			OutputMessage = "Successfully saved generated files to disk...";
		}
	}
}

/// 
/// Handles the creation of the output folder if one does not exist
/// 
/// 
/// 
private string CreateOutputFolderIfNotExists(TemplateTypes value)
{
	// Pre-allocate return value
	string retVal = string.Empty;

	// Create output folder
	switch (value)
	{
		case TemplateTypes.StoredProcedureTemplate:
			retVal = FileSystemUtility.CreateDirectory(OutputFolderRoot, FolderTypes.StoredProcedureOutput);
			break;
	}

	return retVal;
}

/// 
/// Returns a data table object that contains transformed data from metadata
/// 
private DataTable GetTransformCodeStore(List templateTypesList)
{
	// Pre-allocate return value
	DataTable codeStore = null;

	if (templateTypesList.Count > 0)
	{
		// Prepare code store
		codeStore = GetCodeStore();

		// Process template types
		OutputMessage = "Retrieving templates...";
		foreach (TemplateTypes templateType in templateTypesList)
		{
			// Retrieve template paths from configuration
			Dictionary templatePaths = GetTemplatePaths(templateType);
			OutputMessage = "Successfully built template dictionary...\n";

			// Parse templates
			foreach (string key in templatePaths.Keys)
			{
				OutputMessage = string.Format("Verifyting {0} template...", key);
				if (File.Exists(templatePaths[key]))
				{
					// Create new row with values
					OutputMessage = "Template verified, proceeding to transform output...";
					DataRow row = codeStore.NewRow();
					row["TemplateType"] = templateType;
					row["OutputBytes"] = Encoding.ASCII.GetBytes(TransformedOutput(templatePaths[key]));

					// Add row to code store
					codeStore.Rows.Add(row);
				}
			}
		}
	}

	return codeStore;
}

/// 
/// 
/// 
/// 
/// 
private DataTable GetCodeStore()
{
	// Pre-allocate return value
	DataTable retVal = new DataTable("CodeStore");

	// Load columns
	retVal.Columns.Add(new DataColumn("TemplateType", typeof(TemplateTypes)));
	retVal.Columns.Add(new DataColumn("OutputBytes", typeof(byte[])));

	return retVal;
}

/// 
/// Returns a transformed version of the metadata
/// 
/// 
/// 
private string TransformedOutput(string templatePath)
{
	// Create transform object and load template
	OutputMessage = string.Format("Loading {0}...", templatePath);
	XslCompiledTransform transform = new XslCompiledTransform(false);
	transform.Load(templatePath);

	// Create the XML reader that will contain the XML metadata extracted from the server
	XmlReader xmlReader = XmlReader.Create(new StringReader(Metadata));

	// Create XML writer settings
	XmlWriterSettings settings = new XmlWriterSettings();
	settings.CloseOutput = true;
	settings.ConformanceLevel = ConformanceLevel.Fragment;
	

	// Create the XML writer that will create the output of the XSL transformation
	StringBuilder retVal = new StringBuilder();
	XmlWriter xmlWriter = XmlWriter.Create(retVal, settings);

	// Transform the metadata into the target code object
	OutputMessage = string.Format("Generating items for {0}...", templatePath);
	transform.Transform(xmlReader, xmlWriter);
	OutputMessage = "SUCCESS!...\n";

	return retVal.ToString();
}

/// 
/// Retrieves template paths
/// 
/// 
/// 
private Dictionary GetTemplatePaths(TemplateTypes value)
{
	// Pre-allocate return value
	Dictionary retVal = new Dictionary();

	// Parse template types
	switch (value)
	{
		case TemplateTypes.StoredProcedureTemplate:
			retVal.Add("SelectProcedure", SelectProcedureTemplatePath);
			break;
	}

	return retVal;
}

The following table explains what each method does:

CreateOutputFolderIfNotExists	This method receives a TemplateType value that in turn, it translates form the purpose of calling the FileSystemUtility.CreateDirectory() method and returning the final output folder for the generated file.
GetCodeStore	This method is responsible for creating a blank table with two columns: A column for the template type. A column for the transformation output in binary form.
GetTemplatePaths	This method accepts a value of TemplateTypes type and in turn returns a dictionary containing the paths of the target templates as exposed by the CoreBase class.
TransformedOutput	This method is primarily responsible for transforming XML metadata into generated code.
GetTransformCodeStore	This method populates the data table that contains the generated code in XML format to be parsed by the FileSystemUtility class.
PerformCodeGeneration	This is the only method that will interact with a calling application. This could be considered the entry point in the code generation process managed by the CodeBuilder class. It accepts a generic list of type "TemplateTypes" that will be passed down to the GetTransformCodeStore() method. For each template type, the class generates requested code.

While brief, the previous walkthroughs through the CodeBuilder class provide insight in how the code generation process works. Now that the CodeGenerator.Core assembly is complete, a quick class diagram of all classes in the assembly should resemble the following:

CodeGenerator.Core Class Diagram

Next, we will create a basic template for a stored procedure that will be responsible for selecting all rows from a database table (the generation target database).

A Simple Template

Before continuing, while this article only covers the creation of one template, the available source code for this article does contain templates for the following stored procedures

Delete Procedure
Insert Procedure
Search Procedure
Select Procedure
Update Procedure

Also, it is not the intention of this article to be a tutorial on XSL programming. The template code is provided "as is" and simply because without templates, the application would not work so well. Disclaimers aside, the templates will follow a very specific structure that conforms to the metadata we have obtained from the generation target database. The templates will perform the following tasks:

Find the root of the metadata XML document
Create a series of variables to be used as shortcuts throughout the template
Iterate through the table elements of the metadata document
Create the file name of the destination file
Insert heading information which will include personalization data if specified to be used
Create the structure of the file

The following is a sample "Select All" type stored procedure template made to work with our metadata:




















<codefiles>





<codefile filename="__Select.sql"><![CDATA[
/******************************************************************************
** Source Database: 
** Object Name: __Select
** Creation Date: 

** Developer Name: 
** Company Name: 
** Position: 
** URL: 
** Copyrignt Information: 
** Legal:
** This source code is protected by the copyright laws of the United States of 
** America and international treaties. Any unauthorized reproduction and/or
** distribution of this source code is strictly prohibited.

******************************************************************************/

IF EXISTS (SELECT * FROM sysobjects WHERE type = 'P' AND name = '__Select')
	BEGIN
		PRINT 'Dropping Procedure __Select'
		DROP  Procedure  [__Select]
	END

GO

PRINT 'Creating Procedure __Select'
GO

CREATE PROCEDURE dbo.[__Select]
AS

-- Disable affected record count
SET NOCOUNT ON

-- Select all data from  and order by primary key
SELECT * FROM [] ORDER BY 
GO

GRANT EXEC ON [__Update] TO public
GO]]></codefile>


</codefiles>

While it may seem like a tedious task (and I often believe it is) to code these templates, the silver lining is that they only have to be coded once and simply used. If well documented, these templates are fairly simple to maintain as requirements for such templates change over time. Having now covered template structure all we have left to do is modify the CodeGenerator console application to make use of the assembly and template we have completed

Putting X, Y, Z to Work Together

It is finally time to finish the application and start generating code files. To do so, we will need to modify the Program class on the CodeGenerator console application. Load the file and add the following code to the Main() method of the class:

/// 
/// Main application entry method
/// 
/// 
static void Main(string[] args)
{
	// Signal start of code generation process
	Console.ForegroundColor = ConsoleColor.Green;
	Console.WriteLine("Starting code generation process: {0}".ToUpper(), 
		DateTime.Now.ToString());

	// Create list of templates to process
	List templatesToProcess = new List();
	templatesToProcess.Add(TemplateTypes.StoredProcedureTemplate);

	// Create code builder and generate code
	Console.ForegroundColor = ConsoleColor.DarkGray;
	Console.WriteLine("\nStarting code generation process...");
	CodeBuilder builder = new CodeBuilder();
	builder.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(builder_PropertyChanged);

	builder.PerformCodeGeneration(templatesToProcess);

	// Signal completion
	Console.ForegroundColor = ConsoleColor.Green;
	Console.WriteLine("\nCode generation process is complete: {0}".ToUpper(), 
		DateTime.Now.ToString());

	// Hang the console
	Console.ForegroundColor = ConsoleColor.DarkGray;
	Console.WriteLine("\n\nPress [Return] to exit...");
	Console.Read();
}

The code simply creates a list of TemplateTypes type and invokes the PerformCodeGeneration method passing the template types list along to the CodeGenerator.Core assembly. Also, as noted in the Main method with the line:

builder.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(builder_PropertyChanged);

we will need to add a static method that will handle messaging to the screen for the application as part of the "INotifyPropertyChanged" implementation of the CodeBuilder class. Therefore, add the following method to the Program class:

/// 
/// Handles PropertyChanged events
/// 
/// 
/// 
static void builder_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
	// Output message to the console
	Console.WriteLine(e.PropertyName);
}

At this point, we are ready to build the application and launch it. If things go well, the application will display a series of messages to the screen and created the necessary output folders specified in the configuration file and all of generated files supported by the provided templates.

Conclusion

In this Code Generation series we have explored the concepts behind code generation and the tools that are available for free to make this task a possibility without having to commit to non-free and rather expensive applications available commercially. While these applications are excellent choices for their intended purpose, their purpose can indeed be achieved by simple means and moderate programming skill while maintaining full control over patterns, design and architecture.

Get the source code for this article.

Code Generation Part I – Extract Database Metadata

ramon_tristani — Fri, 29 May 2009 07:17:57 +0000

Overview

[inline][/inline]

This article is the first in a series of code generation articles that will demonstrate the basic concepts of using code and freely available tools to generate code and eliminate hours of tedious and repetitive work. We will in addition, demonstrate how code generation may be used to create consistent code based on architectural patterns. Instead of presenting all of the concepts involved in code generation all at once, we will peacemeal these concepts into major functional areas. These are:

Extraction of database metadata without the use of SQLDMO or its .NET counterpart SMO
Using LINQ to XML to format all extracted metadata
Using XSLT to generate code on the fly
Using what we've learned with design patterns

Data About Data

Before any code generation can take place, it is very important to obtain as much information about the data store we are trying to generate code for. This descriptive metadata, or "data about data" is at the heart of our code generation process. For the purposes of this article, we will be using Microsoft SQL Server 2008 as our database engine. The concepts discussed in this article could be applied to other database engines as long as specific metadata extraction methodologies, specific to that engine, are used.

Before we go any further however, some friendly advice about naming conventions and style is in order. In this article, as well as any other article or project, Pascal Notation is used, NOT Hungarian Notation. For a comparison and stylistic differences, please refer to Naming Conventions for .NET / C# Projects. Adhering to these conventions will make our resulting code more elegant, descriptive, and natural. The importance of this will become more apparent as we move forward.

First Steps

Now that we have a basic understanding of our requirements, we can now begin by creating our database. For the purpose of this article, a very simple database was created called "CodeGeneration". This is our first step, so please load SQL Server Management Studio and create this database. Use the following SQL script to create the schema by loading a new script editor ensuring that the CodeGeneration database is selected first:

USE [CodeGeneration]
GO
/****** Object:  Table [dbo].[Gender] ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Gender](
	[GenderID] [int] IDENTITY(1,1) NOT NULL,
	[Type] [nvarchar](50) NOT NULL,
	[Created] [datetime] NOT NULL,
	[Updated] [datetime] NOT NULL,
	[IsActive] [bit] NOT NULL,
	[Description] [nvarchar](512) NOT NULL,
 CONSTRAINT [PK_Gender] PRIMARY KEY CLUSTERED 
(
	[GenderID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
/****** Object:  Table [dbo].[Person] ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Person](
	[PersonID] [int] IDENTITY(1,1) NOT NULL,
	[GenderID] [int] NOT NULL,
	[FullName] [nvarchar](50) NOT NULL,
	[Age] [int] NOT NULL,
	[Created] [datetime] NOT NULL,
	[Updated] [datetime] NOT NULL,
	[IsActive] [bit] NOT NULL,
	[Description] [nvarchar](512) NOT NULL,
 CONSTRAINT [PK_Person] PRIMARY KEY CLUSTERED 
(
	[PersonID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
/****** Object:  Table [dbo].[Email] ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Email](
	[EmailID] [int] IDENTITY(1,1) NOT NULL,
	[PersonID] [int] NOT NULL,
	[Email] [nvarchar](50) NOT NULL,
	[Created] [datetime] NOT NULL,
	[Updated] [datetime] NOT NULL,
	[IsActive] [bit] NOT NULL,
	[Description] [nvarchar](512) NOT NULL,
 CONSTRAINT [PK_Email] PRIMARY KEY CLUSTERED 
(
	[EmailID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
/****** Object:  Default [DF_Email_Created] ******/
ALTER TABLE [dbo].[Email] ADD  CONSTRAINT [DF_Email_Created]  DEFAULT (getdate()) FOR [Created]
GO
/****** Object:  Default [DF_Email_Updated] ******/
ALTER TABLE [dbo].[Email] ADD  CONSTRAINT [DF_Email_Updated]  DEFAULT (getdate()) FOR [Updated]
GO
/****** Object:  Default [DF_Email_IsActive] ******/
ALTER TABLE [dbo].[Email] ADD  CONSTRAINT [DF_Email_IsActive]  DEFAULT ((1)) FOR [IsActive]
GO
/****** Object:  Default [DF_Gender_Created] ******/
ALTER TABLE [dbo].[Gender] ADD  CONSTRAINT [DF_Gender_Created]  DEFAULT (getdate()) FOR [Created]
GO
/****** Object:  Default [DF_Gender_Updated] ******/
ALTER TABLE [dbo].[Gender] ADD  CONSTRAINT [DF_Gender_Updated]  DEFAULT (getdate()) FOR [Updated]
GO
/****** Object:  Default [DF_Gender_IsActive] ******/
ALTER TABLE [dbo].[Gender] ADD  CONSTRAINT [DF_Gender_IsActive]  DEFAULT ((1)) FOR [IsActive]
GO
/****** Object:  Default [DF_Person_Created] ******/
ALTER TABLE [dbo].[Person] ADD  CONSTRAINT [DF_Person_Created]  DEFAULT (getdate()) FOR [Created]
GO
/****** Object:  Default [DF_Person_Updated] ******/
ALTER TABLE [dbo].[Person] ADD  CONSTRAINT [DF_Person_Updated]  DEFAULT (getdate()) FOR [Updated]
GO
/****** Object:  Default [DF_Person_IsActive] ******/
ALTER TABLE [dbo].[Person] ADD  CONSTRAINT [DF_Person_IsActive]  DEFAULT ((1)) FOR [IsActive]
GO
/****** Object:  ForeignKey [FK_Email_Person] ******/
ALTER TABLE [dbo].[Email]  WITH CHECK ADD  CONSTRAINT [FK_Email_Person] FOREIGN KEY([PersonID])
REFERENCES [dbo].[Person] ([PersonID])
ON UPDATE CASCADE
ON DELETE CASCADE
GO
ALTER TABLE [dbo].[Email] CHECK CONSTRAINT [FK_Email_Person]
GO
/****** Object:  ForeignKey [FK_Person_Gender] ******/
ALTER TABLE [dbo].[Person]  WITH CHECK ADD  CONSTRAINT [FK_Person_Gender] FOREIGN KEY([GenderID])
REFERENCES [dbo].[Gender] ([GenderID])
GO
ALTER TABLE [dbo].[Person] CHECK CONSTRAINT [FK_Person_Gender]
GO

Once the script is executed against the CodeGeneration database, create a new database diagram and add all of the database tables. When that step is complete, you should end up with a model that is similar to the following:

Code Generation Data Model

The database model was purposely made simple in an effort to maintain focus and march straight to our goal of extracting database metadata and storing it in XML format. Having now completed this step, we are now ready to move forward.

Building Blocks

Now that we have a database to work with, we can now begin to create the code generator application. In keeping with tradition, we will build a simple code generator with a Console Application. This application will in turn make use of an utility assembly that will contain all of the necessary functionality to extract metadata from the database and translate that metadata into useful code objects. This assembly will assume the role of the code generation engine. Let's get started!

CodeGenerator.Core

If you haven't done so already, load Visual Studio and create a new empty solution named "Code Generation Tutorial" or anything that you like. Once we have a solution, add a new C# project of type "Class Library" and name it "CodeGenerator.Core" without the quotes. Once created, delete the "Class1.cs" default class as we will be adding our own classes. Since the code generator will rely on a configuration file at a later point in time, go ahead and add a reference to the System.Configuration assembly to our project. We do this because much of the information the code generator will require at runtime, such as server instance name, connection strings, code decoration information, will be stored in a configuration file that we can modify on the fly. It is important to note that just as any other commercially available code generation utility, the application will need to make use of many different configurations and database targets. Therefore, it is recognized that using a single configuration file is probably not the best approach. Given that we are sticking to simplicity however, this approach will be used instead of a more robust configuration management scheme.

The first coding step we will take will be to create a class that will contain a series of string constants. These constants will represent stored procedure names and configuration key names. We do this to avoid or limit the use of "magic strings" in our code.Let's get started. Add a static class to the CodeGenerator.Core project named LibraryConstants.cs and add the following code:

namespace CodeGenerator.Core
{
	/// 
	/// LibraryConstants class
	/// 
	static public class LibraryConstants
	{
		/// 
		/// Master database connection string configuration key
		/// 
		public const string MASTER_DATABASE_CONNECTION_KEY = "MasterDatabaseConnectionString";
		/// 
		/// Target database connection string configuration key
		/// 
		public const string TARGET_DATABASE_CONNECTION_KEY = "CodeGeneration";
		/// 
		/// Target database configuration key
		/// 
		public const string TARGET_DATABASE_KEY = "TargetDatabase";
		/// 
		/// SQL Server instance configuration key
		/// 
		public const string SQL_SERVER_INSTANCE_KEY = "SqlServerInstance";		
		/// 
		/// Help server stored procedure
		/// 
		public const string HELP_SERVER_SPROC = "sp_helpserver";
		/// 
		/// Databases stored procedure
		/// 
		public const string INSTANCE_DATABASES_SPROC = "sp_databases";
		/// 
		/// Primary keys procedure
		/// 
		public const string P_KEYS_SPROC = "sp_pkeys";
		/// 
		/// Foreign keys procedure
		/// 
		public const string F_KEYS_SPROC = "sp_fkeys";
		/// 
		/// Columns procedure
		/// 
		public const string COLUMNS_SPROC = "sp_columns";
		/// 
		/// Database tables stored procedure
		/// 
		public const string DATABASE_TABLES_SPROC = "sp_tables";
		/// 
		/// Include personalization key
		/// 
		public const string INCLUDE_PERSONALIZATION_KEY = "IncludePersonalization";
		/// 
		/// Developer name key
		/// 
		public const string DEVELOPER_NAME_KEY = "DeveloperName";
		/// 
		/// Developer company key
		/// 
		public const string DEVELOPER_COMPANY_KEY = "Company";
		/// 
		/// Developer position key
		/// 
		public const string DEVELOPER_POSITION_KEY = "Position";
		/// 
		/// Developer URL key
		/// 
		public const string DEVELOPER_URL_KEY = "DeveloperUrl";
		/// 
		/// Copyright key
		/// 
		public const string COPYRIGHT_KEY = "Copyright";
	}
}

Don't worry about what each of these constans mean for now. While their meaning is somewhat explained by the comments in the code, their usage will become more aparent later in this article. We will next create a base class that will contain some important properties we will need. This base class will essentially wrap "AppSettings" elements from the main configuration file that we will add to the code generator application. Add an anstract class to the project named CoreBase.cs and add the following code to it:

using System.Configuration;

namespace CodeGenerator.Core
{
	public abstract class CoreBase
	{
		#region Properties
		/// 
		/// Gets MasterDatabaseConnectionString
		/// 
		protected string MasterDatabaseConnectionString
		{
			get
			{
				return ConfigurationManager
					.ConnectionStrings[LibraryConstants.MASTER_DATABASE_CONNECTION_KEY]
					.ConnectionString;
			}
		}
		/// 
		/// Gets TargetDatabase
		/// 
		protected string TargetDatabaseConnectionString
		{
			get
			{
				return ConfigurationManager
					.ConnectionStrings[LibraryConstants.TARGET_DATABASE_CONNECTION_KEY]
					.ConnectionString;
			}
		}
		/// 
		/// Gets SqlServerInstance
		/// 
		protected string SqlServerInstance
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.SQL_SERVER_INSTANCE_KEY];
			}
		}
		/// 
		/// Gets TargetDatabase
		/// 
		protected string TargetDatabase
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.TARGET_DATABASE_KEY];
			}
		}
		/// 
		/// Gets IncludePersonalization
		/// 
		protected string IncludePersonalization
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.INCLUDE_PERSONALIZATION_KEY];
			}
		}
		/// 
		/// Gets DeveloperName
		/// 
		protected string DeveloperName
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.DEVELOPER_NAME_KEY];
			}
		}
		/// 
		/// Gets Company
		/// 
		protected string Company
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.DEVELOPER_COMPANY_KEY];
			}
		}
		/// 
		/// Gets Position
		/// 
		protected string Position
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.DEVELOPER_POSITION_KEY];
			}
		}
		/// 
		/// Gets DeveloperUrl
		/// 
		protected string DeveloperUrl
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.DEVELOPER_URL_KEY];
			}
		}
		/// 
		/// Gets Copyright
		/// 
		protected string Copyright
		{
			get
			{
				return ConfigurationManager.AppSettings[LibraryConstants.COPYRIGHT_KEY];
			}
		}
		#endregion
	}
}

As seen in the CoreBase class, we are making use of the constants in the LibraryConstants class to identify sections in a future App.config file. Doing this, we now have a clearer idea as to what this file will look like. The App.config file will contain information that will be used for the identification of the target database, server instance, developer information, etc.

One aspect of metadata retrieval that is of great importance is the ability to validate the availability of not just the SQL Server instance, but the existance of the database itself. We can achieve this in many ways such as

Using SMO or SQLDMO
Opening a SQLConnection with a connection string and test for exceptions
or, query SQL Server itself using system procedures to get at the validation data we need

While the second option might seem as the most natural and quickest of all the mentioned options, it is part of the intention of this article to expose the functionality of these specialized system procedures. Therefore, it is for this reason that the first two options will not be used in this tutorial, though they are indeed worth mentioning and perhaps even explored in future articles.

For the purpose of validating what we shall call the "generation target", we will be creating a class that will inherit CoreBase directly. Indirectly however, it is worth mentioning before hand that every class within the CodeGenerator.Core assembly will directly or indirectly inherit CoreBase; with the notable exception of LibraryConstans. Add a class to the project and call this class DataSourceValidator and have this class inherit from CoreBase. Add the following code to the class:

using System;
using System.Data;
using System.Data.SqlClient;

namespace CodeGenerator.Core
{
	/// 
	/// DataSourceValidator class
	/// 
	public class DataSourceValidator : CoreBase
	{
		#region Constructor
		/// 
		/// Default constructor
		/// 
		public DataSourceValidator() { }
		#endregion
		
		#region Utility Methods
		/// 
		/// Indicates whether a data store is valid
		/// 
		/// 
		/// 
		/// 
		public bool IsValidTarget()
		{
			// Allocate default return value
			bool retVal = false;

			try
			{
				retVal = ServerIsValid() && DatabaseIsValid();
			}
			catch
			{
				// Do nothing - Simply return default value
			}

			return retVal;
		}

		/// 
		/// Indicates whether the server instance is valid or not
		/// 
		/// 
		private bool ServerIsValid()
		{
			// Allocate default return value
			bool retVal = false;

			// Begin server validation process
			using (DataSet availableServers = new DataSet("AvailableServers"))
            {
				// Connect to the master database
            	using (SqlConnection connection = new SqlConnection(MasterDatabaseConnectionString))
                {
                	// Fetch all servers
					using (SqlCommand retrieveServers = new SqlCommand(LibraryConstants.HELP_SERVER_SPROC, connection))
                    {
						// Set up data adapter
                    	using (SqlDataAdapter adapter = new SqlDataAdapter(retrieveServers))
                        {
                        	// Set command type and fill the dataset
							retrieveServers.CommandType = CommandType.StoredProcedure;
							adapter.Fill(availableServers);

							// Begin server instance validation
							if (availableServers.Tables.Count > 0)
							{
								// Get rows that match the instance name
								DataRow[] rows = availableServers.Tables[0].Select(string.Format("name='{0}'", SqlServerInstance));

								// Set return value
								if (rows.Length > 0)
									retVal = rows[0]["name"].ToString().ToLower().Equals(SqlServerInstance.ToLower());
							}
                        }
                    }
                }
            }

			return retVal;
		}

		/// 
		/// Indicates whether the database is valid or not
		/// 
		/// 
		private bool DatabaseIsValid()
		{
			// Allocate default return value
			bool retVal = false;

			// Begin database validation process
			using (DataSet availableDatabases = new DataSet("AvailableDatabases"))
			{
				// Connect to the master database
				using (SqlConnection connection = new SqlConnection(MasterDatabaseConnectionString))
				{
					// Fetch all databases
					using (SqlCommand retrieveDatabases = new SqlCommand(LibraryConstants.INSTANCE_DATABASES_SPROC, connection))
					{
						// Set up data adapter
						using (SqlDataAdapter adapter = new SqlDataAdapter(retrieveDatabases))
						{
							// Set command type and fill the dataset
							retrieveDatabases.CommandType = CommandType.StoredProcedure;
							adapter.Fill(availableDatabases);

							// Begin server instance validation
							if (availableDatabases.Tables.Count > 0)
							{
								// Get rows that match the instance name
								DataRow[] rows = availableDatabases.Tables[0].Select(string.Format("DATABASE_NAME='{0}'", TargetDatabase));

								// Set return value
								if (rows.Length > 0)
									retVal = rows[0]["DATABASE_NAME"].ToString().ToLower().Equals(TargetDatabase.ToLower());
							}
						}
					}
				}
			}

			return retVal;
		}
		#endregion
	}
}

As seen in the code to this point, the DataSourceValidator class consists of three methods. Two private methods: DatabaseIsValid() and ServerIsValid(); are wrapped inside of the public method IsValidTarget() which will return the combined validation result of the forementioned methods. Again notice how these methods make use of the LibraryConstants constants in order to minimize the usage of "magic strings" throughout our code. Additionally, these methods make use of system procedures to retrieve SQL Server instances and databases in order to validate our future entries in the App.config file later on and do provide a template of sorts of what our calls will look like against the generation target.

The next step will be to create another abstract class named TargetSchemaInfo that will also inherit from CoreBase to our project. This class will contain some very important pieces that will be used by a derived class named MetadataGenerator for the collection of database tables, child tables, columns, primary key columns, connections to the generation target, etc. Once the class has been added and made to inherit from CoreBase, add the following code to it:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Data;
using System.Data.SqlClient;

namespace CodeGenerator.Core
{
	/// 
	/// TargetSchemaInfo class
	/// 
	public abstract class TargetSchemaInfo : CoreBase
	{
		#region Properties
		/// 
		/// Gets/Sets Connection
		/// 
		protected SqlConnection Connection { get; set; }
		#endregion

		#region Constructor
		/// 
		/// Default constructor
		/// 
		public TargetSchemaInfo() : base() 
		{
			// Initialize object
			Initialize();
		}
		#endregion

		#region Utility Methods
		/// 
		/// Handles class initialization logic
		/// 
		private void Initialize()
		{
			// Create validator
			DataSourceValidator validator = new DataSourceValidator();

			if (validator.IsValidTarget())
			{
				// Initialize and open connection to the target database
				Connection = new SqlConnection(TargetDatabaseConnectionString);
				Connection.Open();
			}
		}
		
		/// 
		/// Retrieves a list of database tables in the target database
		/// 
		/// 
		protected List DatabaseTables()
		{
			// Pre-allocate return value
			List retVal = new List();

			// Begin process of fetching database tables
			using (DataSet availableTables = new DataSet("AvailableTables"))
			{
				using (SqlCommand retrieveTables = new SqlCommand(LibraryConstants.DATABASE_TABLES_SPROC, Connection))
				{
					using (SqlDataAdapter adapter = new SqlDataAdapter(retrieveTables))
					{
						// Set command type and fill dataset
						retrieveTables.CommandType = CommandType.StoredProcedure;
						adapter.Fill(availableTables);

						// Filter out un-wanted tables such as system and information schema tables.
						List temp = new List();
						foreach (DataRow row in availableTables.Tables[0].Select("TABLE_TYPE='TABLE' and TABLE_OWNER <> 'sys' AND TABLE_OWNER <> 'INFORMATION_SCHEMA'"))
							temp.Add(row["TABLE_NAME"].ToString());

						// Get valid table names
						retVal = (from x in temp
								  where !x.Contains("sysdiagrams")
								  select x).ToList();
					}
				}
			}

			return retVal;
		}

		/// 
		/// Retrieves a list of child tables
		/// 
		/// 
		/// 
		protected List ChildTables(string parentTableName)
		{
			// Pre-allocate return value
			List retVal = new List();

			// Begin process of fetching database tables
			using (DataSet availableTables = new DataSet("AvailableTables"))
			{
				using (SqlCommand retrieveTables = new SqlCommand(LibraryConstants.F_KEYS_SPROC, Connection))
				{
					using (SqlDataAdapter adapter = new SqlDataAdapter(retrieveTables))
					{
						// Set command type and fill dataset
						retrieveTables.CommandType = CommandType.StoredProcedure;
						retrieveTables.Parameters.AddWithValue("@pktable_name", parentTableName);
						adapter.Fill(availableTables);

						// Filter out un-wanted tables such as system and information schema tables.
						foreach (DataRow row in availableTables.Tables[0].Rows)
						{
							if (row["fkcolumn_name"].ToString().Contains(parentTableName))
								retVal.Add(row["fktable_name"].ToString());
						}
					}
				}
			}

			return retVal;
		}

		/// 
		/// Retrieves a list of columns from a database table
		/// 
		/// 
		/// 
		protected DataTable Columns(string tableName)
		{
			// Pre-allocate return value
			DataTable retVal = new DataTable();

			// Begin process of fetching table columns
			using (DataSet availableColumns = new DataSet("AvailableColumns"))
			{
				using (SqlCommand retrieveColumns = new SqlCommand(LibraryConstants.COLUMNS_SPROC, Connection))
				{
					using (SqlDataAdapter adapter = new SqlDataAdapter(retrieveColumns))
					{
						// Set command type and fill dataset
						retrieveColumns.CommandType = CommandType.StoredProcedure;
						retrieveColumns.Parameters.AddWithValue("@table_name", tableName);
						adapter.Fill(availableColumns);

						// Set return value
						if (availableColumns.Tables.Count > 0)
							retVal = availableColumns.Tables[0];
					}
				}
			}

			return retVal;
		}

		/// 
		/// Returns the promary key status of a given column
		/// 
		/// 
		/// 
		/// 
		protected bool IsPrimaryKeyColumnName(string tableName, string columnName)
		{
			// Pre-allocate return value
			bool retVal = false;

			// Begin process of fetching table primary key status
			using (DataSet availableKeys = new DataSet())
			{
				using (SqlCommand retrieveKey = new SqlCommand(LibraryConstants.P_KEYS_SPROC, Connection))
				{
					using (SqlDataAdapter adapter = new SqlDataAdapter(retrieveKey))
					{
						// Set command type and fill dataset
						retrieveKey.CommandType = CommandType.StoredProcedure;
						retrieveKey.Parameters.AddWithValue("@table_name", tableName);
						adapter.Fill(availableKeys);

						if (availableKeys.Tables.Count > 0)
						{
							if (availableKeys.Tables[0].Rows.Count > 0)
							{
								foreach (DataRow row in availableKeys.Tables[0].Rows)
								{
									if (availableKeys.Tables[0].Rows[0]["COLUMN_NAME"].ToString().Equals(columnName))
									{
										retVal = true;
										break;
									}
								}
							}
						}
					}
				}
			}

			return retVal;
		}
		#endregion
	}
}

As seen by the code in the TargetSchemaInfo class, all data access methods are fairly similar with the exception that they make use of different system procedure calls. It is noted that due to the similarity of these methods, these methods could be combined and simply passed the LibraryConstans constant that they should use for whatever stored procedure they should be using. For demonstration purposes however, these methods have been split so as to clearly demonstrate each operation as clearly as possible.

The last step before we complete the CodeGenerator.Core assembly is to add the one class that will feed XML formatted metadata to the code generator. Prior to creating this class, it seems appropriate, without getting into too much detail, show the XML schema of the generated XML. This will give us an ideal view of how we need to generate our metadata, step by step. The following is an extract of the XML metadata we will be producing:



	
	
		Ramon E. Tristani
		PCSWebLabs
		Software Architect
		http://www.pcsweblabs.com
		This stuff is copyrighted by the powers of Hello World and foo vars!

As you can see, with what we have so far we can get at a lot of information from our generation target without even using a hint of SQLDMO or SMO. We do this by way of the MetadataGenerator class. This class is responsible for creating the entire XML content we will need in future phases of our project. Without further delay, add the MetadataGenerator class to the project and have this new class inherit from our previous class TargetShemaInfo. Add the following code to this class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Xml.Linq;
using System.Collections;

namespace CodeGenerator.Core
{
	/// 
	/// MetadataGenerator class
	/// 
	public class MetadataGenerator : TargetSchemaInfo
	{
		#region Constructors
		/// 
		/// Default constructor
		/// 
		public MetadataGenerator() : base() { }
		#endregion

		#region Utility Methods
		/// 
		/// Returns a basic metadata XML document
		/// 
		/// 
		/// 
		private XElement CreateBasicDocument(List tables)
		{
			return new XElement("metadata",
							new XElement("project",
								new XAttribute("server", SqlServerInstance),
								new XAttribute("database", TargetDatabase),
								new XAttribute("created", DateTime.Now.ToShortDateString()),
								new XAttribute("objectnamespace", TargetDatabase),
								new XAttribute("sqlcodeobjectprefix", TargetDatabase.ToLower())),
							new XElement("personalization",
								new XAttribute("includepersonaldata", IncludePersonalization),
								new XElement("developername", DeveloperName),
								new XElement("company", Company),
								new XElement("position", Position),
								new XElement("developerurl", DeveloperUrl),
								new XElement("copyright", Copyright)),
							new XElement("databasetables",
								new XAttribute("count", tables.Count.ToString())));
		}

		/// 
		/// Creates a columns XML element
		/// 
		/// 
		/// 
		/// 
		/// 
		private XElement CreateColumnsElement(string tableName, DataTable tableColumns)
		{
			XElement columnsElement = new XElement("columns",
							   new XAttribute("columncount", tableColumns.Rows.Count.ToString()));
			foreach (DataRow row in tableColumns.Rows)
			{
				if (!(row["TYPE_NAME"].ToString().Equals("timestamp")))
				{
					columnsElement.Add(new XElement("column",
						new XAttribute("name", row["COLUMN_NAME"].ToString()),
						new XAttribute("datatype", row["TYPE_NAME"].ToString()),
						new XAttribute("length", row["PRECISION"].ToString()),
						new XAttribute("primarykeystatus", IsPrimaryKeyColumnName(tableName, row["COLUMN_NAME"].ToString()) ? "true" : "false"),
						new XAttribute("nullable", row["NULLABLE"].ToString().Equals(0) ? "false" : "true"),
						new XAttribute("columnindex", (int.Parse(row["ORDINAL_POSITION"].ToString()) - 1).ToString()),
						new XAttribute("defaultvalue", row["COLUMN_DEF"].Equals(DBNull.Value) ? "nodefault" :
											row["COLUMN_DEF"].ToString().Replace("(", string.Empty).Replace(")", string.Empty).Replace("'", string.Empty))));
				}
			}
			return columnsElement;
		}

		/// 
		/// Creates a child tables element
		/// 
		/// 
		/// 
		/// 
		private XElement CreateChildTablesElement(List childTables, ref XElement columnsElement)
		{
			XElement childTablesElement = new XElement("childtables");
			if (childTables.Count > 0)
			{
				foreach (string childTable in childTables)
				{
					// Create child table node
					XElement childTableElement = new XElement("childtable",
						new XAttribute("name", childTable),
						new XAttribute("type", "table"));

					// Parse columns
					columnsElement = CreateColumnsElement(childTable, Columns(childTable));

					// Add columns to child table element
					childTableElement.Add(columnsElement);

					// Add child table to child tables element
					childTablesElement.Add(childTableElement);
				}
			}
			return childTablesElement;
		}

		/// 
		/// Returns an XML metadata representation of the target database
		/// 
		/// 
		public string GetMetadataXml()
		{
			// Pre-allocate return value
			string retVal = string.Empty;

			if (Connection.State.Equals(ConnectionState.Open))
			{
				// Fetch tables
				List tables = DatabaseTables();

				// Process tables
				if (tables.Count > 0)
				{
					// Create basic document
					XElement element = CreateBasicDocument(tables);

					// Create document from current XML data
					XDocument doc = new XDocument(element);

					// Reference the "databasetables" node as this node will be heavily modified
					XElement databaseTables = doc.Root.Element("databasetables");
					for (int i = 0; i < tables.Count; i++)
					{
						// Retrieve child tables
						List childTables = ChildTables(tables[i]);
						XElement tableElement = new XElement("table");
						tableElement.Add(new XAttribute("name", tables[i]));
						tableElement.Add(new XAttribute("type", "table"));
						tableElement.Add(new XAttribute("haschildren", childTables.Count > 0 ? "true" : "false"));
						tableElement.Add(new XAttribute("objectindex", i.ToString()));

						#region Load Columns
						// Parse out table columns
						XElement columnsElement = CreateColumnsElement(tables[i], Columns(tables[i]));

						// Add columns to table element
						tableElement.Add(columnsElement);
						#endregion

						// Load child tables
						tableElement.Add(CreateChildTablesElement(childTables, ref columnsElement));

						// Add table element to database tables container node
						databaseTables.Add(tableElement);
					}

					// Set return XML
					retVal = element.ToString();
				}

				// Close connection to the database
				Connection.Close();
			}

			return retVal;
		}
		#endregion
	}
}

The one thing to note with this class is that LINQ to XML is used exclusively for the creation of what will be our XML formatted metadata output. Additionally, having followed a clear inheritance path, we have managed to implement an object with the sole purpose or generating metadata from the generation target.Having worked on similar objects that use the XML DOM objects such as XMLWriter objects, I can attest that our code would have been 4 times as long than it would by using LINQ to XML as we have done so here. At this point, our CodeGenerator.Core assembly is complete for all effective purposes of this tutorial and should look like the following diagram:

Code Generation Core Class Diagram

The Code Generator - Testing the Metadata

At this point, we are ready to test our assembly output and we will do so by adding a new Console Application project to the Visual Studio solution called CodeGenerator. After creating the project, two things need to happen and those are:

Add a reference to the CodeGenerator.Core project
Add the App.config file to the new project

While the structure of the App.config file should be clear from what we have seen in the CoreBase class, the following configuration presents a sample of what this file must look like:

The only thing that remains to be done to this configuration is to plug in your own values where the value tokens have been placed. Next, we need to edit the Program class of the CodeGenerator project in order to make use of the CodeGenerator.Core assembly's new metadata extraction capabilities. To do so, add the following code to your Program class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CodeGenerator.Core;

namespace CodeGenerator
{
	class Program
	{
		static void Main(string[] args)
		{
			//
			MetadataGenerator meta = new MetadataGenerator();
			Console.WriteLine(meta.GetMetadataXml());

			// Hang the console
			Console.Read();
		}
	}
}

Go ahead, build and take the application for a spin! After doing so, if all goes well, you should be able to see a console window, complete with XML metadata output as seen in the following screen capture:

Metadata Output

The output basically is a complete regurgitation of metadatadata to the screen. As such, this step concludes this tutorial

Conclusion

In this tutorial we have explored the key concepts of metadata extraction from SQL Server for the purpose of creating the building blocks of a code generation utility. While exploring these concepts, we have gained exposure on how to extract database information from SQL Server using system procedures, how to create XML documents with LINQ to SQL, and how to bring these concepts together. Future articles on code generation will build on the concepts and projects covered in this article all the way to the completion of your very own code generator.

Get the source code for this article.