Data Transfer Objects Pattern

DTOs Defined

/// <summary> 
/// Domain Object 
/// </summary> 
public class Company
{
    private string name;
    private string taxId;

    public Company(string name, string taxId)
    {
        this.name = name;
        this.taxId = taxId;
    }

    public string Name { get { return name; } }
    public string TaxId { get { return taxId; } }
}

/// <summary> 
/// Data Transfer Object 
/// </summary> 
public class CompanyDTO
{
    public string Name { get; set; }
    public string TaxId { get; set; }
}

/// <summary> 
/// A company 
/// </summary> 
public class Company
{
    private string name;
    private string taxId;

    public Company(string name, string taxId)
    {
        this.name = name;
        this.taxId = taxId;
    }

    public string Name { get { return name; } }
    public string TaxId { get { return taxId; } }

    public Owner Owner { get; set; }
}

/// <summary> 
/// Owner of a company 
/// </summary> 
public class Owner
{
    public Company Company { get; set; }

    public string FirstName { get; set; }
    public string LastName { get; set; }
}

/// <summary> 
/// Data Transfer Object 
/// </summary> 
public class CompanyDTO
{
    public string Name { get; set; }
    public string TaxId { get; set; }

    public string OwnerName { get; set; }
}

From Domain Object to DTO and Back Again

/// <summary> 
/// Assembler for Company and CompanyDTO. 
/// </summary> 
public interface ICompanyAssembler
{
    CompanyDTO Convert(Company company);
    Company Convert(CompanyDTO DTO);
}

What is so useful about an object that has no behavior?

1. Multiple fieldsets are now supported in the forms.
2. I have taken the first steps towards supporting objects that contain child objects.  A 1-1 relationship is supported in the current revision.  A new fieldset is generated for each child object.
3. Strategies have been revamped so that they no longer are mapped to types.  Now a strategy is allowed to return null if it does not want to handle a property descriptor passed to it.  If it returns null, the next strategy in the list will be tried.

The end goal

The Components

• Field - A field is the smallest unit of input and validation in a form.
• Widget - A widget is an abstraction of HTML template text for input.
• FormBase - Base class for form helpers.
• ModelForm - A form auto created from a POCO model.

Widget

Field

FormBase

Model Action Filter

Rendering the Form in a View

• NAnt
  
• NUnit
  
• TortoiseSVN
• TestDriven.NET

• /Home/Index - return HTML view
• /Home/Index.xml - return xml view
• /Home/Index.json - return json view

routes.MapRoute(
    "SpecifyType",
    "{controller}/{action}.{responseType}/{id}",
    new { controller = "Home", action = "Index", id = "", responseType = "html" } 
);

routes.MapRoute(
    "Default",
    "{controller}/{action}/{id}",
    new { controller = "Home", action = "Index", id = "", responseType = "html" },
    new { action = @"\w+" }
);

string responseType = RouteData.Values["responseType"]

using(ISession s = OpenSession()) {
    using (ITransaction tx = s.BeginTransaction())
    {
        IQuery sql = s.GetNamedQuery("native-delete-car").SetString(0, "Kirsten");
        sql.ExecuteUpdate();
        tx.Commit();
    }
}

Syntax Matters

Desired CreateTable Syntax

Boo Basics

Rhino DSL

Implicit Base Class

public abstract class MigrationBase
{
    protected void CreateTable(params Column[] columns)
    {
	...
    }

    public abstract void Run();
}

The DSL script will be loaded into the abstract Run method of MigrationBase and the CreateTable call in the example will actually call the CreateTable method on MigrationBase.  This is a simple yet extremely powerful concept. 

For completeness sake, here is the Column class

public class Column
{
    public Column(string name, DbType dataType, Hash options)
    {
        Name = name;
        DataType = dataType;
        if (options.ContainsKey("primary"))
            Primary = (bool)options["primary"];
        if (options.ContainsKey("identity"))
            Identity = (bool) options["identity"];
        if (options.ContainsKey("length"))
            Length = (int) options["length"];
    }

    public string Name { get; set; }
    public bool Primary { get; set; }
    public bool Identity { get; set; }
    public int Length { get; set; }
    public DbType DataType { get; set; }

    public override string ToString()
    {
        return Name;
    }
}

public class Int32: Column
{
    public Int32(string name): base(name, DbType.Int32, new Hash())
    {
    }

    public Int32(string name, Hash options) : base(name, DbType.Int32, options)
    {
    }
}

public class String: Column
{
    public String(string name, Hash options) : base(name, DbType.String, options)
    {
    }
}

Transformers

Blocks

Macros

We will write a transformer to walk the abstract syntax tree (AST) turning the statements inside of the block into arguments to the macro.  Boo provides a helpful class to override to make this easier: DepthFirstTransFormer.

public override void OnMacroStatement(MacroStatement node)
{
    if (methods.Contains(node.Name))
    {
        if (node.Block != null)
        {
            var expressions = TransformBlock(node.Block);
            foreach (var expression in expressions)
                node.Arguments.Add(expression);
            node.Block = null;
        }
    }
    base.OnMacroStatement(node);
}

private string[] methods;

/// <summary> 
/// Creates an instance of BlockToParametersTransformer. 
/// </summary> 
/// <param name="methods">Names of the methods whose 
/// invocations should have blocks changed to arguments.
/// </param> 
public BlockToParametersTransformer(params string[] methods)
{
    this.methods = methods;
}

Now for the interesting part, the TransformBlock method.

private static Expression[] TransformBlock(Block block)
{
    var expressions = new List<Expression>(block.Statements.Count);
    foreach (Statement statement in block.Statements)
    {
        if (statement is ExpressionStatement)
        {
            expressions.Add((statement as ExpressionStatement).Expression);
        }
        else if (statement is MacroStatement)
        {
            var macroStatement = statement as MacroStatement;
            if (macroStatement.Arguments.Count == 0 && (!macroStatement.Block.HasStatements))
            {
                // Assume it is a reference expression                 
		var refExp = new ReferenceExpression(macroStatement.LexicalInfo);
                refExp.Name = macroStatement.Name;
                expressions.Add(refExp);
            }
            else             
	    {                 
		// Assume it is a MethodInvocation                 
		var mie =  new MethodInvocationExpression(macroStatement.LexicalInfo);
                mie.Target =
                    new ReferenceExpression(macroStatement.LexicalInfo, macroStatement.Name);
                mie.Arguments = macroStatement.Arguments;

                if (macroStatement.Block.HasStatements)
                {
                    // If the macro statement has a block,                      
		    // transform it into a block expression and pass that as the last argument                     
                    // to the method invocation.
                    var be = new BlockExpression(macroStatement.LexicalInfo);
                    be.Body = macroStatement.Block.CloneNode();

                    mie.Arguments.Add(be);
                }

                expressions.Add(mie);
            }
        }
        else         
        {             
	    throw new InvalidOperationException(
                string.Format("Can not transform block with {0} into argument.",
                              statement.GetType()));
        }
    }
    return expressions.ToArray();
}

A lot is going on in this method, so lets tackle it piece by piece.

if (statement is ExpressionStatement)
{
    expressions.Add((statement as ExpressionStatement).Expression);
}

This is the trivial case.  If we encounter an expression statement, then we just take the expression and add it to the list of expressions to return.

var macroStatement = statement as MacroStatement;
if (macroStatement.Arguments.Count == 0 && (!macroStatement.Block.HasStatements))
{
    // Assume it is a reference expression     var refExp =         new ReferenceExpression(macroStatement.LexicalInfo);
    refExp.Name = macroStatement.Name;
    expressions.Add(refExp);
}

If it has no arguments and no block, we assume that this is a ReferenceExpression that has not been bound yet.  We transform it into a reference expression and add that to our list of expressions to return.  This is a very important step, otherwise local variables declared inside of the DSL script would not be usable inside of our block!  I suggest that when you download the sample project, you experiment without this clause and try to use the DSL and see what happens.

else {     
    // Assume it is a MethodInvocation     
    var mie = new MethodInvocationExpression(macroStatement.LexicalInfo);
    mie.Target =
        new ReferenceExpression(macroStatement.LexicalInfo, macroStatement.Name);
    mie.Arguments = macroStatement.Arguments;

    if (macroStatement.Block.HasStatements)
    {
        // If the macro statement has a block,          
        // transform it into a block expression and pass that as the last argument         
        // to the method invocation.         
        var be = new BlockExpression(macroStatement.LexicalInfo);
        be.Body = macroStatement.Block.CloneNode();

        mie.Arguments.Add(be);
    }

    expressions.Add(mie);
}

Plumbing

public class MiteEngine: DslEngine
{
    public MiteEngine()
    {
        Storage = new FileSystemDslEngineStorage();
    }

    protected override void CustomizeCompiler(Boo.Lang.Compiler.BooCompiler compiler, Boo.Lang.Compiler.CompilerPipeline pipeline, string[] urls)
    {
        compiler.Parameters.Ducky = true;
        pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(MigrationBase), "Run", "BlockToParameters"));
        pipeline.InsertBefore(typeof(ExpandMacros), new BlockToParametersCompilerStep());
    }
}

class Program
{
    public static void Main(string[] args)
    {
        DslFactory factory = new DslFactory();
        factory.Register<MigrationBase>(new MiteEngine());
        var bc = factory.Create<MigrationBase>("test.boo");
        bc.Run();
        Console.ReadLine();
    }
}

protected void CreateTable(params Column[] columns)
{
    foreach (Column column in columns)
        Console.WriteLine(column);
}