Thanks to AOP concept, creating a cache layer that is transparent to the caller is not a big deal. I have a piece of code that in a loop calls this method

   1: ClientCompetitor competitor = Repository.ClientCompetitor.GetByCriteria(

   2:     Query.CreateEq("AssociatedClient", clieid))

   3: .SingleOrDefault();

   4:            

This is based on a standard implementation of repository and a Specification Pattern as a query model. With nhibernate profiler I see that during the execution of this task, a lot of identical query are issued, because it gets called around 1000 times always with the same clieid.

Now before changing the code of the class to store in a dictionary<ClieId, ClientCompetitor> cached result, I like to handle this with a transparent cache layer used with AOP. This could be achieved registering this interceptor.

   1: <component

   2:         id="RepositoryCache"

   3:         service="Castle.Core.Interceptor.IInterceptor, Castle.Core"

   4:         type="xxx.BaseServices.Castle.Cache2Interceptor, xxx.BaseServices"

   5:         lifestyle="transient">

   6:     <parameters>

   7:         <invocationCache>${WindowsCache}</invocationCache>

   8:         <Rules>

   9:             <dictionary>

  10:                 <entry key="ClientCompetitor.*GetByCriteria">.classname(ClientCompetitor) .absolute(600)</entry>

  11:             </dictionary>

  12:         </Rules>

  13:     </parameters>

  14: </component>

I simply create a Cache2Interceptor object that has a property called Rules to define regular expression to specify witch methods I want to apply cache to. With this configuration I ask to put cache in ClientCompetitor repository and with GetByCriteria method. The cache component use the Specification Pattern object for retrieving the key to the real cache implementation, and I tell cache component that the classname is (ClientCompetitor). The className is used because I can register other method as cache invalidator, as an example I can tell that the method Save of ClientCompetitor repository will invalidate the entire ClientCompetitor class.

When the interceptor is configured, I can simply tell castle to apply it to ClientCompetitor repository class, and the game is done.

Then I rerun the code and only one query gets issued, with no modification to the original code.

alk.

I work often with windows services, and one of the most painfully experience is that you do not have an UI and quite often they have to do some scheduled task at certain time, so whenever you have a deploy you can find yourself in this situation.

The question mark means that you are not sure if your new deploy is really ok, because maybe some of the scheduled tasks will fail for misconfiguration or something else. Usually production machine are different to developement ones, you can miss components, point to a wrong db, forget to update configuration, etc, etc. To avoid this situation you need a series of smoke checks, I usually proceed in this way.

public class TestResult
{
    public Boolean Result { get; set; }
    public String Comment { get; set; }

    public static readonly TestResult Ok = new TestResult() {Result = true};
}

interface ITest
{
    TestResult Execute();
    String Name { get; }
}

This is the interface of the a component that is able to do a test, I can now write stuff like this

public class ResolveIoCTest: ITest
{
    #region ITest Members

    public TestResult Execute()
    {
        IoC.Resolve<IMYInterface>("xxxxx");
        return TestResult.Ok;
    }

    public string Name
    {
        get { return "ResolveIoCTest"; }
    }

    #endregion 
}

Just to verify that I’m able to resolve a specific interface or a specific component, but you can actually verify every stuff you like, then I write a simple form with a button and a ritch text box.

The next step is finding in the assembly all test classes

Type testInterfaceType = typeof(ITest);
IoC.FluentRegistration(
    AllTypes.Pick()
    .FromAssembly(
        Assembly.GetExecutingAssembly())
    .If(testInterfaceType.IsAssignableFrom)
    .Configure(reg => reg.LifeStyle.Transient)
    .WithService.FirstInterface());

Thanks to fluent registration it is easy to autoregister all test classes, now the test form simply call IoC.ResolveAll<ITest> and for each test execute it in a Try catch, and here is a typical result.

Some exception occurred.

Now each time I write a component that needs verification, I write a simple test, then each time I deploy I runs this form and verify that I do not miss anything. This saves me pain, because I know that at least a set of smoke tests are passing correctly.

alk.

Tags: Software Architecture

Software architects are similar to civil architects, both of them work to create an artifact (software or building) on paper that will be subsequent realized. If you are committed to make a project of a building, witch of them you will like more to create?

I’m sure that the first one is probably the first choice, for many reasons. It is more challenging, it will probably make you famous, it is surely more beautiful. The problem is that those two buildings are really different in use. The first can be a congress center, a museum, but the other one is a simple house for a standard family. The problem arise if a customer ask you for “an house for me and my family” and you will give him the project to build the first one…. probably it is not the expected result, from the perspective of the customer.

The first solution is more expensive to build, it is probably more expensive to maintain, in winter you will spend tons of money to keep it warm and bla bla bla. The point is that the first building is a perfect structure for a museum, but absolutely the wrong one for a family, so if you, as an architect, will create the first one for a family, you have failed.

In software architecture the situation is the same, but with a great difference: the artifact that gets created, is immaterial (a software cannot be seen), and the customer does not perceive its complexity. Everyone can say “hey, I asked for an house, not for a congress center”, but it is really more difficult to look at a software and say, hey, I asked for a simple web site for my football club, but you gave me a full e-commerce, that I does not need.

In this situation, the customer can ask for a software to manage some data from hardware RFID readers. The architect can create a big software made of separated executables, WCF, Remoting, flexible and pluggable algorithms, etc etc. The big problem is that probably it is enough a single executable connected to the readers, that stores raw data in db, plus another executables that manage those data and finally a bunch of web pages that show the result. The three parts are completely disconnected, and the whole architecture is Simple.

Sometimes architects discard simple solutions, they want the customer to think “This architect is really good, he created really a good project that uses latest technologies”. Then they realize, once in production, that they simply created the wrong stuff, because the whole think is difficult to maintain and probably the customer is not satisfied with the final result.

The conclusion is that, in my opinion, simplicity is a really great value for an architecture, and wise architects always takes it in consideration when they make a project. Creating a simple structure can be less challenging and less interesting, but the final goal is finding what the customer really needs, not giving fame or pleasure to the architect. So the wise architect is the one who really understand the needs of the customer and resists the temptation to create an architecture only for his personal pleasure.

Alk.

Tags: Software architecture

When you develop web applications you usually have X developers solving bugs and implementing features, and a series of testers that test application during developing process. A must to have requirement is that

1. Modifications to the trunk are visible as soon as possible to testers.
2. Data in test database gets preserved

Point 2 is especially important, testers usually work with the site and fills database with data. Suppose that tester John find a bug that occurs only with specific data, a developer correct the bug, then a deploy is done, all test data are wiped away, and the tester is not able to verify if the bug is gone.

Moreover testers usually fill the database with real data useful for testing, then you need to deploy update to web application while updating database schema preserving data. The optimum solution is the one represented by this schema

When a developer does a check-in or at a scheduled time the build server gets latest bit of the tip, then compile it, and update the web server pointing IIS to the new version and updating schema of the database in the meanwhile, preserving all the data inside the test db.

It is absolutely not a complex stuff to do, here is the only modification I need to do into the msbuild file of the build.

<UsingTask
    TaskName="DotNetMarche.MsBuildExtensions.Administrative.IISChangePhisicalDirTask"
    AssemblyFile="..\sources\libs\MsBuildCustomTasks\DotNetMarche.MsBuildExtensions.dll"/>

<UsingTask
    TaskName="DotNetMarche.MsBuildExtensions.Xml.XmlPokeTask"
    AssemblyFile="..\sources\libs\MsBuildCustomTasks\DotNetMarche.MsBuildExtensions.dll"/>

<Target Name="AfterDropBuild">
    <Message Text="Deploy web application for $(BuildNumber)" />

    <XmlPokeTask
        FilePath="$(DropLocation)\$(BuildNumber)\debug\_PublishedWebsites\NorthwindWeb\web.config"
        XPath="/connectionStrings/add[@name='Northwind']/@connectionString"
        NewValue='Data Source=localhost\sql2008;Initial Catalog=NorthwindCiTest;user=sa;pwd=Pa$$w0rd'
        FailIfError='false' />

    <IISChangePhisicalDirTask
        Username="administrator"
        Password="xxxxxxxxxxx"
        MachineName="WS2008V1"
        SiteName="NorthWindTest"
        NewPhisicalDirectory="C:\Drops\NorthwindTest\$(BuildNumber)\debug\_PublishedWebsites\NorthwindWeb\" />

    <MSBuild Projects="$(SolutionRoot)\src\DbEdition\NorthwindTest\NorthwindTest\NorthwindTest.dbproj"
                Properties="OutDir=$(DropLocation)\$(BuildNumber)\debug\;TargetDatabase=NorthwindCiTest;DefaultDataPath=C:\Program Files\Microsoft SQL Server\MSSQL10.SQL2008\MSSQL\DATA;TargetConnectionString=Data Source=WS2008V1\SQL2008,1433%3Buser=sa%3Bpwd=Pa$$w0rd;DeployToDatabase=true;"
                Targets="Deploy"  />
</Target>

The first two <UsingTask directive are needed to import a couple of custom msbuild task. The first is the XmlPokeTask, used to change part of an xml file. In this example you can verify how I change the connection string, because the Test Server can have a different setup, in this situation I use sa credentials, this is very bad for security, but this is only an example. In real scenario you must use integrated security.

The second task is a simple task that uses the technique described in this post, I basically change the directory used by the site NorthWindtest of a machine called WS200v1. The most important stuff here, is that drop location is on WS2008V1 machine, and since I know that the physical directory is c:\drops\ I can simply know the real directory from the BuildNuber. This action permits me to point the test site on the latest build.

Finally since the database could be changed I need to follow the instruction of this post to deploy the data on test database. Now each time a build is triggered after the build Test machine IIS was automatically redirected to the latest version, the web.config was changed to suite the test environment, and the database is automatically upgraded. I simply did the first checkin of the project and after the build I test the site from my dev machine

The site was deployed, and I’m able to insert a record in the new empty database created by the first build.

Alk.

Tags: Team Foundation Server

I just read this post of Martin Fowler, and I found it very interesting. In my opinion, even small projects will greatly benefit from Continuous Integration. Despite of the Branching policies that you choose, having a machine for CI is vital during the lifetime of a project.

Usually I do not like very much CherryPicking even if sometimes it cannot be avoided. In the Promiscuous Integration model, people are doing CherryPicking from other branches and this scares me. The purpose of a branch is to keep changes isolated until they are ready to be moved in the trunk, or to keep copies of specific version of the software, and usually merging between branches can be problematic. Some Source control system do not permit to merge changes between branches that are not contiguous.

In the example made by Fowler, with Promiscuous Integragion, DrPlum and Reverend Green works together in two different branches, but since they have great communication, they periodically merge from one branches to another, but this scheme is a little confused in my opinion.

A better strategy could be this one. Since DrPlum and Reverend Green have great communication, it can be possible to work in different way. Say DrPlum decide to create a new big feature, so he creates a branch and starts to work on that branch. Suppose he do not want to integrate in the trunk until it is completely finished, so he do not use CI.  He ask to other members of the team if someone is working on a branch, all people say no, so he create a new branch and start working on it.

After some time Reverend Green want also to create a new big feature, he ask to the team, and DrPlum says him that he is also working on a feature that have some code in common with the new feature of REverend Green. At this time both Reverend Green and Dr Plum create another branch from the original branch of DrPlum. The situation is the following, we have the trunk, then we have the first branch of DRplum (call it B1), from this branch we have two other branches, one for Reverend Green (B2G), and the other for DrPlum (B2P). Now we can configure a Continuos Integration Machine to integrate B1. Now both DrPlum and Reverend green are working on isolated branches, but they merge changes often with B1, so they never need a big merge. In this scheme B1 acts like a trunk for both developers. As bugfix or changes are made in the trunk, one of them bring those changes in B1, verify that all tests are good, and when B1 is stable again, each one propagates changes from B1 to his own branch.

With such a scheme, two developers can work together on new feature that have code in common, without the risk of big merge, using Continuos Integration, but avoiding put stuff in the trunk until the work is finished. Say Reverend Green has finished his feature, he first integrate all trunk changes in B1, verify that everything is ok, then merge changes from B1 to B2G, when everything is ok he merge remaining changes from B2G to B1 (in the meanwhile DrPlum could have changed B1), then from B1 to the trunk, and the game is done. The same is done from DrPlum when he finished.

I admit that I never used such a complex scheme, because I prefer to have developers continuously merge in the trunk, and thanks to CC.net integration problems are mitigated.

Alk.

Tags: Continuous Integration Source Control

Thanks to Castle Windsor you can write really modular software. I’m building a project in WinForm that needs to access the domain model through a service layer on a WS* service. One of the most annoying stuff is the need to setup a local service to test the application and the interface.

The key to speedup development is writing high modular software, thanks to castle this is really simple. First of all I use guardian facility to create proxy. This permits me to decide with configuration file if a service interface must be resolved with a proxy, or with a real class. This gives you immense flexibility.

Simply changing a configuration file I can use the concrete class that have access to the database, or pass through a ws* wcf webservice. All people inside the organization, that have vpn and access through the vpn network to the database, can use the concrete class of the service, completely bypassing wcf, while people outside the organization use a config that use wcf service.

The application is structured with a light custom MVC pattern, if a controller needs to access a specific service he simply declare a dependency.

public class XXXManagementController : IXXXManagementController
{
    public IXXXManagementService XXXManagementService { get; set; }

    public ICustomerService CustomerService { get; set; }

Here is the startup of the application.

[STAThread]
static void Main()
{
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(login = IoC.Resolve<Login>());
}

Thanks to an autoscan facility, all view are registered with code, in this software the Login View is always the same form, so I can register with an attribute.

[AutoscanComponent(LifestyleType.Transient, IsDefault = true, Id = "Login", ServiceType = typeof(Login))]
public partial class Login : Form

Thanks to autoscan I no need to register all the views in configuration file.

If it seems complex, you should consider the advantage of using a MCV architecture when is come time to test.

container.Register(Component.For(typeof (LoginController)).ImplementedBy<LoginController>());
LoginController sut = container.Resolve<LoginController>();
sut.Settings.LastLoggedUserName ="MyUser";
sut.Settings.LastLoggedCustomerId = 3;

List<Customer> customers = new List<Customer>()
                             {
                                 new Customer(1, "pippo", ""),
                                 new Customer(2, "pippo1", ""),
                                 new Customer(3, "pippo2", ""),
                             };

sut.CustomerService.Expect(c => c.GetAllCustomers()).Return(customers);
BindingSource bs = new BindingSource();
bs.DataSource = customers;
sut.View.Expect(v => v.SetCustomers(customers)).Return(bs);
sut.Start();
Assert.That(bs.Position, Is.EqualTo(2));
sut.View.AssertWasCalled(v => v.SetUserText("MyUser"));
sut.View.AssertWasCalled(v => v.SetFocusToPassword());

This seems a complex test but is really simple, I used a custom version of a AutoMockingContainer to resolve the LoginController and creating Mocks for each dependency. Since I’ve abstracted the settings of the application with an Interface, settings property of the controller is a mock, so I can setup lastloggedUserName and LastLoggerCustomerId, then I create a list of customer, and finally setup the expectations. The only bad stuff is that in windows form we does not have the power of binding of WPF, so I need to manage binding with BindingSource objects. The View is a WinForm that has some BindingSource defined in designer, and those BindingSource are passed to the controller. With this test I’m asserting that if the user was already logged, the controller sets last customer and last user in the interface.

The good stuff of this test, is that it uses mocks, so he do not need service, wcf, or anything else to be run.

alk.

Tags: Architecture

I’m writing a simple Dto generator, and today I found a challenging problem. I supported dto composition like this:

I have a CustomerDto3 that have only CustomerId and ContactName properties, then I want to autogenerate a OrderTestDto that have a Customers property of type CustomerDto3. The syntax on My T4 generator is this one.

SyntaxCode syntax = new SyntaxCode(
    @"bin\Debug\DtoFactory.Exe",
    Path.GetDirectoryName(Host.TemplateFile),
    "DtoFactory.Dto",
    "http://dtonamespace.org");   

syntax.Render(
    "DtoFactory.Orders[OrdersTestDto] (OrderID,OrderDate,Customers) (Customers|CustomerDto3)",
    "Generated\\OrderDto3.cs"); 

I’ve simplified dto creation, and supported generation of each dto in a different file. The main problem supporting this scenario is how to write the assembler of the container class. I’ve started generating this code.

public static Expression<Func<Orders, OrdersTestDto>> ExpressionSelector;

static Assembler() {

ExpressionSelector = obj => new OrdersTestDto() {
        OrderDate = obj.OrderDate,
        OrderID = obj.OrderID,
        Customers = CustomerDto3.Assembler.FromOriginal(obj.Customers),
        }; 

It works perfectly, after all since all the Dto are generated by the same generator, when I have to generate code that transforms an original Orders object into an OrdersTestDto, I know that the creation of CustomerDto3 can be delegated to the assembler of CustomerDto3 object. This is good but now this code wont work.

using (NorthwindEntities context = new NorthwindEntities())
    {
        var Query = context.Orders
            .Where(o => o.Customers.CustomerID == "ALFKI")
            .Select(OrdersTestDto.Assembler.ExpressionSelector);

If you read my older article, you find that one the most useful feature of dto generator, is the possibility to use expressions to make a projection in the database, but with previous generated Expression, Entity Framework give me this error

failed: System.NotSupportedException : LINQ to Entities does not recognize the method 'DtoFactory.Dto.CustomerDto3 FromOriginal(

This is obvious, because when EF translate the ExpressionTree into SQL code, it finds a call to user function, and he cannot know how to proceed. This seems to me a really bad limitation, so I decided to fix it. The problem is that the expression should be generated this way.

public static Expression<Func<Orders, OrdersTestDto>> Expression2Selector
    = obj => new OrdersTestDto()
      {
          OrderDate = obj.OrderDate,
          OrderID = obj.OrderID,
          Customers = new CustomerDto3()
          {
            CustomerID =  obj.Customers.CustomerID,
            ContactName = obj.Customers.ContactName,
          },
      };

With such an expression the EF provider is able to do the projection, but now a big problem arise. I’m working with T4 code generation, when the generator of OrdersTestDto has to generate the Expression, he does not know how the CustomerDto3 was generated, so he cannot generate such an expression. I really want to avoid the need to find a way to make different generators to share data.

After a brief thinking I realize that I already have the right expression built in CustomerDto3, so the only stuff I need is to compose the two expression, but this can be more complex than you can think. After lot of experiments, I came to this little trick.

private static void ParseSelector()
{
    ExpressionSelector = (Expression<Func<Orders, OrdersTestDto>>)
        new DtoExpressionVisitor().ReplaceDtoBinding(ExpressionSelector);
}

static Assembler() {

    ExpressionSelector = ...
    ParseSelector();
}

The trick works in this way, I generate the ExpressionSelector in the usual way, with the call to FromOriginal that does not work in EF LINQ query, but in the static constructor I call a ParseSelector function that rewrite the expression tree making it works with LINQ query . Here is the full code of the DtoExpressionVisitor().

class DtoExpressionVisitor : ExpressionVisitor
{
	private ParameterExpression parameter;
	public Expression ReplaceDtoBinding(LambdaExpression exp)
	{
		parameter = exp.Parameters[0];
		return this.Visit(exp);
	}

	protected override System.Linq.Expressions.MemberBinding VisitBinding(System.Linq.Expressions.MemberBinding binding)
	{
		if (binding is MemberAssignment)
		{
			MemberAssignment assign = (MemberAssignment)binding;
			if (assign.Expression is MethodCallExpression)
			{
				MethodCallExpression callex = (MethodCallExpression)assign.Expression;
				if (callex.Arguments.Count == 1)
				{
					MemberExpression argument = (MemberExpression) callex.Arguments[0];
					Type assembler = callex.Method.DeclaringType;
					if (assembler != null)
					{
						//The object is a dto and it is assemblable.
						FieldInfo expSelector = assembler.GetField("ExpressionSelector", BindingFlags.Static | BindingFlags.Public);
						if (expSelector != null)
						{
							LambdaExpression lambda = (LambdaExpression)expSelector.GetValue(null);
							MemberInitExpression minit = (MemberInitExpression)lambda.Body;
							List<MemberBinding> bindings = new List<MemberBinding>();
							foreach (MemberBinding oribind in minit.Bindings)
							{
								//1° step. access obj.Property
								MemberExpression accessOriObj = Expression.Property(parameter, argument.Member.Name);
								//2° step. access obj.Property.p'roperty
								MemberExpression accessObjProperty = Expression.Property(accessOriObj, oribind.Member.Name);
								//3° recreate the binding and store into a list
								MemberBinding newPropertyBind = Expression.Bind(oribind.Member, accessObjProperty);
								bindings.Add(newPropertyBind);
							}
							NewExpression constructor = Expression.New(((PropertyInfo) assign.Member).PropertyType);
							MemberInitExpression newInitExpression = Expression.MemberInit(constructor, bindings.ToArray());
							MemberBinding newBindingExpression = Expression.Bind(assign.Member, newInitExpression);
							return newBindingExpression;
						}
					}
				}
			}
		}
		return base.VisitBinding(binding);
	}

This is quite complicated code, and it works by replacing part of the original expression tree thus composing two expression tree into one. All initial conditions are needed to identify nodes that need correction, I need to correct all MemberBinding node that are MethodCallExpression, because those ones are the ones calling the FromOriginal function from the other dto. When I find a node to change, I otbain with reflection the original expression selector (a lambdaexpression), where the body is the one used to initialize the Dto. Now I have to regenerate a similar expression using the parameter of the original lambda. Basically the problem is the following, the OrdersTestDto expressionSelector has a parameter named obj of type orders, but the ExpressionSelector of CustomersDto3 has one parameter named obj but of type Customers. This means that I need to regenerate the whole ExpressionTree part, changing how parameters works.

The first step is to regenerate all MemberBinding expression part, with the original parameter (line 34-38) and storing them into a collection (line 39). The operation is the following, I need a MemberExpression that extract from the parameter the object needed to generate the Dto. In the above example accessing the Customers property of Orders to gets a Customer object. Then another MemberExpression to take the corresponding field from the Customers object, and finally a MemberBinding.

Then I need to recreate the BindingExpression (line 41-43) and returning in place of the original one. All the code is based on the original Tree Visitor by microsoft. With this quite complex trick I’m able to change the expression at runtime, thus keeping the generator simple.

alk.

Tags: T4 Generator Expression Tree LINQ

I have a project where I use repository pattern, interface code access domain object through a service, and the service return Dto. One of the bad side of the dto is that they are boring to write and to maintain. The main risk is that developers does this error

Mmmm I had to show a combo with all the typologies of the current customer, let me seee, I have already a service that return Typlogy object given the customer Id, ok I’ll use it. Can you spot the error???

The error is that the Typology object can contain (and in my situation is true) a lot of properties, some of them are long string, so the developer is retrieving a lot of unnecessary data from the service. The obvious solution is Dto, but noone wants to write them, so it is time to use code generation. With a T4 template I’m able to write stuff like this.

    template = new DtoFactoryTemplate (
        @"..\..\..\..\Common\Model\MyProject.Analyzer.Entities.Dll",
        Path.GetDirectoryName(Host.TemplateFile),
        "MyProject.Entities.Analysis.Typology",
        "TypologyLinkDto",
        "MyProject.Service.Dto",
        "http://www.nablasoft.com",
        1,
        new String[] {"Id", "Name", "CustomerId"},
        null,
        true, true, true);
    template.RenderToFile(@"..\Dto\Generated\TypologyLinkDto.cs"); 

Ok it still needs to be cleaned a little, because a lot of the parameter are optional but it does the work, it generates this object.

It is a good DTO with the three property names I requested, now with Linq2Nhibernate and repository pattern I can write this service method.

public List<TypologyLinkDto> GetTipologiesLinkForCustomer(Int32 customerId)
{
    return Repository.Typology.Query(
        t => t.CustomerId == customerId,
        TypologyLinkDto.Assembler.ExpressionSelector);
}

Thanks to autogenerated code I can use autogenerated Assembler.ExpressionSelector that can be passed as a selector function, resulting query is.

exec sp_executesql N'SELECT this_.kety_id as y0_, this_.kety_clieId as y1_, this_.kety_name as y2_ FROM KeyTypology this_ WHERE this_.kety_clieId = @p0',N'@p0 int',@p0=1

This permits to speed up the application because now I retrieve only the data I needed from the database and nothing more, and the good part is that dto is autogenerated, so I can write this code in almost 20 seconds.

alk.

Tags: Code Generation

If I have to tell what is the main property of a good architecture, I surely will answer that a good architecture centralize common operations and make simple to extend the application.

Here is a typical example. I have a WCF services called from external clients, but I use the same service inside my organization. I created a little WPF project that needs to use services functions, but since this program is run internally, I do not want it to pass in the WCF stack, but I simply want to use concrete services classes that access the database.

The solution is really simple, here it is:

[AutoscanComponent(LifestyleType.Transient, IsDefault = true, Id = "KeywordService", ServiceType = typeof(IKeywordService))]
public class KeywordService : IKeywordService

AutoscanComponent is used by a custom Castle facility, and is used to automatically register a component. For services I’m sure that there is always only an instance registered for each interface, so I can simply configure castle to use the autoscan facility, and when the code declare a dependency to IKeywordService, Castle resolve it with the concrete class instead of the WCF Proxy.

But this is not enough, I begin to notice that the program is slow, and after a simple inspection I see that there are too many calls to the database. The problem is that the user interact with a WPF UI and there are too many call to the database because the service interfaces are thought for a different usage pattern. This problem could be easily resolved with caching, so I create a simple interceptor.

public class CacheInterceptor : global::Castle.Core.Interceptor.IInterceptor
{
    private static String BuildCacheToken(IInvocation invocation)
    {
        StringBuilder sb = new StringBuilder(100);
        sb.Append(invocation.TargetType.Name)
            .Append("|")
            .Append(invocation.Method.Name)
            .Append("|");
        foreach (object argument in invocation.Arguments)
        {
            sb.Append(argument.ToString())
                .Append("|");
        }
        return sb.ToString();
    }

    public Int32 CacheDurationInMinutes { get; set; }

    #region IInterceptor Members

    ICacheManager invocationCache = CacheFactory.GetCacheManager();

    public void Intercept(IInvocation invocation)
    {

        String cacheToken = BuildCacheToken(invocation);
        Object cacheObject;
        if ((cacheObject = invocationCache.GetData(cacheToken)) != null)
        {
            invocation.ReturnValue = cacheObject;
        }
        else
        {
            invocation.Proceed();
            invocationCache.Add(cacheToken, invocation.ReturnValue, CacheItemPriority.Normal,
                null,
                new AbsoluteTime(DateTimeService.Now.AddMinutes(CacheDurationInMinutes)));
        }
    }

    #endregion
}

This component is really simple, It builds a string key that represent the cache composing service name + method name + parameterlist, so I’m sure that I cache only calls with the same parameters call. Then I simply use entlib caching application block to store data in cache. Now I simply need to configure this interceptor in config file.

<component id="CacheInterceptor"
     service="Castle.Core.Interceptor.IInterceptor, Castle.Core"
     type="BaseServices.Castle.CacheInterceptor, BaseServices"
     lifestyle="singleton">
  <parameters>
      <CacheDurationInMinutes>5</CacheDurationInMinutes>
  </parameters>

Next I need to instruct my facility to add this interceptor to all autoregistered components

<facility id="AutoScan" type="BaseServices.Castle.AutoscanFacility, BaseServices" >
	<assembly name="DataService" />
	<assembly name="Analyzer.Service" />
	<interceptor name="CacheInterceptor" />
	<interceptor name="SessionPerCallInterceptor" />
</facility>

With this configuration I’m sure that each service is intercepted by the cache component, cache duration is 5 minutes, and the application gains a tremendous speed increase.

This is possible because the architecture extensively use IoC to resolve services and components, and is simple to add features with AOP.

alk.

In this post I dealt with a primitive version of a T4 template to generate dto starting from domain objects. In these days I had little time to improve it a little bit, and I created a simple test project to verify some of the basic functionality.

Usage of the T4 template is really simple, I’ve created in the test project an Entity Factory model to the ubiquitous northwind database, then I added a OrderDto.tt file to the project with this content.

<#@ template language="C#" hostspecific="True" debug="True" #>
<#@ output extension="cs" #>
<#@ include file="DtoFactory.tt" #>
<#
// <copyright file="OrdersDto.tt" company="Gian Maria Ricci">
//  Copyright © Gian Maria Ricci. All Rights Reserved.
// </copyright>
    GenerateDto(
        @"bin\Debug\DtoFactory.Exe",
        "DtoFactory.Orders",
        "OrdersBaseDto",
        "DtoFactory",
        "http://www.nablasoft.com/dotnet/",
        1,
        new String[] {"OrderId", "OrderDate", "Customers.CustomerID", "Customers.ContactName"},
        null,
        true, true, true);
#>

It is quite the same of the previous version, but now I inserted some enhancements. If you look at the property list you can see that I inserted properties like “Customers.CustomerID” and “Customers.ContactName”, that belongs to the customers object. When you use a domain model you are working with a graph of object, but dto must be plain. My generator will generate this class:

My dto class implements various interfaces and it has properties like Customers_ContactName and Customers_CustomerID, so it is a simple transfer object that contains all information we need. The assembler class is responsible to create a dto from original object and as usual can be used in this way:

using (NorthwindEntities context = new NorthwindEntities())
{
    var Query = context.Orders
        .Where(o => o.Customers.CustomerID == "ALFKI")
        .Select(OrdersBaseDto.Assembler.ExpressionSelector);

    foreach (var order in Query)
    {
        Console.WriteLine("OrderId:{0} Customer:{1} Date:{2}",
            order.OrderID, order.Customers_CustomerID, order.OrderDate);
    }
}

This code simply use the ExpressionSelector contained in nested class Assembler of my dto of choice, then I can iterate into the query using various properties of the dto object. The most important stuff is that the expression selector actually does a projection, here is the generated query captured from the profiler.

SELECT
1 AS [C1],
[Extent1].[OrderDate] AS [OrderDate],
[Extent1].[OrderID] AS [OrderID],
[Extent1].[CustomerID] AS [CustomerID],
[Extent2].[ContactName] AS [ContactName]
FROM  [dbo].[Orders] AS [Extent1]
LEFT OUTER JOIN [dbo].[Customers] AS [Extent2] ON [Extent1].[CustomerID] = [Extent2].[CustomerID]
WHERE N'ALFKI' = [Extent1].[CustomerID]

Only the field related to the dto are retrieved, and thanks to Entity Framework you get the join and projection for free, no unnecessary data is taken from database. This is a quite good result, because with few lines of code my generator is able to geneate a dto composed by properties taken from various objects, and thanks to LINQ I also got a projection for free that permits me to gain maximum efficiency avoiding to retrieve full objects.

Another interesting stuff is this one, you can link various Dto objects between them

    GenerateDto(
        @"bin\Debug\DtoFactory.Exe",
        "DtoFactory.Orders",
        "OrdersTestDto",
        "DtoFactory",
        "http://www.nablasoft.com/dotnet/",
        1,
        new String[] {"OrderID", "OrderDate", "Customers"},
        new PropertyData[] {new PropertyData("Customers", "CustomersDto")},
        true, true, true); 

I’m asking to generate an OrdersTestDto object that contains the “Customers” property, but I specify that I do not want full Customers object, but simply a CustomersDto, so you will end in two dto connected together

This facility permits me to reuse dto but actually the ExpressionSelector of this dto cannot be directly used with LINQ, it needs still more work .

All the project is still in a very rought form, but I’m quite satisfied on it, if you like it you can download here. The code is provided as-is do not blame the author.

alk.

Tags: Dto T4 Code generation

Some days ago we have a question on the possibility to have a “Design UI first” approach to a project. (the forum post is in Italian). If you asked me this question some years ago, I surely have answered “Probably not”. I must admit that I always thought that some people gave too many importance to the UI. Quite often Project managers are the kind of people that always ask for impressive interface to show to final customers, while we, as programmers, tend to spent more attention to the “code part” of the project, and usually do not care about UI. After all where is the pride in putting some labels and textboxes in a form respect in designing a well crafted Domain Model with ORM and AOP etc etc.

I now realize that this is wrong!!

The problem is that the UI is directly perceived by the customer and final user, while internal structure is completely hidden. If you build a perfect program with a wrong ui, the customer will blame you, because even the most well crafted architecture fails if the UI is poorly designed. After all what is the point in having a perfect domain model, if the user can use it only through a poor interface?. This is the same of looking at a very good film full of special effects in an old 20’’ black and white screen, the film can be the best in the world, but you cannot perceive it because of viewing it through a poor interface.

Another key factor about UI is usability. Building a good UI does not means using 3D animations and shocking effects, but it is all about usability. If a software fails in usability, he is doomed to disappear.The problem here is that the world is not made of developers, and what is good for a developer, probably is not good for normal people.

For all those reason, probably it is possible to approach a problem starting with the UI, maybe side by side with Use Case approach. If you focus on the UI you need a tool that permits you to rapidly prototype a sketch of the interface, so the customer can immediately have a visual impact on the aspect of the final application. In this scenario Balsamiq can save your life. Consider this mockup as example, it took me no more than 10 minutes to sketch, and it is one of the first time I use balsamiq

This simple sketch can be immediately shown to the customer/user for review and validation. Moreover even if this is only a sketch, it gives immediately a clue on some technical difficulties that can arise. As an example we need Google Map integration, and we need to show various graphic artifacts like icons depending on properties of object. We also need internal link, because you can see a link that states “Go to Order”. We must show picture, use various tab like controls that shows tabs on top or on left, etc.

This interface also  capture the minimum amount of properties of various object, from it we can be sure that Customer object need a Name, Last Name, Age, Nickname, IsAKid (boolean) properties, and we also need to extract from database projections, like “Number of orders” for each customer. This means that even if we start with a UI prototyping, we also begin focusing on data that the software must handle, as well as relations between various objects.

Moreover if we begin the analysis of the project with use cases or other similar techniques, then build the software and finally show the result to the user, we have an high probability that the customer want to change something in the interface, and such changes sometimes impact on the overall architecture. (think to add a Drag and Drop to a web page). If you begin the analysis phase with UI mockup, the probability that the customer want to change the UI when it is finished is considerably lower.

After all A picture is worth a thousand words so I think that a UI First approach can be feasible.

Alk.

Tags: Ui prototyping

When you begin to use Team Foundation Server, you will create different builds for all of your company’s projects. Since building complex products can be resource intensive, it is likely that your Team Foundation Server machine starts to perform slowly. This is a typical issue of Continuous integration servers, since they compile projects at each check-in you will end with a lot of builds and a lot of work to do.

Team Foundation Server addresses this issue separating build machines from Team Foundation Server. If you find that the build machine is becoming slow, you can simply use another machine in the network to execute some of the builds. In real environment you can even avoid to install build engine in the Tfs machine, delegating builds to other servers. First of all go into another machine, fire the installer of Team Foundation Server, and choose to install a “Team Foundation Build”.

Note: if you do not have Active Directory you Must create in this machine an account with the same name/password of an account of the machine where Team Foundation Server is running and that account must have right to access tfs. This is a standar requirement, the Build Server needs to access Team Foundation Server to get sources to build and store build result, etc, etc. so it is of vital importance that it runs with sufficient privilege to access TFS server. If you have active directory you do not need to create a specific account, but you must select one AD user that have credential to access TFS during the installation.

When the installer finished, you can go to Visual Studio, Right Click on the Builds in the Team Foundation Server Explorer Tree, then choose “Manage Build Agents”

Now you can add additional Build Agent, and you can choose the new machine name, where you had previously installed the Team Foundation Build.

Now you can use this new machine to run Builds simply specifying this agent when you create a Build Definition, or you can use it when you manually queue new build. It is really important that the user credentials used to run the Build Service in the new Build machine has the right to access the Team Foundation Server Machine as stated before.

If you had already installed the team Build engine with a wrong user don’t panic, you can still manually change build machine settings to correctly access TFS. Go to Service control panel and change the credential used by the “Visual Studio Team Foundation Build” service to use an user that has sufficient credential for TFS. Now restart the service.

It is highly possible that when you restart the service you get “access is Denied” error, it means that the new account does not have sufficient rights to run, first of all the user needs rights to access the folder where you install the Build Agent, but this is usually not enough. The only way to understand exactly what is wrong is going into the Event Viewer where you can find detailed errors like this one.

Detailed Message: TF224004: The Visual Studio Team Foundation Build service failed to start because WS2008V1\alkampfer does not have the required access permissions for address http://ws2008v1:9191/Build/v2.0/AgentService.asmx.
Exception Message: HTTP could not register URL http://+:9191/Build/v2.0/AgentService.asmx/. Your process does not have access rights to this namespace (see http://go.microsoft.com/fwlink/?LinkId=70353 for details). (type AddressAccessDeniedException)

This message is one of the most dreadful, it means that the user has no rights to use that url to host  a web service. The solution is to run this couple of commands.

netsh http delete urlacl url=http://+:9191/Build/v2.0/AgentService.asmx
netsh http add urlacl url=http://+:9191/Build/v2.0/AgentService.asmx user=alkampfer

With these two lines of code you are giving to user Alkampfer (the one that has right to access Tfs and the one used to run build service) enough rights to create a web service in that url. Now you should be able to start the service. Verify if the Build Agent is running browsing the WebService page (something like http://10.0.0.11:9191/Build/v2.0/AgentService.asmx). Now if everything is ok, you should go to “Manage Build Agents” menu and reenable agent if necessary. This step is needed because Tfs disables all Agents that are unable to run. If you fire a build with an agent that has no right to access TFS the TFS disables that agent because it is useless. When you correct the problem, you can simply edit the Build Agent definition, and change its status back to active, now you can schedule again builds on it.

With such a configuration you can divide build tasks across multiple machines, and the whole build process is more scalable. The advantage is that you have a single point of access (the Tfs machine), and from that point you can subdivide works between machines. Since you can install how many build server you want, the whole system is highly scalable.

Alk.

Tags: Team Foundation Server

Data Transfer Objects, best known as Dto, are an essential part of projects that uses services or Domain Model. Dto are great, but the disadvantage is that maintaining Dto objects is a pain, because they are composed by repetitive code, and you have no fun in writing them.

Since building a Dto is a mechanical process it is better to use a code generation tool to generate them with little effort. If you work with visual studio 2008 the best choice in Code Generator is T4, because it is included in Visual Studio and is really good. I do not want to cover T4 syntax, because you can find tons of information following this post links.

You can download here a little project that contains a simple DtoFActory.tt file used to generate basic Dto out from a domain object. It is written with little effort, and it can contain errors, but I’m quite satisfied by the general result. To use it simply add the DtoFactory.tt file to your solution, then you can use in other tt file. In the example I simply generate a EntityFramework edmx against northwind database, then I create a CustomerDto.tt file with this content.

<#@ template language="C#" hostspecific="True" debug="True" #>
<#@ output extension="cs" #>
<#@ include file="DtoFactory.tt" #>
<#
// <copyright file="CustomerDto.tt" company="Gian Maria Ricci">
//  Copyright © Gian Maria Ricci. All Rights Reserved.
// </copyright>
    GenerateDto(
        @"bin\Debug\DtoFactory.Exe",
        "DtoFactory.Customers",
        "CustomersDto",
        "DtoFactory",
        "http://www.nablasoft.com/dotnet/",
        1,
        new PropertyData[] {"CustomerId", "CompanyName", "ContactName"},
        true, true, true); 

#>

As you can see I import the DtoFactory.tt file, then call the GenerateDto function. The first parameter is the relative path of the assembly that contains the original object. Relative means respect to the tt file itself, this is one of the part I do not like very much because you need to find out relative path and refers to the debug directory, but it can be acceptable.

Then I specify the fullname of the class, the name of the Dto object, the name of the namespace were to put generated class. Then I need to specify the namespace used in the DataContract attribute (I want my Dto to be transferrable by WCF), then the number of base classes to examine to find properties, a list of PropertyData object with names of the property of the original object I want in my dto, finally three boolean values to specify if I need my dto to implement INotifyPropertyChanged, INotifyPropertyChanged, and IEditableObject.

You can see that this simple template will generate a CustomerDto.cs file that contains a CustomersDto class that contains that three properties. The interesting part is how I generate the assembler of the Dto. To build a Dto the standard way to proceed is to take the original object and copy all needed properties into corresponding properties of the dto object. This is a suboptimal approach, because using such a technique, you are forced to load the entire object from the database. In My situation CustomersDto has only three properties, why I need to load an entire Customers object into memory to build a CustomersDto object that contains only three properties? The solution is in how my dtoFactory generates the assembler.

public static Expression<Func<Customers, CustomersDto>> ExpressionSelector;
public static Func<Customers, CustomersDto> Selector;

static CustomersDtoAssembler()
{

    ExpressionSelector = obj => new CustomersDto()
    {
        CompanyName = obj.CompanyName,
        ContactName = obj.ContactName,
        CustomerID = obj.CustomerID,
    };
    Selector = obj => new CustomersDto()
    {
        CompanyName = obj.CompanyName,
        ContactName = obj.ContactName,
        CustomerID = obj.CustomerID,
    };
}

As you can see my generator generates an Expression<Func<Customers, CustomersDto>>, and simply initialize it in static constructor with a simple lambda expression. If you are wondering why I need such a strange object let’s see how I use it

using (NorthwindEntities context = new NorthwindEntities())
{
    var Query = context.Customers.
       Where(c => c.CustomerID.StartsWith("A"))
       .Select(CustomersDtoAssembler.ExpressionSelector);

    foreach (CustomersDto customerDto in Query)
    {
        Console.WriteLine("ID: {0}, ContactName: {1}, CompanyName {2}",
            customerDto.CustomerID, customerDto.ContactName, customerDto.CompanyName);
    }
}

Thanks to LINQ to Entities, I can simply build a query to the NorthwindEntites data context, selecting Customers, applying a filter and specify the assembler ExpressionSelector seen before. This produces this query against my database.

SELECT
1 AS [C1],
[Extent1].[CompanyName] AS [CompanyName],
[Extent1].[ContactName] AS [ContactName],
[Extent1].[CustomerID] AS [CustomerID]
FROM [dbo].[Customers] AS [Extent1]
WHERE (CAST(CHARINDEX(N'A', [Extent1].[CustomerID]) AS int)) = 1

Thanks to the Expression<Func<Customers, CustomerDto>>, Entity Framework knows how to retrieve only the data he need to create the Dto, wonderful . With such a powerful generator I can create Dto objects with few lines of code.

Since this generator is not still fully tested feel free to send me suggestions, bugs, feature you wish to have, etc, etc.

Alk.

Code Download.

Tags: Dto

Here is a possible dialog between Customer/PM/Analyst and a programmer

Developers usually end with one or more of those thought

1. Analyst is a moron, he did a bad job not finding the real requirement of the customer
2. Customer are stupid because they does not know what they want, they are constantly changing requirements.
3. We lack requirement gathering phase, now we must loose time following desires of Analyst/Customer

Finally the programmer complains a lot about too much code to change, and how is painful working in an environment where noone is able to catch the real requirement of the customer.

Situation is much more different if you understand that the needs of the customer quite often change with time, we are in a fast world where moving slowly quite often leads to death, so it is absolutely normal that requirements changes with time. The only solution is Plan in advance for change, if you are ready for changes, you will having really less problem when some requirement changes over time.

Technically speaking, to have a software that can react quickly to change the key concept is loose coupling, through heavy use of Inversion of Control, you can minimize dependencies between the various part of the software. The more the software is loosely copuled, the more you can modify a part without affecting other parts.

Then you need a lot of tests, that can spot immediately when a change in some part of the software has introduced some bug. Then You need to setup a Continuous Integration machine, and make your tests run at each check-in, this assures you that tests are run frequently and automatically. Then you must setup a real good logging infrastructure, to trace immediately what is going wrong with the system. Finally you should work in asynchronous mode when possible, minimizing the coupling between different tiers in the software.

But probably the most difficult step is changing the way we manage software developement. We must change the way we approach the software, not fearing changes and reacting differently to change in requirements.

alk.

Tags: Software Architecture

Using Bidirectional Associations in nhibernate can be tricky, the problem is that you need to manage associations for both ends. This is really important: suppose you have a class called Parent with a collection of childs called Childs, and a child class with a property called Parent; if you expose these two property to the user, you can write this

Parent John = new Parent();
Parent Mark = new Parent();
Child Bart = new Child();

John.Childs.Add(Bart);
Bart.Parent = Mark;

With such a code Bart’s parent is Mark, but Bart is in John Child collection, this is WRONG. To avoid this problem you should maintain integrity in the domain model, managing the consistency of the relationship. Suppose you have the same situation with two objects, a StockKeepingUnit and a StockContainer, here it is the code for StockKeepingUnit

 public virtual StockContainer Parent
 {
    get { return parent;}
    set
    {
       if (parent != null)
          parent._Content.Remove(this);

       parent = value;

       if (value != null)
          value._Content.Add(this);
    }
 }

 private StockContainer parent;

As you can see in the setter part I first check if this object has a parent, if yes we need to remove it from the _Content collection of the parent object (because actually I’m detatching from it); then if the value is different from null it means that we have a new parent, so the object assign itself to the _Content collection of the new father to mantain integrity. Surely you now need to map this property in directly on the field to avoid problem

<many-to-one name="parent" access="field" class="StockKeepingUnit" ... />

It is of fundamental importance that you map to the field, this because when nhibernate rebuild the object from database, you must avoiding calling the Set part of the Parent property, because the coherence of the objects are guaranteed by nhibernate itself. Now here is how I implemented the Collection part on the SockContainer class

 public virtual IEnumerable <StockKeepingUnit> Content
 {
    get { return _Content;}
 }

 internal virtual ISet<StockKeepingUnit> _Content
 {
    get
    {
       return content ?? (content = new HashedSet <StockKeepingUnit>());
    }
    set
    {
        content = value;
    }
 }
 private ISet<StockKeepingUnit> content;

First of all the ISet class is a private field, and the accessor property, called _Content, is internal because it must be accessed by the StockKeepingUnit code seen before, but must not be accessed from external code. The property is implemented with lazy creation, if the content property is null, I simply create an HashedSet, this is useful when you first create the object, because initially this property is null. When nhibernate rebuild the object from database data, the content private field is set by nhibernate, so I can avoid unnecessary creation of HashedSet. With this kind of structure you can map nhibernate to the _Content property and not to the field.

Now a question arise: How can the user of this class access the Collection of StockKeepingUnit if the _Content property is private? The answer is in the property Content that is of type IEnumerable<StockKeepingUnit>. With Ienumerable I permit the user to use fully LINQ syntax to access collection of StockKeepingUnit, this is enough for most scenarios because with LINQ you can iterate, filter, select and doing whatever you want to access all StockKeepingUnit contained in a stockContainer.

Alk

Tags: NHibernate Domain Model

I have a domain model composed by Clients, each client has a series of associated Typology objects and each Typology object has a certain number of associated Target. Now I need to bind this model to a series of three combo in WPF, but I have this little problem

The model is not directly accessible, I have already a service that has functions like GetAllCustomer, GetTyplogyForCustomer(Int32 customerId) and GetTargetForTyplogy(Int32 typologyId). Each method returns a list of the corresponding object, but they are DTO and not real object, so the Customer, Typology and Target returned from the service have no relation between them. Moreover I do not want to load everything when the application starts, because it will be extremely slow, I want to be able to load data as it needed, with lazy load. I created a couple of classes that I can use to lazily load entities

  The LazyPartitionedList class is used to load collection of data partitioned by some value. I need such a base class for typology, I do not want to load all typologies in a single shot, I need only to load for currently selected customer, then when the current customer changed on the WPF interface I need to load (if it was not already loaded) from the service the list of typologies for the new customer. The LazyPartitionedList does this all for me. Then I create a browser class that link all toghether

   public class AnalysisDefinitionBrowser
   {
      private LazyCollection<Client> customers;
      private LazyPartitionedCollection<TypologyDto, Client> typologies;

The class analysisDefinitionBrowser have a lazycollection of customers (it loads all customer in one shot) then It has a LazyPartitionedCollection of TypologyDto partitioned by Client object. In the constructor of this object I initialize everything

customers = new LazyCollection<Client>(
   () => Services.CustomerService.GetAllClient().ToList());
typologies = new LazyPartitionedCollection<TypologyDto, Client>(
  c => Services.KeywordService.GetTipologiesForCustomer(c.Id));
...
customers.Reinit();
cvCustomers = CollectionViewSource.GetDefaultView(customers);
if (cvCustomers != null)
{
  cvCustomers.CurrentChanged += cvCustomers_CurrentChanged;
}

Customers gets immediately loaded (Reinit Method), the interesting thing is that the LazyPartitionedCollection for typology Id is initialized with a function that calls the service to load typologies for current customer, actually no typology gets loaded. Another interesting thing is that using the CollectionViewSource I’m able to retrieve the default view for the Customer list.

void cvCustomers_CurrentChanged(object sender, EventArgs e)
{
   CurrentClient = (Client)cvCustomers.CurrentItem;
}
private Client CurrentClient
{
   get { return currentClient; }
   set
   {
      currentClient = value;
      if (value != null)
         typologies.LoadPartition(value);
      currentTypologies.Clear();
      foreach (TypologyDto typology in typologies.Where(t => t.CustomerId == value.Id))
      {
         currentTypologies.Add(typology);
      }
   }
}
private Client currentClient;

The property CurrentClient have a particular Setter part, it loads the partition of the current Client object, then it copy in an ObservableCollection<TypologyDto> called currentTypologies only the typologies that are associated to current customer. With this trick if I already loaded that partition data are in memory and the service gets called only the first time, and only when it is needed. With this code I’ve created a class that load data only when it is needed, and keep selection in sync with the current properties. The beautiful thing of this object is that I can test it with no problem

private void TestTemplate(
   Action<ICustomerService,IKeywordService> SetupAction,
   Action ExerciseAction)
{
   ICustomerService cs = RhinoRepository.StrictMock<ICustomerService>();
   IKeywordService ks = RhinoRepository.StrictMock<IKeywordService>();

   SetupAction(cs, ks);
   RhinoRepository.ReplayAll();
   using (Services.CustomerService.Override(cs))
   using (Services.KeywordService.Override(ks))
   {
      ExerciseAction();
      RhinoRepository.VerifyAll();
   }
}

[Test]
public void VerifyLoadingOfTheSecondLevelTwoCustomer()
{
   Client c1 = new Client() { Id = 111 };
   Client c2 = new Client() { Id = 222 };
   TypologyDto t1 = new TypologyDto() { Id = 444, Name = "1", CustomerId = c1.Id };
   TypologyDto t2 = new TypologyDto() { Id = 445, Name = "2", CustomerId = c2.Id };
   TypologyDto t3 = new TypologyDto() { Id = 446, Name = "3", CustomerId = c2.Id };
   TestTemplate((cs, ks) =>
   {
      Expect.Call(cs.GetAllClient()).Return(new[] { c1, c2 });
      Expect.Call(ks.GetTipologiesForCustomer(c1.Id))
         .Repeat.Once()
         .Return(new List<TypologyDto> { t1 });
      Expect.Call(ks.GetTipologiesForCustomer(c2.Id))
         .Return(new List<TypologyDto> { t2, t3 });
   },
    () =>
    {
       AnalysisDefinitionBrowser sut = new AnalysisDefinitionBrowser();
       sut.cvCustomers.MoveCurrentToPosition(-1); //Resetto il binding
       sut.cvCustomers.MoveCurrentToFirst(); // Mi muovo sul primo
       Assert.That(sut.CurrentTipologies, Has.Count(1));
       sut.cvCustomers.MoveCurrentToPosition(1); // Mi muovo sul primo
       Assert.That(sut.CurrentTipologies, Has.Count(2));
       sut.cvCustomers.MoveCurrentToFirst(); // Mi muovo sul primo
       Assert.That(sut.CurrentTipologies, Has.Count(1));
    });
}

The TestTemplate is used to create and setup mock for services, my services classes are static wrapper that permits me to override the real instance of service used, so I can use a different mock for each call of the service. Then the test simply setup some expectation and exercise the AnalysisDefinitionBrowser with direct manipulation of the ICollectionView object, thus simulating the user that changes currently selected item in the interface.

This test access the cvCustomers internal ICollectionView object because the Test assembly is InternalVisibleTo the test that contains the sut. The XAML code is something like this (I’ve bound a controller as the root source of the page, the controller initialize an instance of AnalysisDefinitoinBrowser and expose it with a dependency property called AnalysisDefinition)

<ComboBox DockPanel.Dock="Top"
          ItemsSource="{Binding AnalysisDefinition.Customers}"
          IsSynchronizedWithCurrentItem="True"
          DisplayMemberPath="Name"
          SelectedValuePath="Id"></ComboBox>
          ...
<ComboBox ItemsSource="{Binding AnalysisDefinition.CurrentTipologies}"
          IsSynchronizedWithCurrentItem="True"
          DisplayMemberPath="Name"
          SelectedValuePath="Id" ></ComboBox>

Now when I fired the application and look into the sql server profiler I can see that object gets transparently loaded while I’m browsing the objects with the two combo, each time I select a new customer I see query that load related typologies, when I select a customer that was already selected in the past data are already in memory.

alk.

Tags: WPF Binding

In this very interesting link brendan spoke about how to organize the trunk of a project. I think that this is a very important subject, especially for medium sized or big project. If you fail to organize your source code including everything you will end with trouble. In the past it happened to me to work on project where you need to spend a lot of time just to have the first run ok. I need to download and install tools, libraries, then I need to open a solution, compile and move dll into another folder etc etc etc. This situation is a clear indication of a bad organization of the trunk.

A project is not only composed by source code, so you need to include in your repository everything you need to build the project. I include all the installer of third part library, and clear indication on how to get trial license if needed, I also included all binary version of open source libraries (like nhibernate and nunit), I included every document that you need to read to make the software run (EX. manuals of hardware if your software need to communicate with various RFID libraries) but the tougher part is creating a good structure for the project and creating a good build script.

In big project building everything is not so simple, we cannot simply have a solution with 100+ projects, but we usually divide the software into smaller areas, then you need a series of script that build everything from the ground up, moving all the binaries in a well known directory (the artifact or the build one) so you can divide the project into smaller solution that are more manageable.

The goal is having a project where any new developer can start to work with little three steps

1. checkout the solution in a local folder
2. Reads documentation and install any needed third party packages
3. Launch a build script

After step 3 the developer should be able to open any solution in the project and being able to work, this means that the script should create local databases for test sandbox, MSMQ if needed, and any other stuff that is needed in order to have a running solution. This means having a "alive project".

alk.

Tags: project management

If you still work with windows forms and cannot move all of your projects to WPF, you probably gets annoyed by the limitation of the standard BindingList<T> included in the framework. In an old post I showed how can you create a specialized BindingList<T> to support generic Find() thanks to reflection, but this is not enough.

Another annoying limitation is that BindingList does not support IBindingListView. For those that does not knows this interface, it is the one used by the windows forms binding engine to support filtering and advanced sorting. I think that filtering is a real basic functionality needed by the binding engine, and in fact WPF support for filtering, sorting and grouping, make these operations really a breeze. But BindingList does not offers such a functionality.

My question is: is it possible to inherits from BindingList<T> adding generic filtering support as for the DataView component?. The answer is yes, here is a simple implementation.

public string Filter
{
    get
    {
        return filterClause;
    }
    set
    {
        if (filterClause == value) return;
        filterClause = value;
        DoFilter();
    }
}

This is really simple, I implement the FIlter property with a simple check, if the filterClause changes, I call the DoFilter function.

private Func<T, Boolean> filterPredicate;

private List<T> original = new List<T>();

private void DoFilter()
{
    if (String.IsNullOrEmpty(filterClause))
    {
        Items.Clear();
        original.ForEach(e => Items.Add(e));
    }
    else
    {
        original.Clear();
        original.AddRange(Items);
        Items.Clear();
        filterPredicate = DynamicLinq.ParseToFunction<T, Boolean>(filterClause);
        foreach (T element in original.Where(filterPredicate))
           Items.Add(element);
    }
}

The implementation is based on this standard trick, if a filter is applied I copy all the elements in a temp list, then clear the base.Items list and add again only the elements that satisfies the filter. The big work is done in DynamicLinq.ParseToFunction that takes a string and dynamically compiles a function with that criteria. Here is a simple test showing this class in action.

[Test]
public void TestLogicAnd()
{
    Func<Customer, Boolean> f = DynamicLinq.ParseToFunction<Customer, Boolean>("Name == 'Gian Maria' && Age > 5");
    Assert.That(f(aCustomer), Is.True);
}

Actually I use three main component, a tokenizer that takes a string and separates into token, then I pass the tokenized expression (is a List<String>) to another component that convert the infix form in postfix form (reverse Polish), finally I create an expression from the reverse Polish form, creates a LambdaExpression on it and finally call compile() to make dynamic generation happens. The result is a dynamic generator of LINQ expression from a string. It still misses a lot, you cannot express condition on nested properties and parameter support is still experimental, but the basic is there.

The code is still under development, if you are curios you can check out the repository at http://dotnetmarcheproject.googlecode.com/svn/trunk the code is still in rough form, but if you like it you can give it a shot. The class is the BindingListExt<T>

Alk.

Tags: BindingList IBindingView Dynamic Expression Parser

When you work with domain model your domain objects become more complex than a simple containers for table values. This makes somewhat problematic using these object directly with the UI, especially when you use native binding. Let’s make an example, I have this object called Domain

As you can see the Domain class has a property called ContentBlackList that is a List of String. The setter is private and in the getter the list is created lazily, then I have a User Type to map this property into a single field of a table in a list of string separated by the charachter #. The object works well, until I want to bind this property directly to a textbox in a form.

This is a common problem, if objects are not simple container for database fields it could happens that they cannot be used directly with the binding engine.

The first problem is, I need to convert the list<String> to a string to show data in textbox and back when the user change content of the textbox. This is fairly simple in windows forms thanks to Parse() and Format() methods of Binding object

 1 private void AddFormattingForStringList(TextBox textBoxControl)
 2         {
 3             Binding b = textBoxControl.DataBindings["Text"];
 4             if (b == null) return;
 5             b.Parse += ConvertStringToList;
 6             b.Format += ConvertListToString;
 7         }
 8 
 9         void ConvertListToString(object sender, ConvertEventArgs e)
10         {
11 
12             List<String> list = (List<String>)e.Value;
13             if (list == null || list.Count == 0)
14                 e.Value = String.Empty;
15             else
16                 e.Value = list.Aggregate((s1, s2) => s1 + "," + s2);
17         }
18 
19         void ConvertStringToList(object sender, ConvertEventArgs e)
20         {
21             String value = (String)e.Value;
22             if (String.IsNullOrEmpty(value))
23                 e.Value = new List<String>();
24             else
25                 e.Value = value.Split(',', ' ', '|', ';').ToList();
26         }

As you can see in line 3 I get the Binding for property “Text” of a textBox, this is necessary because I could have more bindings to other properties. Then if the binding is not null I listen for the Parse and Format events. The parse event is invoked when the Binding takes the value from the control (Textbox.Text property, a string) and assign it to the original property (a List of String) and the attached ConvertStringtoList simply split the string with various separator and uses ToList() to create a list from the array. The ConvertListToString attached to the format event, does the reverse operation, converting a list of string in a comma separated list of string, this is a breeze thanks to the Aggregate Linq operator.

But this is not enough, if you look closely at the property implementation of the original object you can see that the set part of ContentBlackList is private. This is needed because the user must not be able to change the inner IList<String> used by the object. This is especially important if you use an ORM like nhibernate, because usually NHibernate use lazy list and you should not substitute with other list. Since NHibernate can access private properties I’m sure that noone can tamper the original IList<String> implementation.

Now the problem is: Binding Engine cannot set private property, so the binding is broken.

This happens because the Domain Object is not designed with Ui in mind, and this is a  good thing, because the Domain should not depend from the Ui. To solve this typical problem you can resort to the old Proxy pattern.

As you can see the proxy wraps a real Domain object and exposes the ContentBlackList to the UI and presents both get and set methods. The Set methods simply remove all objects from the original list and then insert again thus permitting me to bind this object directly to a textbox.

The general problem discussed here is that Objects from Domain quite often are not directly usable with the UI layer, and a proxy can be a good solution, even if in domain with hundreds of classes, doing a proxy for each class can be a manteniance nightmare.

alk.

Tags: Binding Proxy

In my experience it is not a good idea to put in direct communication stakeholders (customers) and programmers, here is the typical result

Lets analyze this typical situation from the perspective of the stakeholder; he have all the reason to ask for new features, he does not possess strong technical skills, and since he is the one who actually pay to build the software, he does not understand why he cannot ask for a simple modification. Moreover the developer is speaking some obscure technical jargon, so he could not understand the reason behind these difficulties.

From the perspective of the programmer, the customer is the one who always change the game, he does not understand the technical implications that can lie behind a simple button, so he resort to intimidate him with technical jargon, hoping that at least he will understand that adding that ***** button will not be an easy task.

In the end both the contendants  feels that the other part is not doing his part of the work, it is not a good situation to manage.

But the ultimate question is “there is a solution?”, in my opinion the answer is “you need an analyst”.

The analyst is capable to speak with customer in plain english, and since he possess some technical skills, he can anticipate some of the problems. Then he is capable to analyze the needs of the customer to find the way to fulfill them with alternate solution, quite often the alternate solution could be even better for the stakeholder. Then the analyst speak with the development team, he shows all the possibilities to the developers that will give to each alternative a weight. The final step is choosing the possibility that satisfy the customer but have no great impact on the system, if any.

The analyst is the logical connection between the needs of the customer and the programming team. His ultimate goal is to fully understand all stakeholder’s needs, finding alternatives to each goal, trying to anticipate problems and most important, he is constantly trying to eviscerate all customer’s needs as soon as possible. Without a good analysis you cannot write good software.

alk.

Tags: Analysis Software

I’m developing a little library that basically does these steps

1) open a docx file
2) Find a particular bookmark in the file
3)Add some content at bookmark position
4) Save the updated file.

This is a typical call

I like very much this kind of syntax, since we chain every method we always have intellisense that suggest us what to call, if you read the code you can easily check that we add two simple cell with text, then we add a cell with complex text, then another paragraph and finally another table, here is the result on the final document.

Fluent interfaces like these fully benefit from intellisense and are really simple to use.

alk.

Tags: fluent interface

Today I was reading this post from my friend Marco, where he points out one of the most frequent problem in the design of domain Model: too much use of relations. The problem arises from the fact that an ORM like NHibernate, seems to solve all the problems because it handles all the complexities, but there are a lot of considerations to be done before establish a relation between entities. Let’s have a brief look at the classical example of Customer-Orders

Since an order is related to a Customer, it is good to have relation from Order to Customer, it has business meaning since an order can live only when a customer places it with E-commerce site or in some other way. Lazy load minimize the hit to the database, issuing the select only when you access the data. If you want to associate an order with a Customer, you can avoid loading Customer data if you have CustomerId stored somewhere

Order.Customer = session.Load<Customer>(customerId);

This instruction uses ISession.Load(), that actually creates a proxy of the Customer Object, and since NHibernate needs only the Id of an object to set the relation, customer table never gets queried. This is good

Association between objects seems to make life easier, so one of the most frequent error is thinking that if an association is good, bidirectional association is two times good. With an ORM, lazy load, persistence by reachability, add associations between objects is a tempting strategy….but pay attention, this is the devil whispering to you hear, because bidirectional associations can be really dangerous.

To understand what is happening behind the scenes, suppose you decide to create an association from customer to order, with a simple property Orders of type IList<Order> in the Customer object. This is not a bidirectional association yet, but it is already problematic. First example: adding an order and a new Customer.

Customer gianMaria = new Customer("Gian Maria", "Ricci");
Order order1 = new Order(DateTime.Now, 10.00f);
gianMaria.Orders.Add(order1);
session.Save(gianMaria);

Here is the sql:

NHibernate: INSERT INTO CustomerOne (Name, Surname) VALUES (@p0, @p1); select SCOPE_IDENTITY(); @p0 = 'Gian Maria', @p1 = 'Ricci'
NHibernate: INSERT INTO Orders (Date, Total) VALUES (@p0, @p1); select SCOPE_IDENTITY(); @p0 = '7/22/2008 8:39:09 PM', @p1 = '10'
NHibernate: UPDATE Orders SET CustomerId = @p0 WHERE id = @p1; @p0 = '4', @p1 = '7'

You can see that the order is first inserted into the table with the customerId field equals to null, then the relation is setup with an Update, this means that two queries are needed to setup a relation, this is not scaring, but here is another example, adding an order to an existing customer.

Customer loaded = session.Get<Customer>(gianMaria.Id);
Order order2 = new Order(DateTime.Now, 10.00f);
loaded.Orders.Add(order2);
session.Flush();

This code seems really simple, you load a customer knowing its id, then create a new order, and finally add the order to the inner collection of orders to setup the association, but if you knows how lazy load works you already expecting this SQL

NHibernate: SELECT customer0_.id as id1_0_, customer0_.Name as Name1_0_, customer0_.Surname as Surname1_0_ FROM CustomerOne customer0_ WHERE customer0_.id=@p0; @p0 = '4'
NHibernate: SELECT orders0_.CustomerId as CustomerId__1_, orders0_.id as id1_, orders0_.id as id0_0_, orders0_.Date as Date0_0_, orders0_.Total as Total0_0_ FROM Orders orders0_ WHERE orders0_.CustomerId=@p0; @p0 = '4'
NHibernate: INSERT INTO Orders (Date, Total) VALUES (@p0, @p1); select SCOPE_IDENTITY(); @p0 = '7/22/2008 8:48:53 PM', @p1 = '10'
NHibernate: UPDATE Orders SET CustomerId = @p0 WHERE id = @p1; @p0 = '4', @p1 = '6'

First of all, even if you have the Id of the customer you need to load it entirely from db, but the worst thing happens when you add the order to the orders collection, because nhibernate does lazy load, loading all the orders of the customer in memory, finally he generate the insert and update as before.

Think again to it “To add an order you have to load in memory all customer orders”. What happens if the Customer have hundreds of orders??? Sounds bad, isn’t it? Moreover you are wasting memory for nothing….you never access all the orders, you only want add new one.

Similar thing happens whenever you access Orders collection, if you access the first element all the orders are loaded, if you call Count all orders gets loaded. To avoid this you need to use ISession.CreateFilter() that permits you to issue a Count(*) query without loading the elements or scan orders with pagination, but you can agree that this is not a good situation.

And with a bidirectional association things get worse, because you have also to keep the domain consistent, what happens if we add an Order in the collection of Customer1 and set the Customer property of the same order to Customer2?

The rule of thumb is that you need to set bag relations only when the containing object really needs the collection of child to have business meaning. If we have the FootballClub object it makes sense to have a collection of Players, after all, a Football Club without players has really little business meaning.

The whole problem originates when the developer use relations to reduce the explicit load operations from the database. Since ORM have lazy load, one can think to relate every object, in this way when you have an instance you can retrieve every other instance simply traversing the tree. But the domain is a representation of our business done with objects, and relations are used to explain what concepts are related and how, resists the temptation to use relations only as a way to navigate object tree, you should use repository for that.

When designing relations between object the aggregate pattern (http://domaindrivendesign.org/discussion/messageboardarchive/Aggregates.html) is really useful, because a wise use can limit relations. The key concept is

Allow external objects to hold references to root only.

This means that no relation can be done between two objects that are no root, but another important thing is

Transient references to the internal members can be passed out for use within a single operation only.

Is the root that have complete control of the objects inside the aggregate, we create repositories only for Roots object limiting the way the user can access the domain.

Another concept that is of key importance is “Value objects” . Lets first point out that in DDD terminology, the term “value object” has nothing to do with the concept of .NET value object they are completely different thing. A value object in DDD is an object that has no identity and cannot live without a Entity object that contains it. Here is the definition of Evans in Domain Driven Design

An object that represents a descriptive aspect of the domain with no conceptual identity is called a VALUE OBJECT.

Sometimes is not simple to understand if an object is a value or entity and this distinction mainly depends from the domain. Lets do an example with an hypothetical Address object like this

Street: Loc Piano Di Frassineta
Number: 1
City: Sassoferrato

This is my address , but it is a value or an entity object? In a software for an E-Commerce we can agree that having an address without a customer, or supplier or some other entity is really not useful, so the address is a good candidate to be a Value Object. The situation can be different for a software that need to calculate ICI (ICI is a tax on house in Italy), in such a software an address can be an entity, because the address identify the entity that has to be taxed. The key question that makes us distinguish between value and entity object is “This object can have a lifecycle of his own?”.

A correct use of Value Objects leads to reduction of relations, because relations from or to a Value Object is not permitted except from the object that contains it. Quite often the value object is stored in the same table as the owning object, it has no id and he share the lifecycle with containing object, so making a relation to it has really no sense.

Today Marco told me that he saw domains where we have object like Address, Street, Street Number, Zip code, all having bidirectional association between them. Rethinking such structure with Value objects greatly reduces problems.

Finally remember the YAGNI  principle, avoid adding an association unless you really needs one and try to set up relations only when they have business meaning. I want to point out agaion that relations are not to be used for navigation because the purpose of retrieving object from the storage is duty of the repository. If we really want to access orders from customer object we can simply set up a method in Customer object called GetOrders(DateTime from, DateTime to) that internally access repository and gets order with a criteria.

Alk.

Tags: Domain Driven Design Value Object Domain Relation