Note by author:
Since writing this, I have expanded on this idea quite a bit. I have written a lightweight ORM class library that I call EntityJustWorks.
The full project can be found on GitHub or CodePlex.
EntityJustWorks not only goes from a class to DataTable (below), but also provides:
- SQL 'SELECT' statement to a List<T> of populated classes, each one resembling a row
Security Warning:
This library generates dynamic SQL, and has functions that generate SQL and then immediately executes it. While it its true that all strings funnel through the function Helper.EscapeSingleQuotes, this can be defeated in various ways and only parameterized SQL should be considered SAFE. If you have no need for them, I recommend stripping semicolons ; and dashes --. Also there are some Unicode characters that can be interpreted as a single quote or may be converted to one when changing encodings. Additionally, there are Unicode characters that can crash .NET code, but mainly controls (think TextBox). You almost certainly should impose a white list: string clean = new string(dirty.Where(c => "abcdefghijklmnopqrstuvwxyz0123456789.,\"_ !@".Contains(c)).ToArray());
PLEASE USE the SQLScript.StoredProcedure and DatabaseQuery.StoredProcedure classes to generate SQL for you, as the scripts it produces is parameterized. All of the functions can be altered to generate parameterized instead of sanitized scripts. Ever since people have started using this, I have been maintaining backwards compatibility. However, I may break this in the future, as I do not wish to teach one who is learning dangerous/bad habits. This project is a few years old, and its already showing its age. What is probably needed here is a total re-write, deprecating this version while keep it available for legacy users after slapping big warnings all over the place. This project was designed to generate the SQL scripts for standing up a database for a project, using only MY input as data. This project was never designed to process a USER'S input.! Even if the data isn't coming from an adversary, client/user/manually entered data is notoriously inconsistent. Please do not use this code on any input that did not come from you, without first implementing parameterization. Again, please see the SQLScript.StoredProcedure class for inspiration on how to do that.
So far I have posted several times on the DataTable class. I have shown how to convert a DataTable to CSV or tab-delimited file using the clipboard, how to create a DataTable from a class using reflection, as well as how to populate the public properties of a class from a DataTable using reflection. Continuing along these lines, I decided to bring the DataTable-To-Class wagons around full-circle and introduce a class that will generate the C# code for the class that is used by the DataTableToClass<T> function, so you don't have to create it manually. The only parameter required to generate the C# class code is, of course, a DataTable.
The code below is rather trivial. It uses CodeDOM to build up a class with public properties that match the names and data types of the data columns of the supplied DataTable. I really wanted the output code to use auto properties. This is not supported by CodeDOM, however, so I used a little hack or workaround to accomplish the same thing. I simply added the getter and setter code for the property to the member's field name. CodeDOM adds a semicolon to the end of the CodeMemberField statement, which would cause the code not to compile, so I added two trailing slashes "//" to the end of the field name to comment out the semicolon. The whole point of creating auto properties was to have clean, succinct code, so after I generate the source code file, I clean up the commented-out semicolons by replacing every occurrence with an empty string. The main disadvantage of this 'workaround' is that the code cannot be used to generate a working class in Visual Basic code. I do have proper CodeDOM code that does not employ this workaround, but I prefer the output code to contain auto-properties; auto-generated code is notorious for being messy and hard to read, and I did not want my generated code to feel like generated code.
Below is the DataTableToCode function, its containing class and its supporting functions. The code is short, encapsulated, clean and commented, so I will just let it speak for itself:
public static class DataTableExtensions
{
public static string DataTableToCode(DataTable Table)
{
string className = Table.TableName;
if(string.IsNullOrWhiteSpace(className))
{ // Default name
className = "Unnamed";
}
className += "TableAsClass";
// Create the class
CodeTypeDeclaration codeClass = CreateClass(className);
// Add public properties
foreach(DataColumn column in Table.Columns)
{
codeClass.Members.Add( CreateProperty(column.ColumnName, column.DataType) );
}
// Add Class to Namespace
string namespaceName = "AutoGeneratedDomainModels";
CodeNamespace codeNamespace = new CodeNamespace(namespaceName);
codeNamespace.Types.Add(codeClass);
// Generate code
string filename = string.Format("{0}.{1}.cs",namespaceName,className);
CreateCodeFile(filename, codeNamespace);
// Return filename
return filename;
}
static CodeTypeDeclaration CreateClass(string name)
{
CodeTypeDeclaration result = new CodeTypeDeclaration(name);
result.Attributes = MemberAttributes.Public;
result.Members.Add(CreateConstructor(name)); // Add class constructor
return result;
}
static CodeConstructor CreateConstructor(string className)
{
CodeConstructor result = new CodeConstructor();
result.Attributes = MemberAttributes.Public;
result.Name = className;
return result;
}
static CodeMemberField CreateProperty(string name, Type type)
{
// This is a little hack. Since you cant create auto properties in CodeDOM,
// we make the getter and setter part of the member name.
// This leaves behind a trailing semicolon that we comment out.
// Later, we remove the commented out semicolons.
string memberName = name + "\t{ get; set; }//";
CodeMemberField result = new CodeMemberField(type,memberName);
result.Attributes = MemberAttributes.Public | MemberAttributes.Final;
return result;
}
static void CreateCodeFile(string filename, CodeNamespace codeNamespace)
{
// CodeGeneratorOptions so the output is clean and easy to read
CodeGeneratorOptions codeOptions = new CodeGeneratorOptions();
codeOptions.BlankLinesBetweenMembers = false;
codeOptions.VerbatimOrder = true;
codeOptions.BracingStyle = "C";
codeOptions.IndentString = "\t";
// Create the code file
using(TextWriter textWriter = new StreamWriter(filename))
{
CSharpCodeProvider codeProvider = new CSharpCodeProvider();
codeProvider.GenerateCodeFromNamespace(codeNamespace, textWriter, codeOptions);
}
// Correct our little auto-property 'hack'
File.WriteAllText(filename, File.ReadAllText(filename).Replace("//;", ""));
}
}
An example of the resulting code appears below:
namespace AutoGeneratedDomainModels
{
public class CustomerTableAsClass
{
public CustomerTableAsClass()
{
}
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
public char Sex { get; set; }
public string Address { get; set; }
public string Birthdate { get; set; }
}
}
I am satisfied with the results and look of the code. The DataTableToCode() function can be a huge time saver if you have a large number of tables you need to write classes for, or if each DataTable contains a large number of columns.
If you found any of this helpful, or have any comments or suggestions, please feel free to post a comment.