Marcin Budny 's blog

Unity auto registration

2009-11-03T23:06:00.001+01:00

Auto registration is a great feature for any Dependency Injection container. Suppose you decided to implement the Domain Event pattern. So you have a bunch of events and some event handlers. These event handlers are classes implementing some common interface, say IHandlerFor<TEvent>. You also have a central registry of these handlers, so that you can easily find handlers for particular event – and run them passing the event data. But how does the registry know about these handlers? Well, you probably have to register all of them in the registry with some kind of configuration code. If your registry is built upon your DI container you can take advantage of auto registration feature. That is if your container supports it like Castle does.

Unfortunately Unity doesn’t do that out of the box, but there is a nice library by Artem Govorov on Codeplex, that will let you do just that. It has a nice syntax and offers a great deal of flexibility. Basically in order to achieve auto registration you:

Select which assemblies are scanned for types to register
Specify which types are to be registered by providing conventions
Specify how the types should be registered in the container (select an interface for type, select a name under which it is to be registered)

Of course there are some predefined predicates and other methods that make working with the library easier. For more details, please visit the project’s page.

What I found the library lacked is a predicate that would allow to select types, which implement a generic interface that is constructed from specified open-generic interface (generic type definition).To use an example of domain event: If I have an event called OrderAdded and a handler implementing IHandlerFor<OrderAdded>, the open-generic interface is IHandlerFor<>. By specifying this open-generic interface I can register all handlers at once and later access concrete generics when needed. Of course you can write the predicate yourself, but it would be nice to have it out of the box.

So I introduced this predicate and Artem was kind enough to apply this patch to the library’s codebase. Now having this:

public class OrderAdded { }

public class NotifySalesHandler : IHandlerFor<OrderAdded> { }

public class SendConfirmationHandler : IHandlerFor<OrderAdded> { }

I can do this:

_container
    .ConfigureAutoRegistration()
    .IncludeAssemblies(_testAssemblies)
    .Include(type => type.ImplementsOpenGeneric(typeof(IHandlerFor<>)), 
        Then.Register().AsFirstInterfaceOfType().WithTypeName())
    .ApplyAutoRegistration();

var orderAddedHandlers = _container.Resolve<IHandlerFor<OrderAdded>>();

Of course with no additional setup required I am able to resolve any other hadlers for whatever events I might have.

Typed Expand() for Linq to NHiberante

2009-10-13T18:28:00.001+02:00

( You can get code discussed in this post here )

One of things that keep me irritated in Linq to NHibernate is the way you specify eager fetching paths. Suppose you have domain model like this:

Normally you do things like this:

using (var session = sessionFactory.OpenSession())
{
    var invoices = session.Linq<Invoice>().Expand("Customer").ToList();
}

I don’t like using strings to identify type members since this way they’re not impacted by refactoring changes using automatic tools. What’s more, Expand returns IQueryable<T> instead of INHibernateQueryable<T>, which means you can’t chain multiple paths and have to use some temporary variable.

So to address those issues it would be nice to have ability to specify eager fetching path using labmda expressions and to chain them. For this purpose I created a little extension to INHibernateQueryable<T>, which allows you to do this:

[Test]
public void CanExpandSimpleProperty()
{
    var nhQueryable = 
        MockRepository.GenerateStub<INHibernateQueryable<Invoice>>();
    nhQueryable.Expand(i => i.Customer);

    nhQueryable.AssertWasCalled(nhq => nhq.Expand("Customer"));
}

[Test]
public void CanExpandNestedProperties()
{
    var nhQueryable =
        MockRepository.GenerateStub<INHibernateQueryable<Invoice>>();
    nhQueryable.Expand(i => i.Customer.CustomerCategory);

    nhQueryable.AssertWasCalled(nhq => nhq.Expand("Customer.CustomerCategory"));
}

This is pretty easy to do. But there is another scenario that complicates things a little: what if you would like to fetch invoices along with invoice items and with products. Since Items is a collection of InvoiceItem object, so there is no way of directly specifying a path like: Invoice –> Items –> Product. If Items is an IList or IList<T>, the extension allows you to do this:

[Test]
public void CanExpandCollectionTraversal()
{
    var nhQueryable =
        MockRepository.GenerateStub<INHibernateQueryable<Invoice>>();
    nhQueryable.Expand(i => i.Items[0].Product);

    nhQueryable.AssertWasCalled(nhq => nhq.Expand("Items.Product"));
}

So you can traverse collections using the indexer. But what if you have a collection like ISet, which doesn’t have an indexer? For this scenario, extension provides notion of subpaths:

[Test]
public void CanExpandWithSubpath()
{
    var nhQueryable =
        MockRepository.GenerateStub<INHibernateQueryable<Invoice>>();
    nhQueryable.Expand(i => i.Items,
        Subpath.For<InvoiceItem>().Add(item => item.Product));

    nhQueryable.AssertWasCalled(nhq => nhq.Expand("Items.Product"));
}

You can also chain multiple Add calls in order to specify more than one subpath rooting from type provided in For<T> method.

You can get this extension here. Hope this helps!

Linq to NHibernate First() bug

2009-10-10T21:53:00.001+02:00

As I suspected Linq to NHibernate has some flaws. I just discovered a bug showing up when eagerly loading collections and using IQueryable<T>.First(). Suppose you’ve got persistent class like this:

public class Invoice 
{
    public virtual int Id { get; set; }

    public virtual IList<InvoiceItem> Items { get; set; }

}

Normally, if you want to get and instance by id with eagerly loaded collection of items, you’d write something like this:

using (var session = sessionFactory.OpenSession())
{
    var nhQueryable = session.Linq<Invoice>();
    nhQueryable.Expand("Items");
    var invoice = nhQueryable.Where(i => i.Id == id).First();
}

This code executes without any errors, but unfortunately you always get only one item in Items collection. A quick investigation there and it turns out there is a problem with SQL generated by this query. NHibernate performs eager fetching by means of outer joins. This means that SQL query would return as many rows as there are invoice items associated with this invoice. But usage of the First() method results in the SQL query having TOP(1) clause, which causes database to return only one invoice item. It seems to be a bug in Linq to NH because according to information found on the web, such queries expressed with Criteria API work just fine. Well, you can either not use Linq to NH or just write this:

var invoice = nhQueryable.Where(i => i.Id == id).ToArray()[0];

When in doubt, write some code

2009-09-27T20:26:00.001+02:00

Well, that was some time since I last posted. I had some private matters going on, but hopefully I will be able to make up for that time.

Currently I’m starting a new project – internet facing web application. Carefully considering technologies that I would use I came up with this:

Web layer:

ASP.NET MVC
jQuery

Application layer:

WCF for exposing services
NHibernate with additional help of Fluent NHiberante and Linq for NHibernate

Common:

PostSharp for AOP
Unity for DI

However I still have some doubts related to those choices. ASP.NET MVC while being seemingly perfect for internet facing application, is still quite new on the market and not really proven. Because I don’t have any experience with this technology, I don’t know what can be expected. As for NHibernate I have some previous experience and I generally know where the traps are set for me. But Fluent NHibernate and Linq for NHibernate are also new for me. Especially Linq for NH, despite being version 1.0, seems immature. There are some bugs open for it, which seem to be quite serious. I’m not really sure if it will be Linq or if I will just stick with Criteria API, which supports a very interesting feature of futures since NH 2.1.

With all those doubts I would be crazy just jumping into full scale development. In my opinion the best way to verify architectural assumptions is to write some code. So I intend to create a prototype of the application, which will reflect structure of the final solution, but with some simplifications, that would allow to achieve some basic functionality in short time. After this is done, I hope to be able to assess my assumptions and – if something is wrong – to correct this, before changes in architecture start to cost some real money.

Building a fluent interface

2009-06-20T23:04:00.001+02:00

Who doesn’t like fluent interfaces? They allow to write things down in more compact manner and keep them readable in the future. Almost all contemporary libraries have fluent APIs. Some of them don’t (see LLBLGen Pro for example, argh!), but they definitely should get one.

In this post I’d like to show how to build a really simple fluent interface, and then – how to make it a little better. In the example, we’ll be writing a simple interface for creating and running SQL queries. What we want to achieve is ability to write code like this:

var query = new QueryFactory().Create();

var result = query
    .From("Employee").Alias("e")
    .Join("Order").Alias("o").On("e.EmployeeID = o.EmployeeID")
    .Where("o.TotalPrice > 1000")
    .Execute<Employee>();

As you can see, fluency is gained by chaining method calls on an object. The QueryFactory class is our entry point and returns IQueryBuilder interface, which then serves as our fluent API for building the query. The IQueryBuilder interface is defined as follows:

public interface IQueryBuilder
{
    IQueryBuilder From(string tableName);
    IQueryBuilder Join(string tableName);
    IQueryBuilder Alias(string alias);
    IQueryBuilder On(string joinCondition);
    IQueryBuilder Where(string filter);

    IList<T> Execute<T>();
}

Every method returns IQueryBuilder interface, which allows to chain calls. A sample implementation could look like this:

public class Query : IQueryBuilder
{
    private class TableOptions
    {
        public string TableName { get; set; }
        public string Alias { get; set; }
        public string JoinCondition { get; set; }
    }

    private List<TableOptions> tableOptionsList = new List<TableOptions>();
    private TableOptions currentTableOptions;
    private string filter;

    #region IQueryBuilder Members

    public IQueryBuilder From(string tableName)
    {
        currentTableOptions = new TableOptions() { TableName = tableName };
        tableOptionsList.Add(currentTableOptions);

        return this;
    }

    public IQueryBuilder Join(string tableName)
    {
        currentTableOptions = new TableOptions() { TableName = tableName };
        tableOptionsList.Add(currentTableOptions);

        return this;
    }

    public IQueryBuilder Alias(string alias)
    {
        if (currentTableOptions == null)
            throw new InvalidOperationException("First specify a table");

        currentTableOptions.Alias = alias;
        
        return this;
    }

    public IQueryBuilder On(string joinCondition)
    {
        if (currentTableOptions == null)
            throw new InvalidOperationException("First specify a table");

        currentTableOptions.JoinCondition = joinCondition;
        
        return this;
    }

    public IQueryBuilder Where(string filter)
    {
        this.filter = filter;

        return this;
    }

    public IList<T> Execute<T>()
    {
        tableOptionsList
            .ForEach(options => Console.WriteLine(
                "From table: {0}, alias: {1}, join on: {2}", 
                options.TableName, options.Alias, options.JoinCondition));
        Console.WriteLine("Where: {0}", filter);    
        
        // fake result
        return new List<T>();
    }

    #endregion
}

The Query class always returns itself in each method, so that subsequent calls always refer to the same instance. This way information about query is collected step by step.

There are however some problems with this code. Some parts of the query are mandatory, while other are optional. Some can appear only once. Some have to be provided in specific sequence in order to make sense. You can always validate conditions in code and throw exceptions if user of your library does something wrong, but it’s always better to guide user and detect errors at compile time. Also, we should make our interface more intuitive. Suppose you don’t know the structure of SQL query, but want to use the library. What do you do if Intellisense shows you this?

Well, you refer to the documentation. But who likes to do this? Wouldn’t it be better if the library took you by the hand? We are going to improve our interface a little by ensuring following things:

From() is the only mandatory call here, so we’re not letting user do anything until this method is called
When Join() is called, only available options should be Alias() (to assign table an alias) and On() (to specify the join condition). After calling On() we want to return to regular interface.

In order to do this, we should define more than one interface for the Query class.

public interface IQueryBuilderMandatory
{
    IQueryBuilder From(string tableName);
}

public interface IQueryBuilder
{
    IQueryJoinBuilder Join(string tableName);
    IQueryBuilder Alias(string alias);
    IQueryBuilder Where(string filter);

    IList<T> Execute<T>();
}

public interface IQueryJoinBuilder
{
    IQueryJoinBuilder Alias(string alias);
    IQueryBuilder On(string joinCondition);
}

Create() method of the QueryFactory class now returns IQueryBuilderMandatory interface instead of IQueryBuilder. The Query class implements all three of the interfaces:

public class Query : IQueryBuilderMandatory, IQueryBuilder, IQueryJoinBuilder
{
    ...
}

Implementation also changes slightly. The Join() method now returns IQueryJoinBuilder interface (body stays the same).

public IQueryJoinBuilder Join(string tableName)
{
    ...
}

There also have to be two explicit implementations of the Alias() method (since it is defined in two interfaces with the same parameters, but different return type). Their body is the same as body of the Alias() method in first version of the class – or it can be extracted to private method of course.

IQueryBuilder IQueryBuilder.Alias(string alias)
{
    ...
}

IQueryJoinBuilder IQueryJoinBuilder.Alias(string alias)
{
    ...
}

And that’s it. Now when user opens Intellisense at the begining of query definition, he sees only the From() method:

After calling From(), more options become available:

And when defining a joined table, only relevant methods are available:

This still is far from perfect. There are possible some combinations, which are not correct syntax or make no sense. But it serves as a good example. Where you can take it is up to you.

Code contracts in .NET 4.0

2009-05-26T20:29:00.001+02:00

Code contracts are a nice feature, that will be included in .NET 4.0’s BCL. They allow you to express assertions on method parameters and object state in explicit manner. Surely everyone has already written his Guard class to achieve Design by Contract approach, but .NET’s code contracts work a little different. Look at this:

class Account
{
    private decimal balance;

    public Account(decimal balance)
    {
        this.balance = balance;
    }

    public void Debit(decimal amount)
    {
        Contract.Requires(10 < amount, 
            "Amount cannot be less than 10");
        Contract.Requires(amount <= this.balance, 
            "The amount to debit exceeds account balance");
        Contract.Ensures(this.balance == Contract.OldValue(this.balance) - amount,
            "Operation has resulted in incorrect final balance");

        this.balance -= amount;
    }

}

class Program
{
    static void Main(string[] args)
    {
        Account ac1 = new Account(100);
        ac1.Debit(5);
    }
}

There are at least two interesting things about this piece of code. First, note that expectations of exit condition are expressed before the value even gets calculated. Secondly, you can use variable’s old value (that is a value it had just before method invocation) in exit condition in order to compare it with this variable’s value after method has been executed. This is possible thanks to the way code contracts work. After compilation, assembly is processed and rewritten, so that assertions can be expressed in IL. This works in similar way as PostSharp. There are also other “special” values, that can be used in conditions like method’s return value or value of output parameter. Execution of the above code snippet results with this error notification:

Note, that you can actually see the condition in the message. You can also state conditions, that should always be true for object’s state:

[ContractInvariantMethod]
protected void ObjectInvariant()
{
    Contract.Invariant(this.balance >= 0);
}

There are also means to express contracts over interfaces and abstract methods. Contracts are inherited, but cannot be modified in subtypes (Liskov Substitution Principle).

So that was runtime checking, but there’s also another mode – static checking, which occurs during compilation. Warnings about possible assertion violations are displayed in Error List window. Unfortunately I was unable to get any satisfying results with the code snippet above. All I got was information, that my assertions are “unproven”:

This is not really helpful ;) I checked tutorial videos and forums, but for other people this appears to work just fine. Strange I say. Documentation only says:

First, a word of caution: Static code checking or verification is a difficult endeavor. It requires a relatively large effort in terms of writing contracts, determining why a particular property cannot be proven, and finding a way to help the checker see the light.
Before you start using the static checker in earnest, we suggest you spend enough time using contracts for runtime checking to familiarize yourself with contracts and the benefits they bring in that domain.

I don’t think this feature is going to be widely used if it will require special considerations from it’s users. Anyway, this feature seems to be only available for users of VSTS, which is a big disadvantage.

Why does everything have to be so hard?

2009-05-21T23:45:00.001+02:00

All I wanted was to get a really simple functionality of uploading quite large files (~100 MB) from mobile device to a server. Seems easy to achieve, right? Well it’s not.

My original idea was to create a web service, that would orchestrate the upload process. A client would request upload of one or more files. File information would be recorded in database, then the web service would return URLs for the client to perform HTTP PUT requests. After finishing upload of each file, the client would notify the web service. It is important that the upload has to be streamed, because buffering whole file in the memory on either client or web server would cause extreme performance penalty. Also, a mechanism for upload resuming should be provided, but this seemed easy to do with Content-Range header. I assumed I can use standard IIS mechanisms to achieve this and that’s where I was wrong.

Firstly, in order to get HTT PUT on IIS, the WebDAV feature has to be installed. And it turns out that the standard implementation provided by Microsoft doesn’t support Content-Range header (attaching this header resulted in HTTP 50* status code). There are other implementations, but since this application was a small internal project, it had no budget to buy one. What’s more, PUT verb always requires authentication with this implementation of WebDAV and that prevents streaming. Why? .NET’s HttpWebRequest needs to buffer whole request in order to perform authentication and setting AllowWriteStreamBuffering to false causes exception to be thrown. Well if you only need to perform Basic HTTP authentication this problem can be worked around by manually attaching authentication header to the request, but still!

Ok, so if not that way, maybe another then - FTP. Oh yeah, I just forgot that .NET CF doesn’t have classes for FTP support. Darn. There are of course commercial libs, but as I said earlier, I could not buy them. Maybe I should put out a web page with upload control and POST files to the server? Oops – not resumable.

Well why not implement my own http handler to handle the PUT requests? Yes, idea seemed brilliant, but unfortunately it turns out, that there’s no easy way to stream request from client. The request gets buffered in the memory and the http handler is called when whole request is completed. This was unacceptable. After a lot of digging I found this post, which describes how to work around that problem, but hey – there’s a code that sets private fields of ASP.NET classes using reflection! This definitely isn’t a supported scenario. I decided, that I can’t accept this solution. I mean, shouldn’t request streaming be an easy to perform task? Isn’t that quite common thing to do?

I ended up with solution, that uploads files by sequential web service requests, chunk by chunk. This is quite ugly and requires client to transfer around 33% percent more data than other solutions – due to Base64 encoding of binary data in SOAP messages. But at least it works!

So what is the point of me ranting about this? There’s none really ;) Sometimes I just want to scream: “Why does everything have to be so hard?!”

The Geneva framework

2009-05-14T20:15:00.001+02:00

The “Geneva”, while being a very interesting framework developed by Microsoft, isn’t getting much buzz on the blogs. A beta 2 version was just recently released and the final version is planned somewhere in 2009.

The framework aims at providing an easy to use solution for federated authentication and claims based security. None of those concepts are new in IT world. There are standards from WS-* family, which encompass both. In fact, WCF provides both claims based security plumbing code and bindings compatible with WS-Federation standard. The problem was, that those concepts were hard to implement in applications and required a lot of effort from developers. There also were no easy means of implementing own STS (Security Token Service). This changes with “Geneva”, which tries to make usage of federation and claims based security as easy as possible. As for claims, a developer can access them using IClaimsPrincipal interface (which derives from IPrincipal) – this integrates very well with security mechanisms built into .NET. There are even ASP.NET controls provided making implementation of ASP.NET based Relaying Parties and Security Token Services a lot easier. But Geneva is not only a library to use in your code. It also consists of two more components – the Geneva Server, which is a STS (with identity database and GUI for administration) as well as extensions to Windows CardSpace. I’m not going to go into details with this – there are very good whitepapers on this topic and I’d hate to just copy them here. Instead I would like to write about two usage cases, that got me most interested.

Authentication Assurance

Not directly related to federation, “Authentication assurance” sample from Geneva SDK presents a case, where different parts of system require different levels of security. For example browsing the order list is not a security critical operation and user can be authenticated based on his Windows account (not to bother him with different form of authentication). When performing more sensitive operations like canceling an order, system might require a stronger proof of user’s identity like a certificate stored on a smart card. Geneva’s programming model makes it easy to secure operations according to their sensitivity level. Developer just needs to access authentication type stored as one of user claims in IClaimsPrincipal. Then, if authentication type is too weak, user is required to prove his identity in another way (and possibly in another STS).

“Act As” Scenario

In one of the whitepapers you can read:

When you build a multi-tier system, typically with a web front end and a collection of web services and other resources on the back end, you have a tough choice to make. Should the web front end use its own identity to access those back end resources, or should delegate the user’s credentials to make those requests? If you choose the first option, you end up with what is known as a trusted subsystem model. If you choose the second, you’ll need some way to delegate the client’s identity to the back end. There are performance and security tradeoffs for both of these choices, with the trusted subsystem model generally favoring performance over security and the delegation model generally favoring security over performance.

The example is:

Web application talks to Service1, which in turn talks to Service2. How should Service1 authenticate at Service2? First solution is to use same credentials for each user of web application. This creates the trusted subsystem and Service2 has to trust Servce1 to only perform those operations, which are permitted for the user. The other solution requires Service1 to act on behalf of the user, which allows Service2 to make it’s own security assertions. In order to achieve that, a special kind of security token has to be issued for Service1, which contains ActAs property set to the users identity.

What’s more, Geneva provides means of transforming security token into Windows identity, which for example allows for using Windows authentication while accessing SQL Server data store by back end services. I recommend you download the beta and check it out yourself.

Tips on refactoring towards testability

2009-04-09T20:58:00.001+02:00

Last time I was expressing my doubts about the value of unit testing. This time I decided to go back to the beginning and show how to start with testing. Newcomers to unit testing often ask themselves how to test things, that are seemingly untestable. Here I gathered some tips on restructuring application’s code in order to achieve testability.

Base principles

What you really want to achieve is two things: possibly low level of component coupling and separated responsibilities. Both things mean ease of testing of one component in separation from other components in the system. The simplest thing to do in order to decouple two classes is to remove direct dependency between them by means of interfaces. When the class we chose for a test subject depends only on interfaces – not concrete classes – these interfaces can be easily mocked, either by hand or using one of the numerous mocking libraries. This allows you to test your class in separation and assert both it’s state and behavior. The single responsibility principle states, that each class should have only one responsibility. In practice this means, that classes performing business logic should not contain code related to any other of the application concerns, for example persistence. This way your logic is testable without necessity to have a database in place.

Where interfaces are not applicable, you can usually use inheritance.This however requires you to mark methods and properties of mocked classes as virtual. Most mocking frameworks support mocking of classes. Remember, that high coupling between application components makes unit testing very hard or even impossible due to extensive setup required to perform even simplest test.

Dependency injection containers

You may wonder how to wire up components of your application when they are supposed to be dependent merely on interfaces. Somewhere the instances of concrete types have to be instantiated anyway, right? This is where DI container come to the rescue. The idea is to register application’s components in a container using the component’s interface as a key. Then, all component dependencies defined in it’s constructor or as public properties can be injected with container’s contents. Components are added to the container at application’s setup phase, for example in entry point method or even declared in XML configuration (although I’m not a fan of this solution). This enables you to easily change container’s registrations during a test and to use mocks instead of real components. Don’t think that DI containers serve only the purpose of making your application testable. As Ayende Rahien writes, it’s not their main purpose. They help a lot, but what they mainly do is to enable you to structure your application in a better way.

Laws and principles

All principles of good object oriented design positively influence testability. Like for example Single Responsibility Principle (SRP) mentioned earlier. Please see “Design Principles and Design Patterns” by Robert C. Martin for more detailed information. I’ll just mention the Law of Demeter here. It states that a component should only directly interact with it’s immediate neighbors in dependency graph. The component should not know nothing of it’s neighbor’s properties structure. In code instead of:

musician.Trumpet.Blow();

you'd write:

musician.PlayInstrument();

You don’t care about PlayInstrument’s implementation. This way test subject is not dependent on Trumpet class, just the Musician class. There is less coupling and testing and mocking is easier. This law also applies to application’s layers – each layer should only interact with a layer directly underneath it.

What about the UI?

There are applications, that have a lot of logic related to user interface: disable this, change color of that… In traditional approach testing of that logic is almost impossible – unless you’re using GUI automated test’s, which didn’t convinced me yet as I wrote in my last post. However there are some design patterns like MVP, MVC and MVVM which allow you to achieve testability in this area. The idea behind all of those patterns is to extract view logic from views and place it in separate classes. Those classes interact with the view itself through interface (MVP, MVC) or don’t interact at all (MVVM) and therefore are testable without need to really make use of any real controls. As for the view itself – you need to keep it as dumb as possible. If there is almost no complexity, it’s not likely to break.

The framework doesn’t allow me to test this…

Quite often you have to make use of third party APIs that are not really designed with testability in mind. This API may be for a component that is slow or requires extensive setup in order to test. It would be better not to have it in test at all, but how to do this when we have direct dependency and no control of API’s structure? The answer is: build a layer of abstraction over this API. An example here is very easy to find: the System.IO.File class. It’ static methods are very useful, but couple your code with file system directly. Instead I suggest you build an adapter and extract it’s interface.

Final thoughts

Although mocking frameworks give you a lot of power, try to assert component’s state after operation, not it’s behavior during. Asserting behavior tends to couple the test and components implementation, which is not really good, because increases cost of maintenance. Testing is hard to start, but it gets easier with each step.

Random thoughts on automated testing

2009-03-31T22:14:00.001+02:00

Recently I’ve been thinking what is required for unit tests to be valuable. First conclusions is that you need good code coverage of critical areas and the tests need to be comprehensive. What is the value of a good test suite? It allows you to easily detect bugs introduced by making software modifications. If you lack test coverage in some areas, a bug can easily slip into your application unnoticed. The other conclusion was, that tests need to be written by people who fully understand the purpose. What I noticed is that some developers just want to “write a test” without any thought on what they really want to test. In worst case they just copy from another test and there you have it – useless piece of code that introduces problems only. So first state what is the purpose of your test (I’m a fan of naming convention, that describes test’s role), then implement it. With those two things you can say that build in your CI environment was successful.

Can you really prove unit tests are worth the effort? What if your manager comes to you and asks you for an example, where well written test suite saved the day? Or at least made your work easier? I whish there was a study on what types of application benefit the most from automated testing. I think that apps concerned mainly with complex business logic or mathematical calculations are at the top of the list, while CRUD and rich-UI-hardly-any-content applications are at the very bottom. With business logic it’s all about whether you can or cannot test components in separation from rest of the system. With UI the only way to automate testing process is to use some UI test automation tools, but they are specific to technology and usually very clumsy and therefore not popular.The best way to test in those cases is just to let your testers take over.

In any case one may wonder if automated tests are really worth the amount of work, that is put into their creation and maintenance. In my actual project I made an observation, that usually when test fails, it is due to desired modifications in code and correction has to be made in the test itself, not the code, in order to make it pass. I tried to think of the reason of this situation, but all I came up with was a conclusion, that the tests are too complicated. We try to keep components of our application as loosely coupled as possible, nonetheless they have dependencies, that need to be set up in order to run the test case. Usually a change in program’s structure causes a few tests to fail. We use RhinoMocks extensively and I’m aware, that state-based testing introduces a lot less complexity than behavior-based testing, but most of the components are about behavior and interaction and this way of testing is unavoidable. What I’m trying to say is that it’s not clear to me if automated tests save money for my organization. Maybe manual-only testing would be cheaper? A nice experiment would be to run same project on two different teams with two approaches to testing and see which works more effectively. It’s all about the money in the end. But how do you measure savings? When releasing buggy software you have to count both money lost for maintenance and money you won’t earn in future because of poor quality image of organization’s software. This is very hard to measure.

Handling complex use case flows

2009-02-28T21:35:00.001+01:00

There are applications, that have fairly complex flows in user interface. In application I’m currently working on there are forms which can be visited many times during execution of one business process, each time behaving differently according to context (values collected earlier). The challenge here is how to write code, that will be testable and maintainable and also not too complex?

I will use a simplified example here. Let’s say the application is used to collect information about car parts. Parts can grouped and each group get’s it’s own ID. You can also associate parts with a car, in which they have been mounted. If you decide to enter car information, it is obligatory to also enter information about car body (treated as car part). The business analyst says, he wants application to work following way:

If I want to enter car part information, I choose “Enter car part” from menu. Car part form is shown.
I then enter car part information and I have to provide car part group identifier.
I click OK and return to menu. Now I have two options: “Enter car part” as previously – this will create new car part group, and “Enter additional car part” – this will add a car part to previously created group (it’s number is a context).
There also is a possibility to choose “Enter car” from the menu. This option also creates new group, but shows car form instead of car part form.
After filling car information, I’m automatically redirected to car part form with car part type set to “car body”. I have to provide group identifier.
If car body number meets certain criteria, I’m redirected to registration certificate form, where I have to provide registration certificate information.
After doing this, I return to the menu and have option to start a new group or add parts to recently created group.

Let’s not go into details why exactly is the UI so awkwardly designed. Sometimes your users think differently than you do. Instead, let’s look at navigation between forms:

Looks pretty simple, but it doesn’t reflect the use case flow at all. The car part form in this simple example can work in 3 modes: entering a car part, entering additional car part and entering car body. This introduces some complexity already, but the tricky part is this: where do you go after completing the car part form? It can be either application menu or registration certificate form depending on car part information and what happened earlier in the flow. Basically what we need here is a state diagram.

This state machine represents our business process of collection car part group information. As you can see the transitions of states are a little more complex than navigation between forms. Three of the states use the same form to perform different tasks: Car, Car part and Car body. Transitions marked with light gray are not directly part of business process, but rather initiate new car part group. It now becomes clear where should we go after leaving car part form – this depends on what state are we currently in.

This diagram makes it clear for us how the application should behave. But how to implement this process? First and most obvious thought is to create a bunch of flag variables and implement some if-else statements. While this is OK in simple scenarios, the real world complexity will make such code completely unreadable and hard to maintain. Next you may consider a workflow engine. This allows you to express transition logic in readable way, but in most cases this is too heavyweight for regular applications. And what if you have to implement this on mobile device? No workflow engine there.

Suppose this application uses MVC pattern. We focus on the “C” here. The controller most probably has methods like “OnCarPartEntered” taking in car part information object as parameter. This method saves the information and decides what view to show next and in what mode. This is where your “if-else” would go if you opted for the first solution. In this post I suggest using the state machine pattern to implement the controller (a similar was used in my post on circuit breaker pattern). You have to implement your controller interface for each state separately. Following diagram depicts the situation:

The context class is an access point to the state machine. It knows all the states and knows which state is the current one. It exposes business process context (group number here) and methods used to switch states through IContext interface. Since it also implements the controller interface, it forwards all method calls to current state. Each application state has it’s own implementation of IMyController. These classes derive from StateBase, which can contain behavior common to all states. Derived classes override this behavior when appropriate. For example the CarBodyState will check the car body number criteria match after leaving car part form. The CarPartState will just return to main menu in this situation. The state classes are also responsible for switching states in reaction to certain actions of the user. Following diagram shows sample state transition:

Before executing this sequence, application is in Car body state and car part form is displayed. After execution, application is in Additional part state and menu form is displayed. The code is quite straightforward, so I won’t be cluttering this post with it :)

Zero friction APIs

2009-02-11T21:05:00.001+01:00

This is what Ayende talked about some time ago now and got a few interesting comments. The essence of his post is that you (an architect) should be able to setup a project in a way that will make the easiest way of doing things also the best way in terms of the architecture.

There is a lot of base code to be developed before the actual business functionality can be implemented. I mean, even if you’re in position when you can take advantage of latest technologies, all the jEntityMVCInjectionFoundation libraries, you usually build your own abstractions and base class libraries in order to both remove dependency on particular technology and encapsulate some reusable behaviors. These base class libraries of yours are used by developers on your team. The question is do you put enough effort in designing these libraries to be zero friction? I’ve seen some APIs being pretty slick (StructureMap) and some really ugly (LLBLGen Pro), but these are widely used libraries and their authors have to design friendly APIs as part of their job. You should too. Especially because the developers will most probably make direct use those other libraries less often than will use your base class library.

If I were to create a list of things that should be considered when creating a library, this would be in order of importance:

Your library should get things done. And do it the best way possible in terms of complexity, performance and maintainability. (Yes, this is always most important and it’s the point of creating the library in the first place. The other are worthless without this one – keep this in mind).
Name classes, methods, etc. so that they are self-explanatory and obvious. Don’t make me refer to any documentation. (This, as everything, is not always possible. If that’s the case, provide a friendly and useful documentation for me).
Think about testing. Is your library designed so that testing is easy? Can I mock your classes?
Make sure you don’t have any hidden dependencies. Your classes will be used by other people that won’t have an insight on their inner workings. Suppose you have method X. In order to call it, you have to call Y before. Y doesn’t return any value that is used as X’s parameter. It’s a hidden dependency and most probably you’re doing something wrong. Don’t make me refer to sample code in order to do event the simplest things (although samples will never hurt).
Think about whether your library is easy to extend and maintain. Also think about API versioning policy if applicable.
Don’t overcomplicate things. Do not provide a hundred layers of abstraction just because you think in few years they may come in handy. If they will, you can add them at that time – and refactor other things too. Remember, YAGNI.
Provide a slick syntax for me. A fluent one if applicable. Make the code look elegant, compact and easy to read.

If your base and helper class library fulfills most of those things, people using it will be grateful.

HTTPS with client certificate authentication in .NET CF

2009-02-04T22:21:00.001+01:00

The struggle with .NET CF 1.0 continues.

The HTTPS is just ordinary HTTP sent over a secure TLS (extension of SSL) connection. The secure connection is initiated in following way:

Server and client negotiate strongest cipher algorithms supported by both parties
Server sends its certificate to the client
Client can verify correctness of the certificate by verifying digital signature of the Certification Authority that issued the certificate
Client generates a random number (master secret), encrypts it with server’s public key and sends it to server. Only server can decrypt this message with its private key.
Both parties derive a key for symmetric algorithm from the master secret. Following communication is encrypted using this key.

After completing those steps, client and server have a secure way to communicate. Additionally the client knows, that server is trusted. The server on the other hand doesn’t have any information about the client. It often is required to authenticate the client before allowing it to access confidential resources. This can be done in many different ways, one of which is a client certificate. This option is supported directly in TLS – the client sends its certificate right after it receives certificate from server. To confirm, that it owns this certificate, the client also has to prove, that it owns the private key associated with certificate. In order to do this, after establishing master secret the client sends digital signature over all messages exchanged with server up to that point. Server verifies this signature using client’s public key.

I’m developing a client that has to authenticate at HTTPS web service with client certificate. Unfortunately this scenario is not supported in .NET CF prior to version 3.5. While looking for a way to work around this problem, I came by library called SecureBlackbox. The package called SSLBlackbox supports my scenario and additionally provides very comprehensive support for X509 certificates, which .NET CF lacks. What is interesting, the library developers don’t use any external APIs to perform the cryptography. The implemented all algorithms from scratch. To evaluate this library I needed a test environment. I decided to use simple ASP.NET page hosted on IIS server that would display client certificate information associated with request. The code comes from MSDN:

protected void Page_Load(object sender, EventArgs e)
{
    HttpClientCertificate cs = Request.ClientCertificate;
    if (cs != null)
    {
        Response.Write("ClientCertificate Settings:<br>");
        Response.Write("Certificate = " + cs.Certificate + "<br>");
        Response.Write("Cookie = " + cs.Cookie + "<br>");
        Response.Write("Flags = " + cs.Flags + "<br>");
        Response.Write("IsPresent = " + cs.IsPresent + "<br>");
        Response.Write("Issuer = " + cs.Issuer + "<br>");
        Response.Write("IsValid = " + cs.IsValid + "<br>");
        Response.Write("KeySize = " + cs.KeySize + "<br>");
        Response.Write("SecretKeySize = " + cs.SecretKeySize + "<br>");
        Response.Write("SerialNumber = " + cs.SerialNumber + "<br>");
        Response.Write("ServerIssuer = " + cs.ServerIssuer + "<br>");
        Response.Write("ServerSubject = " + cs.ServerSubject + "<br>");
        Response.Write("Subject = " + cs.Subject + "<br>");
        Response.Write("ValidFrom = " + cs.ValidFrom + "<br>");
        Response.Write("ValidUntil = " + cs.ValidUntil + "<br>");
        Response.Write("What's this = " + cs.ToString() + "<br>");
    }
    else
    {
        Response.Write("No certificate");
    }
}

I also needed to generate certificate for server and client. I used makecert.exe according to hints from Manu Cohen-Yashar’s post. The only modification I made is to generate a personal client certificate rather a one for machine. To do this just specify CurrentUser instead of LocalMachine as a target certificate store.

Next step is to configure IIS, I use version 7. You need to configure HTTPS binding with created server certificate – configured at web site level. Then you have to add an application under this web site for previously created ASP.NET page. Then, for this application you need to set SSL setting so that SSL is enabled and client certificates are required:

The easiest way to verify if server’s setup is ok is to browse create page with Internet Explorer. Since IE uses certificates installed in personal store, no additional setup is required for this browser. You can also use Firefox for example, but you need to export the client certificate to PFX file (with private key) and import it to the browser. When a page requests client certificate, the browser will let you choose certificate to be sent. Following is the result from my page:

Ok, after setting up the server, it was time to write some client code.

class Program
{
    static TElX509Certificate cert = new TElX509Certificate();
    
    static void Main(string[] args)
    {
        SBUtils.Unit.SetLicenseKey("<license key here>");
        var stream = File.OpenRead(@"<client certificate file>.pfx");
        cert.LoadFromStreamPFX(stream, "<private key password here>", 0);
        stream.Close();

        TElHTTPSClient https = new TElHTTPSClient();
        https.OnData += new SBSSLCommon.TSBDataEvent(https_OnData);
        https.OnCertificateValidate += 
            new SBSSLCommon.TSBCertificateValidateEvent(https_OnCertificateValidate);
        https.OnCertificateNeededEx += 
            new SBClient.TSBCertificateNeededExEvent(https_OnCertificateNeededEx);
        
        int code = https.Get("https://myurl/");
        Console.WriteLine(code);

        Console.ReadLine();
        https.Close(true);
    }

    static bool wasCert = false;

    static void https_OnCertificateNeededEx(object Sender, ref TElX509Certificate Certificate)
    {
        if (wasCert)
            return;

        Certificate = cert;
        wasCert = true;
    }

    static void https_OnCertificateValidate(object Sender, TElX509Certificate X509Certificate,
        ref bool Validate)
    {
        Validate = true;
    }

    static void https_OnData(object Sender, byte[] Buffer)
    {
        Console.WriteLine(Encoding.UTF8.GetString(Buffer));
    }
}

Am I the only one that gets impression that syntax could be improved here? Anyway this works just fine. If requested URL requires client certificate, the OnCertificateNeededEx event is called and you can return the certificate. This method is supposed to be called over and over until it returns null in Certificate parameter. This way you can return whole certificate chain. A developer is also required to validate server’s certificate (OnCertificateValidate event). I just return true here, so all certificates are accepted – not a production ready solution.

All would be great if not for performance issues on mobile devices. It seems that HTTPS handshake requires a lot of computation power, which mobile devices lack. I got results up to 14s for first handshake! I’m still trying to get around this. Also the library’s size is considerable – over 2mb is significant on mobile device.

Java web service interoperability from .NET CF 1.0

2009-01-23T17:53:00.001+01:00

I don’t suppose anyone else is developing in .NET CF 1.0 now in 2009. Well those are the constraints for project I’m involved in and I prefer to think about this as a challenge :)

Anyway current topic is interoperability with Java web services. This causes a lot of problems in .NET CF 1.0, some of them weren’t addressed until .NET CF 3.5. In my case it started with inability to generate web service client proxy using standard wsdl.exe tool.

In this example we have a Java web service for querying cars by name. It returns car description with name and collection of car parts. Each car parts can have a set of string attributes. The model looks like this:

Let’s say we have WSDL like this one:

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="ws" targetNamespace="http://tempuri.org" 
                  xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" 
                  xmlns:tns="http://tempuri.org" 
                  xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
                  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <wsdl:types>
    <xsd:schema targetNamespace="http://tempuri.org" xmlns:pref="http://tempuri.org/to">
        <xsd:import namespace="http://tempuri.org/to" schemaLocation="myschema.xsd" />
        <xsd:element name="getCarDesc">
            <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="carQuery" type="pref:CarQuery" maxOccurs="1" minOccurs="1" />
          </xsd:sequence>
            </xsd:complexType>
        </xsd:element>
        <xsd:element name="getCatDescResponse">
            <xsd:complexType>
                <xsd:sequence>
                    <xsd:element name="response" type="pref:Car" maxOccurs="1" minOccurs="0" />
                </xsd:sequence>
            </xsd:complexType>
        </xsd:element>
    </xsd:schema>
  </wsdl:types>
  <wsdl:message name="carRequest">
    <wsdl:part element="tns:getCarDesc" name="parameters"/>
  </wsdl:message>
  <wsdl:message name="carResponse">
    <wsdl:part element="tns:getCarResponse" name="parameters"/>
  </wsdl:message>
  <wsdl:portType name="ws">
    <wsdl:operation name="getCar">
      <wsdl:input message="tns:carRequest"/>
      <wsdl:output message="tns:carResponse"/>
    </wsdl:operation>
  </wsdl:portType>
  <wsdl:binding name="wsSOAP" type="tns:ws">
    <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
    <wsdl:operation name="getCar">
      <wsdl:input>
        <soap:body use="literal"/>
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal"/>
      </wsdl:output>
    </wsdl:operation>
  </wsdl:binding>
  <wsdl:service name="ws">
    <wsdl:port binding="tns:wsSOAP" name="wsSOAP">
      <soap:address location="http://myhost/get-cat-web/ws" />
    </wsdl:port>
  </wsdl:service>
</wsdl:definitions>

There is one service and it has one method, getCar. This method takes CarQuery object as a parameter and returns a Car object as response. The WSDL refers to external schema in myschema.xsd file, which contains type definitions.

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema" 
        targetNamespace="http://tempuri.org/to" 
        xmlns:tns="http://tempuri.org/to" 
        elementFormDefault="qualified"
        xmlns:jaxb="http://java.sun.com/xml/ns/jaxb" jaxb:version="1.0">

    <complexType name="CarPart">
        <sequence>
            <element name="attribute" type="string" maxOccurs="unbounded" minOccurs="1" />
        </sequence>
    </complexType>

    <complexType name="Car">
        <sequence>
          <element name="name" type="string" maxOccurs="1" minOccurs="1" />
          <element name="parts" type="tns:CarPart" maxOccurs="unbounded" minOccurs="0" />
        </sequence>
    </complexType>

    <complexType name="CarQuery">
        <sequence>
            <element name="name" type="string" maxOccurs="1" minOccurs="1" />
        </sequence>
    </complexType>
</schema>

This works perfectly in Java and is used by Java guys to generate a web service. When you try to feed this to wsdl.exe, the only thing it has to say is:

Error: Unable to import binding 'wsSOAP' from namespace 'http://tempuri.org'.
 - Unable to import operation 'getCar'.
 - The operation binding 'getCar' from namespace 'http://tempuri.org' had invalid syntax.
Missing soap:operation binding.

At least wsdl.exe is being quite specific about this one. I went to validate my WSDL at this site and it confirmed, that I lack soap:operation tag. So I added it and specified operation URI:

    <wsdl:operation name="getCar">
      <soap:operation soapAction="http://tempuri.org/ws/getCar" style="document"/>
      <wsdl:input>
        <soap:body use="literal"/>
      </wsdl:input>
      <wsdl:output>
        <soap:body use="literal"/>
      </wsdl:output>
    </wsdl:operation>

The wsdl.exe finished successfully and generated proxy class along with used types. This however was not the end of my struggle. It turned out, that the generated code won’t compile int .NET CF 1.0 as there is no support for Form property of XmlElementAttribute class. The web service method was decorated with this attribute in following way:

[return: System.Xml.Serialization.XmlElementAttribute("response", 
    Form=System.Xml.Schema.XmlSchemaForm.Unqualified)]
public Car getCar(
    [System.Xml.Serialization.XmlElementAttribute(Form=System.Xml.Schema.XmlSchemaForm.Unqualified)] 
    CarQuery carQuery) 
{
    ...
}

It’s really strange that this tool would generate code that won’t compile (and yes, the result was the same when created using Add Web Reference in Smart Device project). I went to look for solution on the web and came up with this modification to WSDL (added elementFormDefault attribute):

...
<wsdl:types>
    <xsd:schema elementFormDefault="qualified" 
                targetNamespace="http://tempuri.org" xmlns:pref="http://tempuri.org/to">
...

This removed all usages of the Form property of XmlElementAttribute class. The code would now compile, but looked a little different than I expected. Take a look at the Car class:

public class Car {
    
    private string nameField;
    
    private string[][] partsField;
    
    /// <remarks/>
    public string name {
        get {
            return this.nameField;
        }
        set {
            this.nameField = value;
        }
    }
    
    /// <remarks/>
    [System.Xml.Serialization.XmlArrayItemAttribute("attribute", typeof(string), IsNullable=false)]
    public string[][] parts {
        get {
            return this.partsField;
        }
        set {
            this.partsField = value;
        }
    }
}

There’s no CarPart object collection. There was no CarPart class in generated code at all. Instead, the tool generated string[][] array for me. Well it’s not what I would like to have, but I could live with it. So I went on to code that test the web service and to my surprise the constructor of the proxy class threw FileNotFoundException as the application was unable to find a dynamically created assembly used by XML serializer. I tried to do the same with Visual Studio 2008 and here’s what I got:

InvalidOperationException was unhandled
Unable to generate a temporary class (result=1).
error CS0029: Cannot implicitly convert type 'string' to 'string[]'

Not only the wsdl.exe changed the object model, but also the XML Serializer was unable to deal with it. At this point I decided to manually modify the generated code and added the CarPart class. I also changed parts collection to CarPart[] type. And it finally worked. Yet I feel disappointed that I have to manually create proxy classes to work with Java web services.

A whole different thing is performance of web services on the smart device. SOAP and XML imply large message sizes and extensive use of reflection, which has a great impact on the application’s performance.

Dependency injection in .NET CF 1.0

2009-01-17T00:10:00.001+01:00

Recently I got involved in building an application for mobile devices. The problem is that they are old Pocket PC 2002 devices, so the only option to write managed code is to use also old .NET CF 1.0. Don’t even get me started on how limited it is and how much pain it is to work with VS2003 – do you remember the times when you had to add namespace imports by hand? Without ReSharper it’s almost unbearable.

Anyway I’m responsible for the design of the solution. I thought it would be nice to have DI container, but there are some constraints on the mobile platform:

Performance – There’s no possibility to use reflection extensively without running into performance problems.
Limited BCL - .NET CF 1.0 base class library is only a small subset the .NET 1.1 BCL, not to mention .NET 2.0

Taking this into account I thought it would be best to implement a really simple solution myself. The features of my simple container are:

Mapping interfaces to implementing types
Registering types both as singleton and as transient instance
Registering existing instances
Resolving both mapped interfaces and unmapped types
Injecting dependencies into constructors (recursively)
Fluent registration syntax
Reflection usage reduced to a minimum

This set of functionalities should allow me to work comfortably with dependency injection and keep the container as simple as possible. Here is the code, first the container interface:

public interface IContainer
{
    IContainer Register(Type mapFrom, Type mapTo);
    IContainer RegisterSingleton(Type mapFrom, Type mapTo);
    IContainer RegisterSingleton(Type mapFrom, object toInstance);
    object Resolve(Type type);
}

Register method allows you to register a mapping of a transient objects (instantiated on every resolve). RegisterSingleton is overloaded and allows you to register either a type mapping or type to existing instance mapping as a singleton (instantiated only once). Resolve returns instance of requested type – either mapped or not.

Now TypeItem class used to store type mappings (in a Hashtable):

public class TypeItem
{
    private Type targetType;

    public Type TargetType { get { return targetType; } }

    private bool sigleton;

    public bool Singleton { get { return sigleton; } }

    public TypeItem(Type targetType, bool singleton)
    {
        this.targetType = targetType;
        this.sigleton = singleton;
    }
}

And the container itself:

public class Container : IContainer
{
    private Hashtable typeMap = new Hashtable();
    private Hashtable singletonCache = new Hashtable();
    private ArrayList targetTypeList = new ArrayList();

    #region IContainer Members

    public IContainer Register(Type mapFrom, Type mapTo)
    {
        CheckRegistrationConditions(mapFrom, mapTo, true);

        TypeItem item = new TypeItem(mapTo, false);
        AddItem(mapFrom, item);
        return this;
    }

    public IContainer RegisterSingleton(Type mapFrom, Type mapTo)
    {
        CheckRegistrationConditions(mapFrom, mapTo, true);

        TypeItem item = new TypeItem(mapTo, true);
        AddItem(mapFrom, item);
        return this;
    }

    public IContainer RegisterSingleton(Type mapFrom, object toInstance)
    {
        CheckRegistrationConditions(mapFrom, null, false);
        Guard.AgainstNullArgument(toInstance, "toInstance");

        TypeItem item = new TypeItem(toInstance.GetType(), true);
        if(targetTypeList.Contains(item.TargetType))
        {
            throw new ArgumentException(
                "Cannot register singleton because another singleton mapping " + 
                "uses the type of the instance",
                "toInstance");
        }
        AddItem(mapFrom, item);
        singletonCache.Add(item.TargetType, toInstance);
        return this;
    }

    public object Resolve(Type type)
    {
        Guard.AgainstNullArgument(type, "type");

        if (typeMap.ContainsKey(type))
        {
            // mapped type
            TypeItem item = typeMap[type] as TypeItem;

            if (item.Singleton && singletonCache.ContainsKey(item.TargetType))
                return singletonCache[item.TargetType];

            object instance = BuildInstance(item.TargetType);

            if (item.Singleton)
                singletonCache.Add(item.TargetType, instance);

            return instance;
        }
        else
        {
            // unmapped type
            if (!type.IsClass || !type.IsPublic)
                throw new TypeResolveException(
                    "The type " + type.Name + 
                    " is neither mapped nor can it be instantiated");

            return BuildInstance(type);
        }
    }

    #endregion

    private void CheckRegistrationConditions(Type mapFrom, Type mapTo, bool mapToValid)
    {
        Guard.AgainstNullArgument(mapFrom, "mapFrom");
        if (mapToValid)
        {
            Guard.AgainstNullArgument(mapTo, "mapTo");
            if (!mapTo.IsClass || !mapTo.IsPublic)
                throw new ArgumentException("The type " + mapTo.Name + 
                    " cannot be instantiated");
        }

        if (typeMap.ContainsKey(mapFrom))
            throw new ArgumentException("Provided type is already mapped", "mapFrom");
    }

    private void AddItem(Type mapFrom, TypeItem item)
    {
        typeMap.Add(mapFrom, item);
        targetTypeList.Add(item.TargetType);
    }

    private object BuildInstance(Type type)
    {
        ConstructorInfo[] constructors = type.GetConstructors(
            BindingFlags.Public | BindingFlags.Instance);

        if (constructors.Length == 0)
            throw new TypeResolveException("The type " + type.Name +
                " has no public constructors");

        ParameterInfo[] parameters = constructors[0].GetParameters();
        object[] paramValues = new object[parameters.Length];

        for (int i = 0; i < parameters.Length; i++)
        {
            paramValues[i] = Resolve(parameters[i].ParameterType);
        }

        return constructors[0].Invoke(paramValues);
    }

}

As you might noticed, the BuildInstance method just takes the first public constructor returned by GetConstructors and uses it to create instance. This is enough for my scenario, but you might want to mark injection constructor with a custom attribute or select constructor basing on some criteria (ex. most resolvable parameters).

There are also some tests for the container, but I won’t be posting them here.

Comparing OpenID and canonical Subject-IP-RP pattern

2009-01-12T23:15:00.001+01:00

A hot topic lately is identity management in distributed environments and there are some interesting articles on this in the Architecture Journal. The basic thing to do in distributed environment, presumably SOA, is to delegate the identity management to separate component called Identity Provider (IP). It is responsible for maintaining user database and issuing security tokens. This security tokens are used by the subject (a user who wants to gain access to a resource) to authenticate at the Relaying Party (a component that maintains the resource). This way user doesn’t have to have separate user account on each Relaying Party and presumably authenticate in different way using different credentials. The Relaying Party trusts the Identity Provider to perform user authentication. Following diagram presents this situation:

Now in order to authenticate at the Relaying Party, following steps are taken [1]:

Subject first discovers how to authenticate at Relaying Party by getting the security policy. It then authenticates at Identity Provider using proper credentials and receives a security token, which is used to authenticate resource requests at Replaying Party. Relaying Party verifies the token’s signature to ensure it comes from the trusted Identity Provider.

OpenID is a decentralized and open identification standard basing on a concept of trusted Identity Provider. The “distributed” in practice means, that there are many IPs on the web and it’s up to user to decide which one will suit him. For example there is OpenID provider for Google’s Federated Login API, which you can use your Google account to authenticate with OpenID. There are also some dedicated IPs and you even can easily setup your own IP if you do not trust anybody else :). OpenID was created with authentication at web portals and communities in mind (it’s being used by Stack Overflow for instance). It’s well suited for this task and differs from the canonical Subject-IP-RP pattern. It is assumed, that user uses web browser to authenticate and the protocol relies heavily on HTTP/HTML (but implementation in desktop apps is also possible). Authentication process orchestration is taken from hands of the subject and directed by Relaying Party instead. Username has a form of URL and plays significant role during the process of authentication as follows [2](a rough view):

Relaying Party queries username URL to discover information on Identity Provider used by given user. Then, user’s browser is redirected to IP’s login site. After logging in, IP redirects user to RP’s return URL including information about authentication result in the request. RP verifies whether the login status information is legitimate by querying IP.

There are also some modifications and extensions to this protocol like for example ability for RP and IP to establish a shared secret used to verify login status information without the need to query IP every time a user logs in.

Implementation of OpenID authentication is easy, because there are many open libraries for each platform. For .NET there is DotNetOpenId, which even provides ready to use controls for ASP.NET. I suggest you read OpenID specs [2] for more detailed information on this topic. Anyway it would be nice to see OpenID authentication more popular and used by all community portals.

Resources:

[1] Vittorio Bertocci, “Claims and Identity: On-Premise and Cloud Solutions”. The Architecture Journal, Journal 16.

[2] OpenID Authentication 2.0 – Final. http://openid.net/specs/openid-authentication-2_0.html, 2009.

Exploring Boo’s Abstract Syntax Tree (AST)

2008-12-26T14:11:00.001+01:00

Currently I’m going through AST, but the documentation is scarce. AST is in-memory tree representation of code that can be modified and is used while creating syntactic macros. I was wondering what is the best way to check how syntax is transformed to AST when I came across Luis Diego Fallas’ post in which he shows a little application that parses Boo source file and displays AST in tree control. Unfortunately there are some issues with this application. Firstly, it contains a bug and doesn’t show full syntax tree. Secondly, it only displays node names without information what code the node represents. So I decided to modify his code and fix this. Here is a sample screenshot:

There is AST tree structure of code on the left and information about selected subtree on the right. It includes the code itself and serialized form of the subtree. Name of the file to parse is passed to the application as a parameter.

Visitor pattern is employed to visit all nodes in AST tree. Unfortunately deriving from Boo’s DepthFirstVisitor is a tedious task, because there are as many methods to override as there are AST node types. Luis proposed a solution basing on dynamically created type, that derives from DepthFirstVisitor. Method overrides are constructed in-memory from AST nodes and then the dynamic type is compiled. While being compact, this solution is not very readable, especially when you’re not familiar with AST. Fortunately there seems to be alternative way to do this, namely the mysterious [| <code here> |] syntax. I think it’s called quasiquotes. I couldn’t find any documentation for this, only one example in Boo package. From what I was able to figure out, this code (where m is instance of MethodInfo class):

// Node for TreeNode('')
tnCreation = MethodInvocationExpression(ReferenceExpression("TreeNode"))                                 
tnCreation.Arguments.Add(
        StringLiteralExpression(m.GetParameters()[0].ParameterType.Name))

// Create node for 't = TreeNode('')' 
decl = DeclarationStatement(
      Declaration: Declaration(Name:"t",
                 Type: SimpleTypeReference("System.Windows.Forms.TreeNode")),
      Initializer: tnCreation)

is equivalent to this code:

decl = [| t = TreeNode($(m.GetParameters()[0].ParameterType.Name)) |]

So there is a huge improvement. Code between [| and |] is being transformed to AST and assigned to a variable. The $() construct is similar to string interpolation construct. It allows you to insert a string from variable as if it was part of the code (here it is a parameter of the TreeNode constructor, but it also can be a method name for example). When using this syntax, you have to be careful about the indentation. It seems that statements can be in the same line as [|, but when declaring members, they have to be in new line and indented. Otherwise you get compilation errors.

Luis has overridden “Enter*” and “Leave*” (for example EnterBlockExpression) methods of DepthFirstVisitor, which is a problem because “Enter*” and ”Leave*” methods exist only for nodes that can contain subnodes. So for example there is no Enter method for IntegerLiteralExpression node. In my code I override the “On*” methods.

Here is the full code:

import System
import System.Reflection
import System.IO
import Boo.Lang.Compiler
import Boo.Lang.Compiler.Ast
import Boo.Lang.Compiler.Ast.Visitors
import Boo.Lang.Parser
import System.Windows.Forms
import System.Xml.Serialization
import System.Drawing


// Get the type instance for DepthFirstVisitor
a = Assembly.Load("Boo.Lang.Compiler")
visitorType = a.GetType("Boo.Lang.Compiler.Ast.DepthFirstVisitor")

// Create a class definition for a custom visitor
myVisitor = ClassDefinition(Name: "DynamicVisitor")
myVisitor.BaseTypes.Add(SimpleTypeReference("Boo.Lang.Compiler.Ast.DepthFirstVisitor"))

// Add a new field for our node stack
stackField = [| 
    public stack as System.Collections.Stack 
|]
myVisitor.Members.Add(stackField)

// Override On* methods
for m as MethodInfo in [m for m in visitorType.GetMethods() if m.Name.StartsWith("On")]:
    method = [|
        def $(m.Name)(node as $(m.GetParameters()[0].ParameterType.FullName)):
            t = TreeNode($(m.GetParameters()[0].ParameterType.Name))
            t.Tag = node;
            (stack.Peek() as TreeNode).Nodes.Add(t)
            stack.Push(t)
            // call method in superclass to visit subtrees
            super.$(m.Name)(node)
            stack.Pop() 
    |]
    myVisitor.Members.Add(method)

// Compile unit and module creation
cu = CompileUnit()
mod = Boo.Lang.Compiler.Ast.Module(Name:"Module")
cu.Modules.Add(mod)

mod.Imports.Add(Import(Namespace:"System"))
mod.Imports.Add(Import(Namespace:"System.Windows.Forms"))
mod.Imports.Add(Import(Namespace:"Boo.Lang.Compiler.Ast"))
mod.Members.Add(myVisitor)

// Initialize compiler preferences
pipeline = Pipelines.CompileToMemory()
ctxt = CompilerContext(cu)

// Run the compiler
pipeline.Run(ctxt)

// Check the results
if(ctxt.GeneratedAssembly == null):
    for e in ctxt.Errors:
        print e
    Console.ReadLine()
    return    

// Create an instance of the new visitor and initialize it
visitorInstance as object = ctxt.GeneratedAssembly.CreateInstance("DynamicVisitor");
visitorType = ctxt.GeneratedAssembly.GetType("DynamicVisitor")
tStack = System.Collections.Stack()
tStack.Push(TreeNode("root"))
visitorType.GetField("stack").SetValue(visitorInstance, tStack);

// Parse a file an run the visitor
compileUnit = BooParser.ParseFile(argv[0])
compileUnit.Accept(visitorInstance)

//Initialize a form an show the results
frm = Form(Text: "AST content", Width: 800, Height: 600)
outerSplit = SplitContainer(Dock: DockStyle.Fill, Orientation: Orientation.Vertical)
innerSplit = SplitContainer(Dock: DockStyle.Fill, Orientation: Orientation.Horizontal)
definitionText = TextBox(Dock: DockStyle.Fill, Multiline: true, 
    ScrollBars: ScrollBars.Both, Font: Font("Courier New", 8.0))
xmlText = TextBox(Dock: DockStyle.Fill, Multiline: true, 
    ScrollBars: ScrollBars.Both, Font: Font("Courier New", 8.0))

tv = TreeView(Dock: DockStyle.Fill)

tv.AfterSelect += def (sender as object, e as TreeViewEventArgs):
    if e.Node.Tag != null:
        writer = StringWriter()
        BooPrinterVisitor(writer).Visit(e.Node.Tag as Node)
        definitionText.Text = writer.ToString()
        
        serializer = XmlSerializer(e.Node.Tag.GetType())
        writer = StringWriter()
        serializer.Serialize(writer, e.Node.Tag)
        xmlText.Text = writer.ToString()

tv.Nodes.Add(tStack.Pop() as TreeNode)
frm.Controls.Add(outerSplit)
outerSplit.Panel1.Controls.Add(tv)
outerSplit.Panel2.Controls.Add(innerSplit)
innerSplit.Panel1.Controls.Add(definitionText)
innerSplit.Panel2.Controls.Add(xmlText)
Application.Run(frm)

Some highlights:

There is a BooPrinterVisitor class in Boo.Lang.Compiler.Ast.Visitors namespace, that converts AST to source code. Unfortunately this class doesn’t support quasiquotes, so passing a file with quasiquotes will result in exception.
The file passed to the application doesn’t necessarily have to be compilation error free. It can contain macros, that are not yet defined. This way you can write your desired syntax, and then use this application to see how it is parsed. This should make macro implementation easier.

An example of IQuackFu usage in Boo

2008-12-14T12:40:00.001+01:00

The IQuackFu interface lets you intercept calls to a duck type when called method or property doesn’t exist. You can use this to achieve many interesting things. In Boo’s examples there is a class for accessing XML data and also a class that allows dynamic inheritance. The IQuackFu interface has three methods:

QuackInvoke(name as string, args as (object)) as object – intercepts method calls
QuackSet(name as string, parameters as (object), value) as object – intercepts property setter calls
QuackGet(name as string, parameters as (object)) as object – intercepts property getter calls

As you can see each method has a name argument, which contains a name of the called method or property. This name can be parsed and appropriate action can be taken. My example will be a simple class for accessing data in a database table. Methods called on this class should be in form of:

Get <table name> By <column 1> [And <column 2> And …] ( <value 1> [, <value 2>, …] )

The method name specifies which table will be queried and what columns will be used in the WHERE clause. Arguments of the method specify values for the filter. The method returns a DataSet. Here is the code:

import System
import System.Text.RegularExpressions
import System.Collections.Generic
import System.Data.SqlClient
import System.Data

class Repository(IQuackFu):
    
    def QuackInvoke(name as string, args as (object)) as object:

        match = /^Get(?<table>\w+)By(?<column>\w+?)(And(?<column>\w+?))*$/.Match(name)
        if match != null and match.Success:
            table = match.Groups["table"].Value
            
            params = List[of string]()
            for c as Capture in match.Groups["column"].Captures:
                params.Add(c.Value)
            
            if len(args) == len(params):
                return RunQuery(table, params.ToArray(), args)
            else:
                raise InvalidOperationException("Column count doesn't match parameter count")
        else:
            raise InvalidOperationException("Method name has incorrect format")
    
    private def RunQuery(table as string, params as (string), args as (object)):
        paramString = ""
        for i in range(len(params)):
            paramString += " and ${params[i]} = @p${i}"
        commandText = "select * from ${table} where (1 = 1)${paramString}";
        
        using connection = SqlConnection("<your connection string here>"):
            command = SqlCommand(commandText, connection)
            
            for i in range(len(args)):
                command.Parameters.AddWithValue("@p${i}", args[i])

            connection.Open()
            
            dataSet = DataSet()
            SqlDataAdapter(command).Fill(dataSet)
            return dataSet
    
    def QuackSet(name as string, parameters as (object), value) as object:
        pass
    
    def QuackGet(name as string, parameters as (object)) as object:
        pass

Sample usage of this class is:

repository = Repository()
customers = repository.GetCustomersByCountry("Germany") as DataSet
products = repository.GetProductsByUnitsInStockAndReorderLevel(0, 0) as DataSet

As you can see, the result of the method is casted to DataSet. Without this, the result would be of the duck type, which means its members would be resolved at runtime. While this may be OK, you should consider two things:

Duck typing is approx. 160 times slower than static typing.
There is a known issue with Boo 0.8.2 causing AmbiguousMatchException to be thrown when an overloaded indexer is accessed on a duck type. This means that accessing indexer of Tables collection of the DataSet class through duck typing will result in this exception.

Boo language with SharpDevelop

2008-12-13T14:04:00.001+01:00

Recently I had urge to wander off the track laid by almighty Microsoft and take a peek into open source community. And there it is – the Boo language for CLI. It is announced as a “wrist friendly” language, which basically means that it has smooth syntax and other facilities that ease the hard life of a developer. The syntax is Python-like (or Ruby-like if you prefer), but the language itself is statically typed. It imitates dynamically typed language by type inference (where possible). The greatest power of Boo lies in extensibility of the language and the compiler, but let’s start at the beginning.

True programmers use the notepad, but lazy ones prefer to have some IDE. There is Boo support built into open source SharpDevelop IDE. You get project templates, syntax highlighting, debugger and NUnit integration for free.

This is no Visual Studio, but still impressive.

If you would like to learn about Boo, just visit it’s home page. As for this post I would like to bullet point some features that make programming in Boo more pleasant than C#:

First class functions. No need to declare a class, even for entry point.

Puts your code on a diet. It’s this:

class Calculator:
    def Add(a as int, b as int):
        return a + b

print Calculator().Add(1, 2)

versus this:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

public static class Program
{
    public static void Main()
    {
        Console.WriteLine(new Calculator().Add(1, 2));
    }
}

Builtin literals for arrays, lists and hashes (like Hashtable)

myArray = (1, 2, 4)
myList = [1, 2, "apple"]
myHash = { "key1" : "value1", "key2" : "Value2" }

print myArray
print myList
print myHash

// outputs:
// System.Int32[]
// [1, 2, apple]
// Boo.Lang.Hash

Generators, which are basically expressions for defining a sequence based on condition. Those sequences are not stored in memory, but rather executed on demand (yeah, you can do this with LINQ too)

squaresForEvenNumbers = i*i for i in range(10) if i % 2 == 0
print join(squaresForEvenNumbers, ', ')
fruits = ("apple", "bannana", "strawberry", "raspberry")
berries = "Berry: " + fruit for fruit in fruits if fruit.Contains("berry")
print join(berries, ', ')

// outputs:
// 0, 4, 16, 36, 64
// Berry: strawberry, Berry: raspberry

String interpolation (no more String.Format)
```
name = "Marcin"
print "Hello ${name}"
```
Builtin literals for regular expressions.
```
print /\d{2}-\d{3}/.IsMatch("12-333")
```

Slicing

numbers = (1, 2, 3, 4, 5)
print join(numbers[1:3])
name = "Marcin"
print join(name[-3:])

// outputs
// 2 3
// c i n

Duck typing, which is what you will get with the dynamic keyword in C# 4. This means being able to resolve member names at runtime. But Boo also implements mechanism of missing methods (also present in Ruby for example). When a method is not found on object implementing IQuackFu interface, then a special method of this interface is called and the name of missing method along with its parameters are passed. Developer can implement some behavior basing on the method’s name or its parameters. I hope to cover this in more detail in future.
Boo allows creating syntactic macros which you can use to extend language. While implementing a macro, developer has access to object tree representation of code (AST – abstract syntax tree) and is able to modify this tree. This opens a lot of possibilities. For examle Ayende Rahien uses this feature to create DSLs. Also you can build your own compiler steps – an example is to check the naming convenstions during compilation or automatically include assembly references for used types.

Hopefully I’ll be able to write more on Boo in future. For now I encourage you to explore it on your own.

How to get property name from lambda expression

2008-12-04T20:45:00.001+01:00

Just a quick tip here. If you need a property name for reflection or any other purpose, the simplest solution is to pass it as a parameter of your method. This unfortunately has a serious disadvantage of not being influenced by automatic refactoring. Alternate way is to take advantage of lambda expressions and expression trees:

public void UseProperty<T, K>(Expression<Func<T, K>> propertySelector)
{
    if (propertySelector.Body.NodeType != ExpressionType.MemberAccess)
    {
        throw new ArgumentException(
            "A property selector expression has an incorrect format");
    }

    MemberExpression memberAccess = propertySelector.Body as MemberExpression;

    if (memberAccess.Member.MemberType != MemberTypes.Property)
    {
        throw new ArgumentException("A selected member is not a property");
    }

    string property = memberAccess.Member.Name;
    Console.WriteLine(property);
}

The usage:

var myClass = new MyClass();
myClass.UseProperty((Exception ex) => ex.Message);

Notice there is no need to explicitly provide parameter types as they are inferred from the lambda expression, but you have to explicitly type the lambda expression. If your class operates on a specific type, you can make it generic and move type declaration to the point, where an instance is created. This is useful if you have more methods using lambda to retrieve property name.

public class MyClass<T>
{
    public void UseProperty<K>(Expression<Func<T, K>> propertySelector)
    {
        // same as previously
    }
}

The usage:

var myClass = new MyClass<Exception>();
myClass.UseProperty(ex => ex.Message);

Hope this helps.

Some thoughts on LLBLGen

2008-12-03T00:21:00.001+01:00

While there are many popular ORMs, the LLBLGen doesn’t get too much buzz on the blogs. Possibly because it is a commercial product and people rather use free tools if available. I think it is one of the first .NET ORMs on the market and it surely is a mature product. I had an opportunity to work a little with LLBLGen so I’d like to sum up some of my observations.

An overall impression I got was that LLBLGen is very ADO.NET-like. There’s no equivalent of session (or object context) unless explicitly specified, so the Identity Map pattern is not used by default, which is OK in most scenarios (and more intuitive in my opinion). Instead of session, you use a DataAccessAdapter class, which behaves like a smart connection to a database. There’s the EntityCollection class which is basically something like a DataSet – a data container, that tracks changes . There are typed lists which allow to create a custom view over a set of related entities.

The pros of LLBLGen are:

Allows you to just get things done quickly. Maybe not in the best style, but still.

Has a nice designer and a very sophisticated text templating engine with ORM oriented syntax. Take a look at this:

/// <summary> 
/// CTor which initializes the DTO with values from its corresponding entity 
/// </summary> 
/// <param name="entityInstance">The entity instance which holds the values for this DTO</param> 
public <[CurrentEntityName]>DTO(<[CurrentEntityName]>Entity entityInstance)<[ If IsSubType ]> 
    : base(entityInstance)<[ EndIf]> 
{ 
    <[Foreach EntityField CrLf]> _<[CaseCamel EntityFieldName]> = 
        entityInstance.<[EntityFieldName]>;<[NextForeach]> 
}

I consider this to be a nice example of DSL.

Has an advanced LINQ support together with extensions allowing you to define prefetch paths on IQueryable<>
Extensive predicate mechanism (Specification pattern) when not using LINQ
Supports both adapter mode (the usual with entities loaded and saved using external object, adapter) and self-serviced mode(Active record pattern)
Has some advanced features including auditing, authorization and own dependency injection, but presumably you will use specialized libraries for this aspects anyway.

While the cons are:

Entities generated by default templates are cluttered with ORM related code and really heavyweight.

The syntax imposed by runtime libraries is clumsy and awkward. An example:

EntityCollection customers = new EntityCollection(new CustomerEntityFactory());
DataAccessAdapter adapter = new DataAccessAdapter();
adapter.FetchEntityCollection(customers, null);
customers.Sort((int)CustomerFieldIndex.CompanyName, ListSortDirection.Descending);

Fortunately this is remedied to some extent by usage of LINQ.

Does not support lazy loading.
While prefetching related entities, LLBLGen generates separate SELECT statement for each entity type instead of performing a join.
While having a very nice templating engine and template designer, there is virtually no repository for community created templates. Sure, there is a forum section, but it is unstructured and you can browse posts from last year only!

Still, overall impression is good. I hope to get some comments on this :)

Using MetaLinq to simulate NHibernate’s DetachedCriteria in Entity Framework

2008-11-28T00:28:00.002+01:00

NHibernate’s DetachedCriteria allow you to specify a query filter outside session context and then pass it to code that actually uses a session in order to retrieve data. What’s more, DetachedCriteria is serializable, so you could imagine a scenario in which a client forms criteria and passes it to a service in order to query data.

Entity Framework has no such thing as DetachedCriteria, but you can use LINQ and expression trees in similar fashion. The only problem is that the expression trees are immutable and nonserializable. There is however a project called MetaLinq that copies an expression tree’s structure into mutable clone (built from custom set of classes that mirror the System.Linq.Expressions namespace) and enables you to both edit the tree and serialize it.

So I performed a little experiment. Following is the code of WCF service operation.

public Customer[] GetCustomersBy(EditableLambdaExpression filter)
{
    var filterLambda = filter.ToExpression() as LambdaExpression;
    var filterDelegate = filterLambda.Compile() as Func<Customer, bool>;

    using (var context = new NorthwindContext())
    {
        return context.CustomerSet.Where(filterDelegate).ToArray();
    }
}

The method receives a filter in a parameter. It is of type EditableLambdaExpression, which is one of MetaLinq’s expression types. By calling it’s ToExpression method you get the regular expression tree. Then there’s a compilation resulting in a delagate of type Func<Customer,bool> (it’s a quiet assumption) that is finally passed to the Where method of ObjectContext. Quite straightforward.

So is the client code:

using (Service1Client client = new Service1Client())
{
    var filter = EditableExpression.CreateEditableExpression(
        (Customer c) => c.CustomerID == "ALFKI") as EditableLambdaExpression;

    var customers = client.GetCustomersBy(filter);
}

The filter expressed as a lambda has to be converted to MetaLinq’s EditableLambdaExpression. Then it can be serialized and passed to the service. And this works just fine. What also works is:

var filter = EditableExpression.CreateEditableExpression(
    (Customer c) => c.CustomerID.StartsWith("A")) as EditableLambdaExpression;

What does not work is for example:

var filter = EditableExpression.CreateEditableExpression(
    (Customer c) => c.Orders.Any(o => o.Freight > 100.0M)) 
    as EditableLambdaExpression;

It turns out MetaLinq (as for now) is having trouble deserializing expressions with generic and extension methods.

This was an interesting experiment and now there is time for:

The criticism

I wouldn’t recommend using this idea in any production environment. It has several disadvantages:

MetaLinq itself is just an experiment, it definitely is not finished. There potentially are some hidden problems and you can’t express more advanced scenarios (unless of course you fix the code yourself :).
Building mutable expressions, serializing them, then deserializing and then compiling again imposes a performance penalty.
You can’t enforce the lambda passed to your service to be Func<Customer, bool>. You always has to check it and throw when it’s not.
And last but not least – it threats security of your service. What you’re doing is just executing some code that came from outside the service’s boundaries. This could allow someone to perform, let’s say, LINQ injection :)

[Book] Application Architecture Guide 2.0

2008-11-24T00:17:00.001+01:00

I just skimmed through Application Architecture Guide 2.0 by Patterns & Practices (beta). So I think it's a nice checklist for your project, whatever that is. The guide lists patterns and consideration points categorized both by layers and application types. Yet, if your not already familiar with those concepts, you might have trouble learning them from that book, because there are only short explanations without any examples and there are no specific technologies listed. It's a good starting point for your research. I myself was a little disappointed, because I expected more insight into advanced topics.

Should transaction management be implemented as an aspect?

2008-11-20T19:11:00.001+01:00

As usually the right answer is: that depends :) But let's think think about this a little.

When considering aspect oriented programming, there are a lot of very good examples of cross-cutting concerns whose implementation as an aspect is a very good idea (logging, exception handling, etc). But is transaction management such? Suppose there is situation like following:

(the service here is not to be understood as a part of distributed system, but rather as fragment of transaction script business logic)

Now, what are the pros of opening transaction in an advice (a handler) for DoSomethingTransactional():

You don't have to do it manually
Each new method and class matching a pointcut (or matching rules in Enterprise Library terminology) gets a "free" transaction without any effort
Transaction creation code is centralized and easy to modify
When the Service calls another service, say Service2, the operation should be implicitly enlisted to transaction that was created for Service1

Now the cons:

Transactions are a very serious matter. If for some reason your pointcut contains an error, some operations can execute without opening database transaction, which leads to violated data integrity in case of an unexpected error. This can cause some serious damage and is not easily detectable. I suppose you could roll out some unit tests for that.
Your transactions sometimes cover too much. Suppose your DoSomethingTransactional1 method does two things: updates a database record and then send a notification email. If sending an email fails, whole operation is rolled back. In some cases this is not a desirable behavior. A notification might be significantly less important than the business operation which was successful. This business operation might be your holiday trip reservation when there's just one place left :) Surely you could explicitly handle this error, but your code has to be aware of that specific error.

So you may consider using explicit transactions instead of AOP. Also remember, that .NET's TransactionScope is a nice way of determining what portion of code should run in a transaction.

A digression on UML modeling

2008-11-15T15:46:00.001+01:00

What do you need UML diagrams for?

UML is a language and a language is used for communication. This is also true for programming languages because through them you are communicating a compiler what you want to achieve. So anyway, the communication is the goal.

Who do you communicate with? This depends, really. For one, you may be trying to describe your application's structure in technical documentation. This means you're communicating with people that will require knowledge on your application in the future. Then there are design meetings. You can use UML to express your thoughts more clearly than in regular spoken language. Once other people get your idea, they can discuss, suggest changes and modify your diagrams.

How accurate should the diagrams be? This also depends. While writing a science book you would want to be a little more accurate than when making notes for your next grocery shopping. But this doesn't make your shopping list worse than a science book in terms of communication. It's accurate ENOUGH.

What I'm driving at is that you only need to make your UML diagrams (or any other diagrams) as good as it gets to communicate your ideas to your audience. In my opinion, once this is done, diagrams can be disposed. Well if you need them for future reference, that's fine, but treat them as a way of communication. As analogy I might ask you if you keep transcript of every meeting.

Finally, the language itself. Do you really need UML? Think twice before you use it, because maybe a few boxes connected with arrows will tell your audience more than an elaborate UML diagram. Not everyone can tell the difference between solid and dashed line, but that doesn't make them less able to comprehend your ideas.