justnbusiness

ESharp Validation Rule Breakthrough

Thu, 17 Jul 2008 23:07:53 GMT

After a late night of hacking I have finally got an end to end transformation of E# validation rules into CSLA code that compiles. I am using the NVelocity code generator I created to do this, here is the example entity I have defined:

using NBusiness.Frameworks.Csla.Templates;

using Csla.Validation.CommonRules;

family Test

{

entity A as EditableRoot

{

field auto id int aid;

field nullable string data;

field nullable double value;

validate data StringMaxLength { MaxLength : 10 };

}

After running this through the compiler here is the code that it generated:

using System;

using Csla;

using Csla.Validation;

using System.Collections.Generic;

namespace Test

{

[Serializable]

public partial class A : BusinessBase<A>

{

#region Properties

private static PropertyInfo<int> aidProperty = RegisterProperty<int>(

typeof(A),

new PropertyInfo<int>("aid"));

/// <summary>

/// aid property

/// </summary>

public int aid

{

get { return GetProperty<int>(aidProperty); }

}

private static PropertyInfo<string> dataProperty = RegisterProperty<string>(

typeof(A),

new PropertyInfo<string>("data"));

/// <summary>

/// data property

/// </summary>

public string data

{

get { return GetProperty<string>(dataProperty); }

set { SetProperty<string>(dataProperty, value); }

}

private static PropertyInfo<System.Nullable<double>> valueProperty = RegisterProperty<System.Nullable<double>>(

typeof(A),

new PropertyInfo<System.Nullable<double>>("value"));

/// <summary>

/// value property

/// </summary>

public System.Nullable<double> value

{

get { return GetProperty<System.Nullable<double>>(valueProperty); }

set { SetProperty<System.Nullable<double>>(valueProperty, value); }

}

#endregion

#region Relationships

#endregion

#region Validation

protected override void AddBusinessRules()

{

Dictionary<string, object> dataArgs = new Dictionary<string, object>();

dataArgs.Add("MaxLength", 10);

ValidationRules.AddRule(

Csla.Validation.CommonRules.StringMaxLength,

new DecoratedRuleArgs(dataProperty, dataArgs));

}

#endregion

}

(You can see the power of a DSL simply by looking at how many more lines of code it takes to represent the same thing in a lower level language!)

It has taken me a loooong time to get to this point and I think it’s all downhill from here. Trying to find out how to discover validation / access / authorization rules from arbitrary business object frameworks turns out to be a terribly difficult thing to do. There is lots of room for improvement but I think I have the basics down for now. This should allow me to generate code for CSLA and NBusiness frameworks at least and perhaps a couple of others without too much work.

Next up is largely a process of cleaning up code (I have been hacking on things a lot recently), fixing up unit tests and fleshing out CSLA templates for each major stereotype (I love that word in a software context!). What a relief!

Unit Testing Asynchronous Code in Silverlight

Wed, 16 Jul 2008 12:02:58 GMT

My current job is a very enjoyable one. I have the pleasure of working for Rocky Lhotka on CSLA 3.6 and CSLA Light, more specifically CSLA Light but the two definitely bleed together.

CSLA Light is a project where we are trying to create a version of CSLA that will run on Silverlight. If you’re interested in hearing more details about this you should check out Rocky’s blog since it is the most up to date authority on CSLA development progress.

One of the problems we ran into right away was the ability to unit test our Silverlight code. Unit testing on Silverlight presents a number of limitations that are not present in a standard .net application. We initially tried using the unit test framework provided by Microsoft but found it impossible to test anything with a WCF service call in it due to threading.

To help illustrate the problem consider the following test:

[TestClass]

public class TestExample

{

[TestMethod]

public void Example()

{

ManualResetEvent mre = new ManualResetEvent(false);

BackgroundWorker worker = new BackgroundWorker();

worker.DoWork += (o, e) =>

{

// Do some processing...

};

worker.RunWorkerCompleted += (o, e) =>

{

mre.Set();

};

worker.RunWorkerAsync();

mre.WaitOne();

}

This test simulates a unit of work that is performed asynchronously. If you run this test in Silverlight what will happen? Also, suppose in your DoWork method there is bug and an Exception is thrown, what will happen? I’ll get back to this in a moment.

One of the features of CSLA is something called the “Data Portal” which is a concept that has been preserved in CSLA Light with only some slight differences, primarily all network calls in Silverlight must be done asynchronously. The Data Portal is the mechanism your CSLA business objects must use to transfer data across network separated application tiers. In CSLA 3.6 an asynchronous Data Portal has been created to provide parity with Silverlight, not to mention the fact that it’s just plain cool.

One interesting thing to know about Silverlight is that whenever you use WCF to make a network call it will dispatch that call onto the UI thread. I believe this is actually a limition of the browser rather than Silverlight itself, it must be piggy backing on top of the browser XmlHttpRequest functionality and therefore suffers from the same limitations.

This is a major problem for the Silverlight MSTest framework! Since your test is running on the UI thread if your test tries to make a WCF call it will need to be dispatched to the UI to work and you will end up with a deadlock. The above test will not work in Silverlight because we have used a ManualResetEvent to hold the UI thread since it too will dispatch to the UI thread.

So to respond to this we came up with a light weight unit testing framework that will allow you to easily test asynchronous code in Silverlight and to accompany NUnit or MSTest in .NET. The project is on Codeplex and it is called Unit Driven. It is designed to allow you to easily test asynchronous code in both Silverlight and .NET. In fact, in CSLA the test code we are writing is identical for both CSLA and CSLA Light despite the various differences in the environments. Here is an example of how you would write the previous test to address all of the questions I posed using Unit Driven:

[TestClass]

public class TestExample : TestBase

{

[TestMethod]

public void Example()

{

UnitTestContext context = GetContext();

BackgroundWorker worker = new BackgroundWorker();

worker.DoWork += (o, e) =>

{

// Do some processing...

};

worker.RunWorkerCompleted += (o, e) =>

{

};

worker.RunWorkerAsync();

context.Complete();

}

The subtle differences in this approach are simply that you’re using the UnitTestContext object to block the thread, or not, for you depending on the framework your test is running in as well as having an AsyncAsserter to manage getting exceptions back to the test thread for you.

In the first example you would end up in a deadlock in Silverlight and if your DoWork method threw an exception in either framework it would be interpreted as an unhandled exception and would cause your test to hang. With UnitDriven we are able to manage this easily by using an Assert.Try( … )

[TestMethod]

[ExpectedException(typeof(InvalidOperationException))]

public void ExpectedExceptionExample()

{

UnitTestContext context = GetContext();

BackgroundWorker worker = new BackgroundWorker();

worker.RunWorkerCompleted += (o, e) =>

{

// catches exception here and passes to the context.

context.Assert.Try(() =>

{

throw new InvalidOperationException();

});

context.Assert.Fail();

};

worker.RunWorkerAsync();

// When the context is triggered it will find the

// exception and re-throw it in .NET

// and simply pass it back in Silverlight.

context.Complete();

}

For some working examples check out our AsyncTests.cs on codeplex.

Happy Testing!

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

}