justnbusiness

NVelocity Code Generation Tool for NBusiness

Thu, 03 Jul 2008 08:06:13 GMT

I’ve really been struggling with how to improve creating templates for NBusiness 3 so that it is much easier than it is now. I have been delayed by the prospect of actually creating any more templates with the CodeDom. It is just too painful and ugly.

On one hand I really want templates to be classes because this allows me to search for them easily, they are either in the same assembly or in a referenced assembly. It also allows me to easily gather meta-data about templates (attributes) and actually run the templates. It also allows for the template developer to generate code however they way, it's very powerful. There also does not need to be some special path that you store templates in and there does not need to be a relative path specified in the entity. It’s a very light-weight and powerful way to do templates.

Unfortunately the problem with this approach is that your templates are probably going to end up being done with the CodeDom, which as you probably know is a royal pain in the butt. If you try to use a template engine such as NVelocity then you’re stuck taking care of the path issues yourself, which is ok but is also sort of annoying.

Well last night I finally figured out a great solution to this problem. I have decided to include an NBusinessTemplateCodeGenerator Custom Tool to the visual studio integration project. This custom tool will generate for you a template class, based on a template file it is applied to in your solution. Then your entities can reference that template and will use NVelocity to do the generation. I plan on making it extensible somehow so other template tools (such as codesmith?) could be used. Here are some screenshots of a working prototype.

So in this example my simple NVelocity template has the following code:

using System;

namespace $entity.Namespace

{

public partial class $entity.Name

{

#foreach($field in $entity.Fields)

public $field.TypeName $field.Name { get; set; }

#end

}

The .nbt (NBusiness Template) file will create a Template class such as this:

[NBusiness.Templates.CodeTemplateAttribute()]

public class TestTemplate : NBusiness.Templates.TemplateBase {

protected override NBusiness.CodeDom.Compiler.EntityFile Compile(NBusiness.CodeDom.Entity entity, NBusiness.CodeDom.Compiler.EntityCompileParameters parameters) {

NBusiness.Templates.ICodeGeneratorEngine engine = NBusiness.Templates.CodeGeneratorEngine.GetEngine();

string template = System.Text.Encoding.UTF8.GetString(System.Convert.FromBase64String(@"IyoNCiAgICBTaW1wbGUgRW50aXR5SW5mbyBDb...you get the idea"));

byte[] generated = engine.Generate(entity, template, parameters);

return new NBusiness.CodeDom.Compiler.EntityFile(entity.Name, generated);

}

…Which is ugly, which is why this tool was created. It will convert your template code into a base64 string which will be converted back into code before getting passed into the NVelocity engine and merged with the incoming entity. This class will now be accessible by entities in the same project or referencing projects.

Your entity file might look like this:

using ClassLibrary1;

family Test

{

entity A as TestTemplate

{

field auto id int aid;

field nullable string data;

field nullable double value;

}

Which when run through the TestTemplate will produce code that looks like this:

using System;

namespace Test

{

public partial class A

{

public int aid { get; set; }

public string data { get; set; }

public System.Nullable<double> value { get; set; }

}

So all you have to do to get NVelocity working with NBusiness entities and models will be to add a .nbt file to your project which (if done through the Add New Item dialog) will have the Custom Tool NBusinessTemplateCodeGenerator applied to it. Then author away!

I will be using this system to author the core templates that come with NBusiness from now on.

Twin Cities Developer Guild

Mon, 30 Jun 2008 10:12:43 GMT

The twin cities developers guild has recently formed as a way to help bring together and organize other special interest groups.

Magenic is currently sponsoring an XNA User Group as well as a Languages User Group and now the Developers Guild is being formed. I'm happy to say that these groups are open for everyone and will encompass any relevant topic. Check out the respecitve websites and come to the meetings when you can!

Twin Cities Languages User Group

Tue, 24 Jun 2008 08:11:05 GMT

A new user group has formed in the Twin Cities with a special focus on programming languages.

http://www.twincitieslanguagesusergroup.com

The first session will be held by Charles Nutter, who works for Sun Microsystems developing JRuby. He works right here in the Twin Cities and I've met him personally at the Lang.NET symposium this past January and found him to be very knowledgable and exciting to talk to.

Getting a chance to talk with someone who is actively working on a professional programming language should be quite interesting. If you have any interest at all in programming languages you should definitely go to the link above and find out the logistics.

NBusiness 3 Updates

Tue, 24 Jun 2008 07:39:05 GMT

I’ve been working on NBusiness a little bit over the weekend. I’ve decided to create a Curried API using extension methods for the CodeDom to speed along template creation. Here is an example of what I have so far.

CodeMethodReferenceExpression onPropertyChanged =

new CodeMethodReferenceExpression(null, "OnPropertyChanged");

CodeMemberProperty memberProperty = new CodeMemberProperty();

memberProperty.Name = field.Name.ToPascalCase();

memberProperty.Type = new CodeTypeReference(field.Type);

memberProperty.Get()

.Return(memberField.Reference());

memberProperty.Set()

.If(

memberField.Reference().NotEqualTo(memberProperty.SetValue()))

.Then(

memberField.Reference().Assign(

memberProperty.SetValue()),

onPropertyChanged.Invoke(memberProperty.Name));

Trust me, as ugly as the above seems it’s still a million times better than doing it all the way it was originally written. Hopefully this will mature and get better over time as well. Here is an example of the code it produces.

private int Aid {

get {

return _aid;

}

set {

if ((_aid != value)) {

_aid = value;

OnPropertyChanged("Aid");

}

Secondly I have been polishing and simplifying the model framework that comes with NBusiness. I have been working to create an abstract DataAccess API that can easily produce any type of query. Here is an example of how you might insert a new model with the next version of NBusiness.

MockModel model = new MockModel();

model.Name = "testinsert";

model.Save();

This is as normal and will end up calling into MockModel’s “InsertModel” method which may be implemented like so

protected override void InsertModel(IQuery query)

{

query.Insert().Into(

MockModel.Database.Table,

MockModel.Database.Name).Values("@Name");

query.Go();

query.Parameter("@Id").Direction = ParameterValueDirection.Output;

query.Parameter("@Name").Value = Name;

query.Load += loader =>

{

Id = (int)query.Parameter("@Id").Value;

};

}

The DataBase.Table and DataBase.Name members are code generated, static ITable and IColumn fields based on your E# model definition. The query object will be passed up to parent objects and down to child objects and will be passed into an abstract provider which will use it to generate SQL and call your database. The IQuery object actually comes from your IDatabaseProvider and may abstract it to work with different databases. My theory at this point is that you could actually parse the query object anyway you like in the IDatabaseProvider and with a little manual work you could even get it working across a webservice.

Here is my MockDatabaseProvider for my unit tests. The provider interface is much simpler with this new technique.

class MockDatabaseProvider : IDatabaseProvider

{

#region IDatabaseProvider Members

public IQuery Query()

{

return new SqlQuery();

}

public ITable Table(string name)

{

return new SqlTable(name);

}

public void Execute(IQuery query)

{

MethodCall.Calls.Add(new MethodCall(

"Execute",

new { Name = "query", Value = query }));

SqlQuery sqlQuery = query as SqlQuery;

// Simulate setting the identity parameter after an insert

IParameterValue id = sqlQuery.Parameters.FirstOrDefault(

v => v.Name == "@Id");

if (id!=null && id.Direction == ParameterValueDirection.Output)

{

id.Value = 100;

}

sqlQuery.OnLoad(new MockLoader());

}

#endregion

}

Creating Attribute Macros in Boo

Tue, 17 Jun 2008 07:23:23 GMT

Here is a simple example of writing an Attribute Macro in boo. I have created a macro that you can use to ensure that parameters are not null and raise a ArgumentNullException if they are. The interesting thing to note about this is that if you were to do this in C# you would need to use a factory method to inject these methods as aspects at runtime. With Boo macros you are actually changing the code at build time, which has both positive runtime performance implications and positive architectural changes since you do not need a factory method.

Here is an example of how you might use such an attribute:

namespace MacroExample

import System

import Macros

class Example:

[Ensure(example)]

def DoSomething(example as string):

print example.ToUpper()

e = Example()

e.DoSomething("testing!")

e.DoSomething(null)

print "Press any key to continue . . . "

Console.ReadKey(true)

I have declared a class called Example with a single method DoSomething. On that method we have attached an Attribute called Ensure. If you were using standard Aspect Oriented Programming techniques you would need some custom code to inspect this attribute at runtime and build a dynamic type and method to wrap the logic of the ensure attribute.

In Boo, since my EnsureAttribute inherits from AbstractMacroAttribute the logic of the Attribute will actually be run at build time, not runtime. Note the parameter in the constructor, the ‘example’. There are no quotes around this because it is not a string. It actually comes into the constructor as a ReferenceExpression which I can use to match to the methods parameters.

Here is the ensure Attribute code:

namespace Macros

import System

import Boo.Lang.Compiler.Ast

[AttributeUsage(AttributeTargets.Method)]

class EnsureAttribute(Boo.Lang.Compiler.AbstractAstAttribute):

private _parameter as ReferenceExpression

public Parameter as ReferenceExpression:

get:

return _parameter

def constructor(parameter as ReferenceExpression):

_parameter = parameter

override def Apply(node as Node):

target = cast(Boo.Lang.Compiler.Ast.Method, node)

parameter as ParameterDeclaration

for p in target.Parameters:

if p.Name == _parameter.Name:

parameter = p

break

code = [|

if $(parameter) is null:

raise ArgumentNullException($(parameter.Name))

target.Body.Insert(0, code)

One of the most amazing parts about constructing macros in Boo is the built in code templating features. If you notice towards the bottom of the example where we are assigning to the variable ‘code’ there is a special block wrapped in [| … |]. This is a special type of operator that tells Boo that whatever is inside of this block is to be parsed and returned as an AST (abstract syntax tree) node. This is a helper for replacing reliance upon manually constructing Boo CodeDom objects. You can see on the following line that this compiled code is being inserted into the body of the method this attribute has been applied to.

It is important to note that while we are affecting the body of the method that method knows about the class it is attached to and that class knows about all other classes in the assembly and so on. This is the difference in power between Boo macros and C++ macros.

Calling Member Methods on null References

Fri, 06 Jun 2008 13:38:09 GMT

I just learned about an interesting way to use extensions methods. It turns out that even though extension methods appear to be used like member methods they still are, actually, not. Here is an example:

class Program

{

static void Main(string[] args)

{

string value = null;

Console.WriteLine("IsNullOrEmpty: " + value.IsNullOrEmpty());

Console.ReadKey();

}

public static class Extensions

{

public static bool IsNullOrEmpty(this string value)

{

return string.IsNullOrEmpty(value);

}

Which outputs:

IsNullOrEmpty: True

Ayende Rahien on building DSLs for Boo

Tue, 13 May 2008 07:41:37 GMT

I just got done reaing a very intesting article about domain specific languages:

http://www.infoq.com/articles/dsl-on-the-clr

His examples are in Boo, I would highly recommend at least looking through his code snippets, especially the one towards the end related to the "ensure" attribute.

Zune games with XNA

Sat, 10 May 2008 08:38:56 GMT

The latest version of XNA comes with support for creating games for the Zune. I'm pretty excited about this and have embarked on an open source game with three coworkers called ZuDoKu. It will be a collaborative Sudoku variant for the zune.

I figured that in order to get this going I was going to have to update my Zune software finally. I haven't been able to update it since I first got it, it's not that I didn't want to but it was just bombing out during the update process every time. Well I spent two hours of my friday night trying to fix it and finally was able to! It was choking when trying to access certain registry keys and when trying to unregister an assembly called Flash9b.ocx. Well both problems were eventually resolved by navigating to the registry keys in question and giving myself the correct permissions to manually delete the problematic keys.

It seems that Flash v9b was actually setting the "Everyone" user to be denied to delete some keys and their uninstallation process was not cleaning these keys up properly, which in turn was causing the Zune update software to choke. Well, after manually deleting all of the Flash related keys in HKLM\CLSID (after uninstalling flash of course) I got the update to finally work! I'm pretty excited... now of to game programming!