Walter Almeida's Blog

Model-View-ViewModel Design Pattern - An implementation of RelayCommand for SilverLight

A common pattern for developping applications with SilverLight and WPF is the Model-View-ViewModel (MVVM) Design Pattern. The MVVP pattern is an evolution of the MVC and MVP well-known pattern, specially adapted to the advanced data binding features of WPF and SilverLight. Please refer to the following excellent MSDN article from Josh Smith for a complete description and implementation of the MVVM Pattern for WPF:

WPF Apps With The Model-View-ViewModel Design Pattern

However, as stated in this article title, we're talking about an MVVM pattern for WPF. For those who have tried to develop portable applications working on both WPF and SilverLight, you know this frustration of discovering small differences between WPF and SilverLight and missing classes in  SilverLight as compared to WPF. 

And in our specific case, Josh defines a RelayCommand class, used to simplified the binding with user interface elements commands with underlying actions in the ViewModel class.

Here is the definition of the RelayCommand class:

public class RelayCommand : ICommand
{
 #region Fields

 readonly Action

This class makes use of the CommandManager object and the RequerySuggested event. When a user actions the UI in WPF, this triggers the CommandManager to requery all the commands. In Silverlight the CommandManager class does not exist: you have to do the work yourself!

So I created the following RelayCommand implementation, working for SilverLight:

 public class RelayCommand : ICommand
 {
 #region Fields

 readonly Action

And here is the definition of the ICommandManager interface:

 public interface ICommandManager
 {
 event EventHandler RequerySuggested;
 }

Now when creating a new command, you should pass a reference to an object implementing the ICommandManager interface. This object will usually be the ViewModel class itself. It is then the responsability of the ViewModel class to trigger the RequerySuggested event when anything in the state of the ViewModel changed that requires the command to be rebinded. That's it, this completes the SilverLight implementation of the MVVM pattern. 

Using Multiple Monitors in Remote Desktop Session

I have just found out a GREAT new feature included in Windows 7 / Windows Server 2008 R2 :

Multiple monitor support for Remote Desktop Services allows users to open a Remote Desktop connection expanded across all the monitors on the client computer regardless of the client monitor configuration. With this feature, the user can fully utilize all the monitors connected to the client computer for the Remote Desktop connection thereby providing extra desktop space and an almost seamless experience with the client desktop that is much improved over “Span mode”.  

I have been so frustated so far to not be able to fully take advantage of my two screens in remote scenarios. And it is more and more usual to work on virtual machines. For instance I develop  with Visual Studio 2010 on a virtual Windows Server 2008 machine, and I was not able so far to fully utilize the multiple screens support of VS2010. I now can:)

The only thing to do to initiate a remote session with multiple screen support is to check the "Use all my monitors for the remote session" box:

 

Find out more here: http://blogs.msdn.com/b/rds/archive/2009/07/01/using-multiple-monitors-in-remote-desktop-session.aspx

WCF, DataContract serialization and self-tracking entities - Internals and tips

Custom Data exchanged with WCF services is defined through DataContracts using DataContract and DataMember attributes to the data definition classes. Please refer to the msdn help for more information: 

http://msdn.microsoft.com/en-us/library/ms733127.aspx

The recommended way of doing so is to apply the DataMember attributes to properties

namespace MyTypes
{
 [DataContract]
 public class PurchaseOrder
 {
 private int poId_value;

 // Apply the DataMemberAttribute to the property.
 [DataMember]
 public int PurchaseOrderId
 {
 get { return poId_value; }
 set { poId_value = value; }
 }
 }
}

However there are cases where you want to apply the DataMember attributes to the fields instead of the properties. I will describe here one of these cases.

The Case

The case is: you want to develop an N-tier application, exposing business data through a WCF service facade. To do so, you define a custom data structure, representing your business, you expose it as a DataContract and you share the DataContract assembly between the WCF service and the client application.

Let's take the following definition of a DataContract representing a contact:

[DataContract]
public class Contact : INotifyPropertyChanged
{
 #region fields

 private string _firstName;
 private string _lastName;
 private bool _isDirty = false;

 #endregion

 #region properties

 [DataMember]
 public string FirstName
 {
 get
 {
 return _firstName;
 }
 set
 {
 if (_firstName == value)
 return;

 _firstName = value;
 OnPropertyChanged("FirstName");
 }
 }

 [DataMember]
 public string LastName
 {
 get
 {
 return _lastName;
 }
 set
 {
 if (_lastName == value)
 return;

 _lastName = value;
 OnPropertyChanged("LastName");
 }
 }

 [DataMember]
 public bool IsDirty
 {
 get
 { 
 return _isDirty;
 }
 set
 {
 if (_isDirty == value)
 return;
 
 _isDirty = value;
 OnPropertyChanged("IsDirty");
 }
 }

 #endregion

 #region methods

 public Contact(string firstName, string lastName)
 {
 _firstName = firstName;
 _lastName = lastName;
 }

 public override string ToString()
 {
 return string.Format("FirstName: '{0}' LastName: '{1}' IsDirty: {2}", FirstName, LastName, IsDirty);
 }

 #endregion

 #region INotifyPropertyChanged implementation

 protected void OnPropertyChanged(string propertyName)
 {
 if (!ReferenceEquals(null, PropertyChanged))
 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

 if (propertyName != "IsDirty")
 IsDirty = true;
 }

 public event PropertyChangedEventHandler PropertyChanged;

 #endregion

}

The only addition to the first simple case is the support for the INotifyPropertyChanged interface. Indeed, if you want to develop a proper application, you probably want to handle self-tracking entities, to make sure the service at server level can easily figure out what happened to the data in order to efficiently process it. First step to handling self-tracking entities is to be able to determine whether data has been changed since last retrieval. This is handled through the IPropertyChanged interface.

Here starts our problems.

Let's take following service definition:

[ServiceContract]
public interface IContactService
{
 [OperationContract]
 Contact PassContactThrough(Contact theContactToPassThrough);
}

And service implementation:

public class ContactService : IContactService
{
 public Contact PassContactThrough(Contact theContactToPassThrough)
 {
 return theContactToPassThrough;
 }
}

All this operation is doing is passing the Contact through. We therefore expect to get back the same Contact information as the one we initially sent.

To test this, let's create a client, add a reference to the service and to the data contract assembly and do the following implementation:

static void Main(string[] args)
{
 ContactServiceClient service = new ContactServiceClient(); 

 var contactToPassThrough = new Contact("Walter", "Almeida");

 Console.WriteLine("Contact Before Service Call: " + contactToPassThrough.ToString());
 
 Contact returnedContact = service.PassContactThrough(contactToPassThrough);
 
 Console.WriteLine("Contact After Service Call: " + returnedContact.ToString());
}

We send through a Contact data for Walter Almeida. The Contact is clean, marked with IsDirty = false.

However, the returned Contact contains the proper "Walter Almeida" information but is marked ad IsDirty = true!

The explanation is the following: when sent to the service, the Contact data is serialized, accordingly to the DataMember attributes information. When received by the service, the received data is deserialized into a new Contact instance. When deserializing, the service will assign values to the Contact instance properties, because it is the properties that  are marked as DataMembers. When doing so: the OnPropertyChanged method is called and IsDirty is set to true.

We could have been lucky here if IsDirty (also marked as DataMember) would be the last one to be deserialized thus compensating the previous calls to IsDirty = true. However when no specified otherwise, the DataMembers are serialized in alphabetical order. Therefore IsDirty is deserialized before LastName...

Here are candidate solutions to this problem with benefits and drawbacks:

Solution 1: Do not share the exact same DataContract assembly 

Instead of sharing the exact same data contract assembly, the server should use a assembly that has the datacontract definition without the INotifyPropertyChanged interface implementation: just data, no behaviour:

[DataContract]
public class Contact : INotifyPropertyChanged
{
 #region fields

 private string _firstName;
 private string _lastName;
 private bool _isDirty = false;

 #endregion

 #region properties

 [DataMember]
 public string FirstName
 {
 get
 {
 return _firstName;
 }
 set
 {
 _firstName = value;
 }
 }

 [DataMember]
 public string LastName
 {
 get
 {
 return _lastName;
 }
 set
 {
 _lastName = value;
 }
 }

 [DataMember]
 public bool IsDirty
 {
 get
 {
 return _isDirty;
 }
 set
 {
 _isDirty = value;
 }
 }

 #endregion

}

However this requires two different versions of the data definition, leading to the associated maitainability issues.

Moreover we also loose all the tracking capabilities at server side, which is wrong: it is possible for the service to perform actions on the data and therefore these actions should be also tracked.

Solution 2: Change order of properties serialization

By default DataMembers are serialized in alphabetical order. You can redefine this order the following way:

[DataContract]
public class Contact : INotifyPropertyChanged
{
 #region fields

 private string _firstName;
 private string _lastName;
 private bool _isDirty = false;

 #endregion

 #region properties

 [DataMember(Order = 0)]
 public string FirstName
 {
 get
 {
 return _firstName;
 }
 set
 {
 if (_firstName == value)
 return;
 
 _firstName = value;
 OnPropertyChanged("FirstName");
 }
 }

 [DataMember(Order = 1)]
 public string LastName
 {
 get
 {
 return _lastName;
 }
 set
 {
 if (_lastName == value)
 return;

 _lastName = value;
 OnPropertyChanged("LastName");
 }
 }

 [DataMember(Order = 2)]
 public bool IsDirty
 {
 get
 {
 return _isDirty;
 }
 set
 {
 if (_isDirty == value)
 return;
 
 _isDirty = value;
 OnPropertyChanged("IsDirty");
 }
 }

 #endregion

 #region methods

 public Contact(string firstName, string lastName)
 {
 _firstName = firstName;
 _lastName = lastName;
 }

 public override string ToString()
 {
 return string.Format("FirstName: '{0}' LastName: '{1}' IsDirty: {2}", FirstName, LastName, IsDirty);
 } 

 #endregion

 #region INotifyPropertyChanged implementation

 protected void OnPropertyChanged(string propertyName)
 {
 if (!ReferenceEquals(null, PropertyChanged))
 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
 if (propertyName != "IsDirty")
 IsDirty = true;
 }

 public event PropertyChangedEventHandler PropertyChanged;

 #endregion

}

The problem is now solved: IsDirty is not altered by the deserialization. Or better said: the IsDirty value is altered during deserialization but restored to the proper value at the end of deserialization when the IsDirty value is deserialized.

This solution is working but not perfect: there are still unecessary calls to the property changed event handler. And it can become cumbersome if we further complexify the Contact class. Moreover this solution does not work if we define a hierarchy of data classes and define the IsDirty property on the base class:

public class BaseContact : INotifyPropertyChanged
{
 #region fields
 
 private bool _isDirty = false;
 
 #endregion

 #region properties

 [DataMember]
 public bool IsDirty
 {
 get
 {
 return _isDirty;
 }
 set
 {
 if (_isDirty == value)
 return;
 
 _isDirty = value;
 OnPropertyChanged("IsDirty");
 }
 }

 #endregion

 #region INotifyPropertyChanged implementation

 protected void OnPropertyChanged(string propertyName)
 {
 if (!ReferenceEquals(null, PropertyChanged))
 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

 if (propertyName != "IsDirty")
 IsDirty = true;
 }

 public event PropertyChangedEventHandler PropertyChanged;

 #endregion
}


[DataContract]
public class Contact : BaseContact
{
 #region fields

 private string _firstName;
 private string _lastName;

 #endregion

 #region properties

 [DataMember]
 public string FirstName
 {
 get
 {
 return _firstName;
 }
 set
 {
 if (_firstName == value)
 return;
 
 _firstName = value;
 OnPropertyChanged("FirstName");
 }
 }

 [DataMember]
 public string LastName
 {
 get
 {
 return _lastName;
 }
 set
 {
 if (_lastName == value)
 return;

 _lastName = value;
 OnPropertyChanged("LastName");
 }
 }

 #endregion

 #region methods

 public Contact(string firstName, string lastName)
 {
 _firstName = firstName;
 _lastName = lastName;
 }

 public override string ToString()
 {
 return string.Format("FirstName: '{0}' LastName: '{1}' IsDirty: {2}", FirstName, LastName, IsDirty);
 }

 #endregion

}

In this case setting orders on DataMembers will not solve the problem because DataMembers of base classes (and therefore IsDirty) are always serialized/deserialized first.

Solution 3: Mark fields as DataMember instead of properties

Third solution is to mark the fields with the DataMember attribute, rather than the properties. This way, the deserialization step will set fields rather than properties and therefore OnPropertyChanged will never be called.

The limitation is that serialization of private fields is not allowed in partial trust scenarios (and this is the case for instance when developping a SilverLight client). Everything works fine when running in a full trust environment. To overcome this issue, the fields must be set as internal rather than private and you need to mark the assembly defining the data contracts with the following attribute (in assemblyinfo.cs):

[assembly: InternalsVisibleTo("System.Runtime.Serialization")]

This gives access right to the serialization assmebly to access your internal members. Not doing so would result in the following exception at runtime, when running in partial trust environments: 

The data contract type 'Contact' cannot be deserialized because the property '_firstName' does not have a public setter. Adding a public setter will fix this error. Alternatively, you can make it internal, and use the InternalsVisibleToAttribute attribute on your assembly in order to enable serialization of internal members - see documentation for more details. Be aware that doing so has certain security implications

So here is the final version of the Contact data contract:

[DataContract]
public class Contact : INotifyPropertyChanged
{
 #region fields

 [DataMember( Name = "FirstName")]
 internal string _firstName;

 [DataMember( Name = "LastName")]
 internal string _lastName;
 
 [DataMember( Name = "IsDirty")]
 internal bool _isDirty = false;

 #endregion

 #region properties

 public string FirstName
 {
 get
 {
 return _firstName;
 }
 set
 {
 if (_firstName == value)
 return; 
 
 _firstName = value;
 OnPropertyChanged("FirstName");
 }
 }

 public string LastName
 {
 get
 {
 return _lastName;
 }
 set
 {
 if (_lastName == value)
 return;
 
 _lastName = value;
 OnPropertyChanged("LastName");
 }
 }

 public bool IsDirty
 {
 get
 {
 return _isDirty;
 }
 set
 {
 if (_isDirty == value)
 return;
 
 _isDirty = value;
 OnPropertyChanged("IsDirty");
 }
 }
 #endregion

 #region methods

 public Contact(string firstName, string lastName)
 {
 _firstName = firstName;
 _lastName = lastName;
 }

 public override string ToString()
 {
 return string.Format("FirstName: '{0}' LastName: '{1}' IsDirty: {2}", FirstName, LastName, IsDirty);
 }

 #endregion

 #region INotifyPropertyChanged implementation

 private void OnPropertyChanged(string propertyName)
 {
 if (!ReferenceEquals(null, PropertyChanged))
 PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

 if (propertyName != "IsDirty")
 IsDirty = true;
 }
 
 public event PropertyChangedEventHandler PropertyChanged;

 #endregion
}

Please note the extra Name = xx setting of the DataMembers. This is to ensure we get a equivalent data schema as the one when marking the Properties as DataMembers. This implementation solves our issue and works in both full trust and partial trust environment. That's it for now!

Using the dynamic Keyword in C# to Improve Object-Orientation

C# 4.0 introduces the new 'dynamic' keyword to the language, adding dynamic support to the .NET Framework though the DLR (Dynamic Language Runtime). 

My first understanding of the use of such a dynamic support was the following:

• Great to use for inter-connections with dynamic langages, avoiding to have to write too complex code to bridge the gap between the 2 languages.
• Great to use for instance for Microsoft Office automation. MS Office automation is done though COM objects. Previous use of MS Office PIA was cumbersome. The new dynamic keyword makes much less verbose.
• Enhance support for reflection.

With the dynamic keyword, type checking is no more done at compile time but will be done at runtime. Thus making code writing more flexible (especially when using uncertain type, only known at runtime). However it makes writing code less safe (no compile checking) and less productive (no intellisense). Therefore one should not use the dynamic keyword in C#, except in previous cases. And use instead Object orientation design principles and patterns to achieve safe, strongly-typed coding. Moreover, the addition of generics to the .NET Framework 2.0 was a huge step forward to enable better object orientation and strong typing.

So IMHO the dynamic keyword and DLR is a great thing to have but will also be an added opportunity to write bad code and break core design principles. So one should be aware of it and use it sparingly, when making real sense!

Moreover be aware that the use of the dynamic keyword has a performance hit: because runtime discovery and type checking has to be done at runtime.

I came accross a post from Peter Ritchie highlighting another great use of the dynamic keyword. I said previously that when developing in C#, you should use as much as possible proper object orientation principle and patterns to write proper good code (because C# is a OO language). However there are cases where it is not easy to write full pure object oriented code. And Peter describes one of these cases and how the dynamic keyword can help:

http://msmvps.com/blogs/peterritchie/archive/2010/05/24/using-the-dynamic-keyword-in-c-to-improve-object-orientation.aspx

The case is the following (for more details please refer to Peter Ritchie's post):

When you use method overloading to define methods that take different flavors of a given type hierarchy (Circle and Square both derive from Shape):

public static void Draw(Circle circle)
{
 //... 
}

public static void Draw(Square square)
{
 //... 
}

When you want to call the Draw method, you have to call it with an object that is known at compile time to be either a Circle or a Square (or inheriting from Circle or Square). You cannot call it generically with a object of type Shape. This is because the compiler must know which method overload to link to.

Please note that this example is probably not the best as a solution could be to define the Draw method on the Shape class and override it on both Circle and Square. However there are cases where this scenario really makes sense, so just take this as a sole demonstration purpose, and get the idea of what the dynamic keyword could bring.

Back to our example, the following method will not compile:

public void ProcessShape(Shape shape)
{
 //...
 Draw(shape); 
 //...
}

You instead have to write something like 

public void ProcessShape(Shape shape)
{
 //...
 if (!ReferenceEquals(null, shape as Square))
 {
 Draw(shape as Square);
 }
 if (!ReferenceEquals(null, shape as Circle))
 {
 Draw(shape as Circle);
 }
 //... 
}

Thus wasting the interest of object orientation, adding a maintenance point for when new Shape types are added etc...

Solution with using the dynamic keyword is:

public void ProcessShape(Shape shape)
{
 //...
 dynamic dynShape = shape; 
 Draw(dynShape); 
 //...
}

The type checking done previously in code is now done by the DLR and the code is more robust: we have elimintated the maintenance point.

And here is the full code that demonstrate the use of the dynamic keyword (just create a Console app to include this code):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
 public class Shape
 { 
 }

 public class Circle : Shape
 {
 }

 public class Square: Shape
 {
 }

 class Program
 {
  static void Main(string[] args)
  {
   Shape myShape = null;
 
   myShape = new Square(); 
   ProcessShape(myShape);

   myShape = new Circle();
   ProcessShape(myShape);

   Console.ReadLine();
  }

  static void ProcessShape(Shape shape)
  {
   //Draw(shape);
   dynamic dynShape = shape;
   Draw(dynShape);
  }

  static void Draw(Square square)
  {
   Console.WriteLine("I am a Square");
  }

  static void Draw(Circle circle)
  {
   Console.WriteLine("I am a Circle");
  }
 }

}

This is a great use of the dynamic keyword. However: this is also a good example to show that the dynamic keyword could be used improperly instead of a right object oriented design: We said before that in this specific case, it could probably better to add a Draw method on the Shape class and override it on derived class : this is a basic OO design principle: classes embed data and behavior. Thing is there is no definite rule: depending on your overall design and architecture (and especially the level of coupling you want to have), it could be good design to have the Draw method excluded from the Shape class. So nothing replaces experience, however the enhancement of the programming languages will add more and more confusion for beginners! And this makes the software design and development really challenging and exciting!

Advanced Linq - Dynamic Linq query library: Add support for 'Contains' extension

This post explains how to extend the Dynamic Linq library to support the "Contains" extension method. This post also can serve as a base for further extension of the Dynamic Linq Library and adding support to more extension methods.

Linq is an amazing programming model, brought to life by the Microsoft.NET Framework 3.5, that introduces data queries as a first-class concept into any Microsoft programming langage.

Linq allows you to build strongly type queries to access data in any source for which a Linq support library is available, including MS SQL, data objects (through IEnumerable and IQueryable), Entity Framework and more.

Even though the regular, strongly typed approach to building queries is definitively recommended, in some cases arises the need for dynamically building queries. For this purpose Microsoft freely provides an open source dynamic Linq query library. Cases for using dynamic queries could be for example: you might want to provide business intelligence UI within your application that allows an end-user business analyst to use drop-downs to build and express their own custom queries/views on top of data. Another example is the creation of RESTfull service interfaces that accept query string parameters that could be converted to dynamic linq queries.

Please refer the the Scott Guthrie post for more information on the Dynamic Linq Query library:

http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx

I found this library very usefull and used it in several scenarios. However this library does not support all of the Linq extensions. I had the need for building dynamic queries with the "Contains" extension which was not supported by the Microsoft Dynamic Linq library. This post explains how to extend the Dynamic Linq library to support the "Contains" extension method. 

Sample Code

Here is the sample application we use to illustrate our tallks (You can download the source code here) : 

We define a class "Contact". For the purpose of demonstration, we do not connect to a data source, but have a static "GetContactList" method that return a collection of users. 

public class Contact
{
 public string FirstName { get; set; }
 public string LastName { get; set; }
 public DateTime BirthDate { get; set; }
 public string Country { get; set; }

 public Contact(string firstName, string lastName, DateTime birthDate, string country)
 {
 FirstName = firstName;
 LastName = lastName;
 BirthDate = birthDate;
 Country = country;
 }

 public override string ToString()
 {
  return string.Concat(FirstName, " ", LastName, " ", BirthDate, " ",Country);
 }
 
 public static List‹contact› GetContactsList()
 {
  var result = new List‹contact›();
 
  result.Add(new Contact("Zephr", "Austin", new DateTime(1967, 11, 07), "Afghan"));
  result.Add(new Contact("Odette", "Bean", new DateTime(1993, 05, 18), "Uzbekistan"));
  result.Add(new Contact("Maggie", "Mcson", new DateTime(2001, 06, 12),"Kiribati"));
  ...
  ...
 
  return result;
 }
}

 

The Case – Use of the Dynamic Linq Library and missing support for the “Contains”  extension method

 

Let's take a first example of simple Linq query to get the contacts located in Austria. Using regular Linq, you write the following query:

var query = from c in Contact.GetContactsList() where c.Country == "Austria" select c;

Or the equivalent query, using extension methods and lambda 

var query = Contact.GetContactsList().Where(c => c.Country == "Austria");

We will keep the second syntax as the dynamic linq library does not support the first syntax.

We can then iterate the query result and retrieve relevant contact information:

foreach (var contact in query)
{
 Console.WriteLine(contact.ToString());
} 

Doing the same query using dynamic Linq: 

query = Contact.GetContactsList().AsQueryable().Where("Country == @0", "Austria");

Please not the extra "AsQueryable()" call because the dynamic extension applies on collections implementing IQueryable. Then Iterating the results is just the same as with regular Linq.

The Dynamic Linq library also supports more complex queries. For instance here is the Dynamic Linq query to retrieve all contacts in Austria, born in 1957: 

query = Contact.GetContactsList().AsQueryable().Where("Country == @0 && BirthDate.Year == 1957", "Austria");

 

Everythings seems to magically work so far. Let’s try now a more complex scenario: when want to retrieve the list of contacts located in given list of countries. Let’s say : all contacts located in either Austria or Poland. For such a purpose, a common solution is to use the “Contains” extension method:

query = Contact.GetContactsList().Where(c => new List<string>>() { "Austria", "Poland" }.Contains(c.Country));

 

In Linq to SQL, the result pseudo SQL projection would be:

select * from contact c where c.Country in (‘Austria’, ‘Poland’);

 

Let’s try to write the same query in Dynamic Linq (using parameters to pass the input list of countries):

query = Contact.GetContactsList().AsQueryable().Where("@0.Contains(Country)", new List<string>() { "Austria", "Poland" });

 

This result at runtime to the following exception: “No applicable aggregate method 'Contains' exists”,

Emphasizing the fact the Dynamic Linq library does not have support for the “Contains” extension method. The following section will explains how to add support for “Contains”.

 

Add support for the “Contains” extension method

Analyzing the “Dynamic.cs” class that adds support for Dynamic Linq, you’ll find the definition of the  IEnumerableSignatures interface. This interface lists all IEnumerable extension methods that are supported by the Dynamic Linq library. You should add the “Contains” extension method signature:

interface IEnumerableSignatures
{
 void Contains(object selector);
 void Where(bool predicate);
 void Any();
 void Any(bool predicate);
 void All(bool predicate);
 void Count();
 void Count(bool predicate);
 void Min(object selector);
 void Max(object selector);
 void Sum(int selector);
 void Sum(int? selector);
 void Sum(long selector);
 void Sum(long? selector);
 void Sum(float selector);
 void Sum(float? selector);
 void Sum(double selector);
 void Sum(double? selector);
 void Sum(decimal selector);
 void Sum(decimal? selector);
 void Average(int selector);
 void Average(int? selector);
 void Average(long selector);
 void Average(long? selector);
 void Average(float selector);
 void Average(float? selector);
 void Average(double selector);
 void Average(double? selector);
 void Average(decimal selector);
 void Average(decimal? selector);
}

 

The IEnumerableSignatures interface is then used in the following method:

 

Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos) 
{
 ParameterExpression outerIt = it;
 ParameterExpression innerIt = Expression.Parameter(elementType, "");
 it = innerIt;
 Expression[] args = ParseArgumentList();
 it = outerIt;
 MethodBase signature;
 if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1)
 throw ParseError(errorPos, Res.NoApplicableAggregate, methodName);
 Type[] typeArgs;
 if (signature.Name == "Min" || signature.Name == "Max") {
 typeArgs = new Type[] { elementType, args[0].Type };
 }
 else {
 typeArgs = new Type[] { elementType };
 }
 if (args.Length == 0) {
 args = new Expression[] { instance };
 }
 else {
 args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };
 }

 return Expression.Call(typeof(Enumerable), signature.Name, typeArgs, args);
}

 

There 2 changes to perform to that method.

Fist, the arguments are constructed using the following line:

args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };

 

this has to be changed specifically for the Contains methods to the following:

args = new Expression[] { instance, args[0] };

Reason is that the signature of the Contains extension methods differs from the others. Let’s take an example: here are the definitions for the “Any” and “Contains” extension methods of the IEnumerable<> interface (classe “System.Linq.Enumerable”):

 

Any<TSource>(this.System.Collections.Generic.IEnumerable<TSource>, System.Func<TSource,bool>);
Contains<TSource>(this.System.Collections.Generic.IEnumerable<TSource>, TSource);

 

You can see that the parameter of the “Any” extension method is a lambda expression taking “TSource” (type of innerIt in our Dynamic Linq library) as entry and returning ”bool” .This explains the transformation Expression.Lambda(args[0], innerIt). In the case of the “Contains” extension method, type of the argument is not a Lambda but just “TSource”.

Next change is the following: the Dynamic Linq library transforms the input string to a proper Linq query by parsing the input string. It internally keeps a context to the current collection being processed. This is the use of the field “innerIt”. When processing our list of “Contacts”, the innerIt represent a “Contact”. However, when processing the “Contains” method, the context changes from the list of “Contacts” to the list being the source for the “Contains” method; in our case: the list of string representing country name. Therefore the parsing of the following dynamic Linq expression:

query = Contact.GetContactsList().AsQueryable().Where("@0.Contains(Country)", new List<String>() { "Austria", "Poland" });

will not work: the parser will try to find a property “Country” on type String, where we meant a property “Country” on “Contact”.

In fact the previous query is equivalent to:

query = Contact.GetContactsList().AsQueryable().Where("@0.Contains(it.Country)", new List<String>() { "Austria", "Poland" });

Where “it” is the keyword defined in the Dynamic Linq library to represent the current element. It represents here the current item in the list {“Austria”, “Poland”}. What we would like here is the following syntax:

query = Contact.GetContactsList().AsQueryable().Where("@0.Contains(outerIt.Country)", new List<String>() { "Austria", "Poland" });

where “outerIt” represents the englobing context: the list of “Contacts”.  For this we should define an “outerIt” keyword, and use it in the “ParseAggregate” method. The new implementation of the “ParseAggregate” methods is now:

Expression ParseAggregate(Expression instance, Type elementType, string methodName, int errorPos) 
{
 outerIt = it;
 ParameterExpression innerIt = Expression.Parameter(elementType, "");
 it = innerIt;
 Expression[] args = ParseArgumentList();
 it = outerIt;
 MethodBase signature;
 if (FindMethod(typeof(IEnumerableSignatures), methodName, false, args, out signature) != 1)
  throw ParseError(errorPos, Res.NoApplicableAggregate, methodName);
 Type[] typeArgs;
 if (signature.Name == "Min" || signature.Name == "Max") {
  typeArgs = new Type[] { elementType, args[0].Type };
 }
 else
 {
  typeArgs = new Type[] { elementType };
 }
 if (args.Length == 0) {
  args = new Expression[] { instance };
 }
 else {
  if (signature.Name == "Contains")
  args = new Expression[] { instance, args[0] };
  else
  args = new Expression[] { instance, Expression.Lambda(args[0], innerIt) };
 }
 return Expression.Call(typeof(Enumerable), signature.Name, typeArgs, args);
}

 

By the way: it is important to mention that since “it” and “outerIt” are defined keywords, they become reserved keywords and should not be used as properties or method definitions in your data classes, if you intend to access them as part of dynamic queries. It would result in a runtime error. Since the common used code standards are to use only capitalized names for public properties and methods, it should be alright in most of the cases.

Remains the use of the “outerIt” keyword. Definition of the keyword and class level storage of its current value:

static readonly string keywordOuterIt = "outerIt";
ParameterExpression outerIt;

 

Taking into account the new keyword in « ParseIdentifier »

 

Expression ParseIdentifier() 
{
 ValidateToken(TokenId.Identifier);
 object value;
 if (keywords.TryGetValue(token.text, out value)) {
 if (value is Type) return ParseTypeAccess((Type)value);
 if (value == (object)keywordIt) return ParseIt();
 if (value == (object)keywordOuterIt) return ParseOuterIt();
 if (value == (object)keywordIif) return ParseIif();
 if (value == (object)keywordNew) return ParseNew();
 NextToken();
 return (Expression)value;
 }
 ...
 ...

 

And new method “ParseOuterIt”:

 

Expression ParseOuterIt()
{
 if (outerIt == null)
 throw ParseError(Res.NoItInScope);
 NextToken();
 return outerIt;
}

 

 

Conclusion

 

That’s it ! The Dynamic Linq library is now supporting the « Contains » extension method

You’ll find the modified “Dynamic.cs” class as part of the code sample. You can now write and successfully run queries likes the following:

query = Contact.GetContactsList().AsQueryable().Where("@0.Contains(outerIt.Country)", new List<String>() { "Austria", "Poland" });

or:

query = Contact.GetContactsList().AsQueryable().Where("@0.Contains(outerIt.Country) && it.BirthDate.Year > @1", new List<string>() { "Austria", "Poland" }, 1955);

This post can be used to further extend the Dynamic Linq library and add support for more extension methods.

Hope this can help other who faced the same limitation and help move forward the Dynamic Linq Library!

You can download the source code for the sample project here. 

 

Great resource for SilverLight development on SharePoint 2010

Here is a great resource about SilverLight development on SharePoint 2010:

http://code.msdn.microsoft.com/SP2010Silverlight/

Include sample code and a video explaining how to develop with SilverLight for SharePoint 2010. Including topics like: SilverLight WebPart development, SilverLight field controls development, the use of the HTML bridge to pass data between SilverLight WebPart and the web page. And last but not least: how to connect SilverLight WebParts with no page refreshes and using the standard WebPart connection mechanism.

Also a sample making use of the new restfull access to SharePoint lists using ADO.NET services.

A must read for those who are starting developping with SilverLight on SharePoint 2010!

SilverLight/WPF: Handling mouse Entering/Leaving composite controls

I have been struggling sometime now trying to handle the following scenario, which seems quite simple at first. This problem highlights the difficulties one can face when doing WPF and/or SilverLight developments: while the most cases are working just fine and great, you will regularly face issues you were not expecting. Making WPF/SilverLight development rather complex.

The scenario is the following: I have a page, composed of several controls. The composing controls are themselves composite controls : there are composed of multiple UI controls

I want to style my page the following way: whenever the user moves his mouse cursor over a control, I want to play an animation to highlight this control. And whenever the user moves his mouse cursor out of a control, I want to play an animation to remove highlight on this control

Let illustrate this with a concrete example: I have a page showing a grid view of products and a form view displaying the details of the selected product. The grid view and the form view are two composite user controls composed of other controls.

Whenever the grid view is focused, I want the following visual result:

 

 

And whenever the form view is focused, I want the following visual result:

 

 

Well... seems quite obvious at first: why not just add a Trigger on the control, triggered by a changing value of the property "IsMouseOver" (for WPF. For SilverLight there is no "IsMouseOver, so instead we should add EventTriggers on "MouseEnter" / "MouseLeave"). When "IsMouseOver" changes, then we can then just play the adequate storyboard.

However the reality is more complex than that... The main control will receive MouseEnter and MouseLeave events (with associated changes of "IsMouseOver" ) whenever the mouse cursor enters/leaves the targeted control AND when the mouse cursor enters/leaves any of the sub-controls composing the targeted control!

Which results in a flickering display: in our example, while moving the mouse inside the scope of the product form view, the form view will be constanlty switched from highlighted to not-higlighted when for example the mouse enters the scope of a TextBox.

I have tried quite a few things to fix that issue. I registered to the MouseEnter/MouseLeave events, in order to generate custom events that will really reflect entering/leaving the main control, and hiding entering/leaving internal controls. However this was a failure and there is no easy way to really be able to know if a MouseLeave event on the main control is because we're really leaving the main control or entering a sub-control.

I have made some research to see what others are doing but could not find a satisfactory answer. I had to admit this is not an easy task on WPF/SilverLight where it just should be!!

So here is the final solution that I implemented:

The problem is really on the MouseLeave event: we have no easy way to figure out if we are really leaving the main control or just entering a sub-control. No problem on the MouseEnter event: whenever we receive a MouseEnter event it means that we are entering the main control or already are over the main control and entering a sub control. But the important point is: we know we are over the main control.

The solution is therefore the following

• Only rely on MouseEnter event: whenever a MouseEnter event is received, we do the animation for Highlighting the control (and keep a flag set to do the animation only once)
• We know we are leaving a control, when we are entering another one (in our example we know we are leaving the product grid view when we are entering the product form view.
• So: when a MouseEnter event is received, in addition to  do the animation for Highlighting the controlwe, we also do the animation to remove higlight from all other controls

That's it! It is working great!

And a few quick tips for doing it on WPF, using the MVVM pattern:

• Add an "IsActiveView" Property on the ViewModel of each composite control
• In the main page loaded event, register to the composite controls MouseEnter events, and in the handlers: set/unset accordingly the "IsActiveView" property of each control
• Create DataTriggers binded on the "IsActiveView" to trigger the appropriate animation

Hope it can help others facing the same issue!

Presenting a great tool: ReSharper

As I describe in the Golden Rule #2, refactoring is a first class citizen of an agile software development process. However refactoring can be painful without appropriate tooling. I have been using the refactoring tools included in Visual Studio since version 2005. This was until I tried and adopted ReSharper.

Visual studio provides us since version 2005 with great refactoring tools. However you start to see limits of these embedded tools once you start large refactoring work involving multiple projects and cross references. I recently started the first refactoring phase of a large project I am working on at the moment. After a first half through, I decided on trying the ReSharper tool. And this was the best choice I possibly could have done! For information I am talking here of ReSharper version 4.1, and I am developing on Visual Studio 2008 SP1. So here is my feedback on the tool:

First of all, I must say that ReSharper is amazingly well integrated into Visual Studio, as you will see in the snapshots later. Very easy to install and then fully integrated into Visual Studio. 

Then I should clarify that ReSharper is more than just a refactoring tool. It includes tools for code analysis, coding assistance, code cleanup, code generation, obviously refactoring and even more… I haven't tried all the included tools yet but I will say a word about code analysis and coding assistance. ReSharper is doing some things that were intended by FxCop (now included in Visual Studio as code analysis), but in a much better way. FxCop was an attempt to guide developers toward writing clean code and following best practices. But it was IMHO a failed attempt, and FxCop was perceived by the developers more as a hassle than real help… Those who have tried the tool can understand what I mean. ReSharper has another very impressive approach to deal with code analysis and gives to the developer hints and advices directly on the source code view! And it is presented as hints rather that error messages. It might seem a detail but it makes a huge difference! Well I guess that FxCop provides many more rules than ReSharper and is not intended for the same purpose, but the ReSharper concept could maybe be used for competing with the Visual Studio code analysis.

Things I experienced are still missing in ReSharper are: renaming in XOML files for WF workflows. And I am not sure yet how renaming works globally with XML configuration files… So if you use dependency injection and configuration in XML then you might have to handle the renaming by hand. Therefore this is one advantage of configuration the DI cotainer dependencies though code versus XML, but that's out of scope here… Another thing that does not properly support renaming is data source definition files.

 

I will now give some examples of ReSharper features I found interesting while refactoring my project. 

First example is the nice way ReSharper highlights (light grey) the unused or redundant parts of your code and propose hints and operation to remove it. In this example, ReSharper proposes you to simplify your code by removing a redundant qualifier: 

 

And in the next example, ReSharper proposes an option to clean up the using directives by removing the unused ones. By the way you can automate this cleaning process on the whole code:

 

 

 

ReSharper also highlights potential runtime problems like in next example where you get the hint that you might get an exception from an API call. Up to you then to judge if your need to add error handling code:

 

 

One great feature is that ReSharper allows you to rename namespaces or portion of namespaces. This is something very useful as reorganizing namespaces is a very common refactoring scenario. I have validated that this refactoring works amazingly well, included across multiple projects:

 

 

ReSharper provides an improved way to navigate usage of method, or class:

 

Please note that ReSharper is able to navigate usages in comments! It is also able to rename into comments. So if you rename a class, you can ask ReSharper to rename the name of the class when it is used in comments!

Other example: ReSharper gives you hints to clean your code (more than hints: it is able to do the work for you):

 

 

Improved Intellisence, with here an example of highlighting obsolete methods:

  

A last example: when a reference is missing, ReSharper highlights it for you and gives you the option to add the missing reference. Well Visual Studio does it too. But ReSharper does it a more visible and accessible way that the very little underscore you need to click with Visual Studio:

 

To conclude I was really convinced by the tool which was of great help for my refactoring phase! And I am discovering more and more functionalities every day…

Golden Rule #2: Don’t be afraid of refactoring!

Here I am, back after more than a month publishing the first golden rule. I said to myself today that I should keep up to speed with this subject in order to finally end-up with a good number of rules as I find the exercise interesting and opening great paths for thinking and reflecting on limited but compelling subjects.

So the Golden Rule #2 is about refactoring code and software architectures. One may wonder: "Why are you talking about continuous refactoring as a Golden rule??!! After all if you follow development best practices and apply all golden rules, aren't you then expecting that the design and code produced are of good quality, therefore not requiring refactoring?!"

Introduction - what is all the fuzz around refactoring?

Refactoring is often associated to "repairing" legacy code or poorly designed applications. Even though it is sometimes what refactoring is used for, refactoring is also first class citizen of a full agile process of developing high quality applications. I would even go one step further: if a reasonable sized project is achieved with no refactoring phase during its implementation, then there is probably something wrong and a flawed underlying design that will bring you trouble on the path ahead.

Software development is a complex discipline, and the vast number of patterns, tools, frameworks and best practices leads to numerous ways for implementing one scenario. It is all about pros and cons, compromises, and identifying the potential future points of evolutions of the business need in order to be ready for it. 

Even though it is always recommended to do a design first and coding later, I don't believe one could or should do a fully detailed design before writing the first line of code. The key winning idea is to be pragmatic, agile and iterative. Any design should be validated by proper implementation and validation, to then be adapted, enhanced and implemented again. There is a limit to paper diagrams and even experienced designers cannot fully predict the behaviour of the future implementation of there designs in terms of performance, security, usability and fitting in the target infrastructure, nor can predict that the frameworks and techniques that they theoretically plan on using will actually be relevant perform/provide a service as excepted; one exception is if they already designed and developed a very similar application, following very similar constraints and non-functional requirements, and targeted to a very similar platform. Added to these technical only aspects, business needs can also evolve, during the lifecycle of the project, get re-scoped and adapted and therefore require changes in the application technical design. The consequence of this is that refactoring phases will be mandatory to iteratively build the software solution.

 

Another point is that a successful software architecture and design is the result of a collaborative work between several people, architects, analysts, and developers. So, all participants should be involved in the process as soon as possible thus requiring starting the development phase early for efficient and productive feedback from the development side ASAP. As a consequence, refactoring phases will have to be planed and performed until reaching an acceptable quality level.

So why do you need refactoring?

Including refactoring phases in your development process and lifecycle answers to the following needs:

• You need to make sure that your software design and architecture properly address evolving business needs: Refactoring phases can be necessary if a major business evolution requires rethinking of part of the design of the application. The application should always be designed with flexibility in mind and requires that aspects of potential evolutions are properly identified to know where to design and build flexibility.

• In an agile process, refactoring is an essential technique to iteratively build the most appropriate software architecture and design, while gaining in maturity iteration by iteration. This is a key for agile development where functional slices of the application are frequently delivered and most of the times require partial refactoring to move from one iteration to the other and increase quality and relevance of the design.

• Late discovery of functional or technical constraints can lead to the need for a partial refactoring of the application to address this unexpected event. By the way, an agile, highly iterative process can help reducing the risk by early addressing all the aspects of the application, and especially the aspects that are considered high risk.

• Results of test campaigns can reveals areas that need refactoring, for either technical reasons (poor performance, low scalability, etc.) or functional reasons (inappropriate functional behaviour revealed by the UAT that has an impact on technical design). Again: and agile iterative process will help address early these issues.

Rigorously including refactoring phases in your development process will therefore help you increase the quality and relevance of the overall application design, making the application more maintainable, robust and flexible. Moreover, being able to regularly and efficiently perform refactoring sessions without breaking the whole application and entering uncontrolled regression phases will be the undisputable proof that your software design is effectively of high standard.

 

Can I include refactoring in my development process seamlessly and for free?

Ok, refactoring is not a simple thing and it is definitively not a painless, safe action to perform if you are not prepared for it.

First condition to include regular refactoring phases as part of your development process is to actually have a well designed and architected application. And refactoring becomes a way to iteratively increase the quality of this design. But you can't apply proper refactoring as part of the development process for commando like or any other kind of quick and dirty type of programming.

Second condition is that you should have a proper set of unit tests covering your full code base. Refactoring is about rewriting and restructuring code thus meaning creation of new bugs. And you don't want to break what was working before. Therefore a set of unit test with high code coverage will help you (yet not always suffice) verify the quality of the refactored code and make corrections if required. Important refactoring will also require the re-writing of the unit tests, which is ok: just make sure that your new set of unit tests still covers the same functional use cases.

Refactoring can be painful if you don't have the proper tooling to assist you and automate repetitive operations. And the pain can be even worth if you need to refactor across several projects. Visual Studio includes basic refactoring tools that are really useful and a big step forward since version 2005. But you can go even a step further and use commercial refactoring tools. The one I use (and love!) is ReSharper, and you can read my post about it for more details.

Another thing you need is a refactoring compliant source code control system that allows you to seamlessly move and rename files while keeping the integrity of source code repository and version history. And I haven't found such a tool yet. To be honest I haven't tried too many tools as I am quite happy with the Microsoft Team Foundation Server package for building a full continuous integration environment. Unfortunately, TFS does not quite like renaming and moving files and can act weird when you try to do so. For large refactoring, the solution is to start on a new, clean TFS project that is built on the new file structure implied by your refactoring. You still keep the full version history though the previous TFS project but lose the connection with your new project. Another advice to limit the issues you can have with your source control while refactoring is the following: try to avoid to a too deep hierarchy of projects, trying to mirror the namespace tree. Just save your projects on a flat, or as flat as possible, file structure. You still can have a hierarchical view in Visual Studio by creating solution folders. This way, it will dramatically make moving or reorganising namespaces much easier! Don't forget that reorganisation namespace is one of the most common thing you will do while refactoring...

Last point to mention is that it will be useful to have an automated process for updating documentation. Refactoring implies changes in the documentation and documentation is not a good candidate for manual update because it will then never be updated. Solution for the documentation is the use of tools that automatically reflect on the code comments to generate the detailed documentation. So rule is: comment properly your code and run a tool on your code base. The tool I use is Sandcastle. And for more high level class diagrams, you can choose a UML tool that can reverse code-engineer UML diagrams from you code. Visual Studio embeds one very basic tool. I personally use Enterprise Architect that I will describe in a future post. Key element is that you should be able to automatically update the technical documentation if you want to have technical documentation at all!

 

So am I ready to go?

You must be aware that refactoring cycles are time consuming, require courage and patience for the extra effort induced. It therefore requires discipline and a well accepted and applied process that includes these "technical" refactoring phases, apparently not bringing any additional features or business value, but really mandatory in the medium to long term for creating a robust and flexible applications. Therefore the sole idea of technical refactoring being part of the software application development lifecycle is something that needs to be strongly supported by the project management board, and more importantly: really applied during the project lifetime. And this is probably the most difficult part as management teams can have difficulties understanding the need of spending a lot of time, effort and money for something that apparently (but apparently only) does not bring any added value to their business application. And this difficulty can be caused by a lack of understanding of both parties and a low trust given to others.

This leads us to another Golden rule on which I will write later. This Golden rule is not really a development golden rule but a more high level, project level, strategic golden rule: go for collaborative and responsibility driven team organisation rather than for a hierarchic centric organisation. This rule says the following: to make a project successful (be it a software project or any kind of project BTW), you should build a team with well defined responsibilities and skills and trust everyone in the team for his/her competencies and believe and take into consideration the well-founded of their advice. This is the best and more human way IMHO to have a real success on your projects and long term involvement and efficiency of your overall project team. But more on this later, so keep connected to the Golden rules series!!

Introducing my favorite ORM tool: Llblgen

In a previous post I introduced the concept of ORM tools and their high importance in software development projects. Today I want to talk quickly about my favourite ORM tool: LlblgenPro, and explain why it has been one of the best tool I have had the chance to use for quite a long time.

 

Have you ever been really amazed by reading the marketing material for a product and think: hey this is what I need! Looks like it's doing everything I want/need plus even more things I would not have thought of first, let's get it!

You would then go and download the trial, with the grand hope that you will be simply satisfied, and not once more disappointed by an advertising façade, selling why the product is the best of the world.

So here you are, trial downloaded, and first eliminatory test is how easy or hard the product is to install and first use. Once the first, supposed easy test is pass, then you start using the product. If you are lucky, the first tries are satisfactory and you still find the product very attractive and are ready to go and celebrate this with your friends. If you are really that lucky and don't live in the real world, you never discover any problem with your newly purchase product and live happily ever after.

However sad but true, more common scenario is that you discover one by one, sooner or later, the flaws and problems and bugs that goes with the product. And interestingly or not, this was not sold on the advert. But the thing is that it comes in a bundle: you get the great stuff and the bugs and problems all in one for the same price, how great is that?!

Unfortunately this happens quite a lot, it is very common to have to make compromises and use a tool because it has great features and you need it, accepting all the bugs, design and functional flaws, perhaps lack of flexibility that come with it. Well you still can contact this great support team: they say that they are available to solve your problems, so wanna call them? Ok right: one doesn't loose anything to try, except perhaps patience and hair…

Ok all is not so bad. You have products to absolutely avoid, and products that are better and being a pleasure to use despite of some drawbacks. And you have few tools that are absolutely phenomenal, and Llblgen Pro is IMHO one of these.

I have already used Llblgen Pro on several big size projects for several of my clients. For information I am always using the adapter flavour of the templates and runtime as I am working on large distributed tiered-architectures and need the disconnected pattern for communicating between tiers, throw web services.

So I must say I keep enjoying the fact that I really love this product, and cannot find anything significant to complain about, which is very uncommon. And Frans, where are the bugs? Pretty very well hidden I must say, was looking for them but apparently didn't get any luck: I find the generated code and runtime extremely stable and robust.

Ok what else can I say? Well, installing the product is very easy and nothing to report, using the designer is pretty straightforward too, and using the generated code made very easy too: the generated projects are including all the proper references, are compiling perfectly fine, and you then just need to reference the generated project and runtime support libraries to be ready to map to your relational data in a full object oriented way.

Even more important: re-generating your projects after changes to the database, on existing entities or creating new one is extremely stable and pain-free too. May you add items to your projects, add your custom code, all is re-generated taking very good care of the work you have done before.

Ok you will tell me that changing the database has impacts on all your code, not just you data access and business entities layers. Well, ok, but don't forget we live in a full strongly typed object oriented code now. So may you have broken your code after update of the database and regeneration of the business entities layer, well, you will know it at compilation time and fix it very quickly!

Another very important point for me is the quality of the generated code and of the runtime source code. For such a technical tool one expect very high quality of the code base, and you get it with Lllblgen. When using the generated code or runtime libraries, you never get the impression of a poor design or dirty kind of object oriented, having design inconsistency or suspicious quality issues. No, this is only great clean object oriented code, handsomely designed, I just LOVE IT

What else can I say? Well the development efforts are pretty well sustain in that Llblgen Pro keeps constantly up to date with the newest versions of Microsoft .NET framework when they get shipped. And much better than this I must say: Llblgen Pro really makes the most of new features of the .NET Framework very fast. Example is the very early support of Link (though Link to Llblgen) and Dynamic Data.

Another point is the extra features that are provided out of the box for you, for free. Examples are support for auditing, and security (authorizations). So you have access to points of extensibility for your application just by using the tool. Let's see what new exciting features we get in the future.

What else? Oh yes, support. Llblgen Pro has got the most amazing support service through its forums. You get answers extremely fast to your problems and issues and bug fixes integrated quite fast in subsequent releases. And it is working, they really are there to help you, it is not only sugar to make you buy the product!

I see one bad thing though about the tool…. And it is its name!! Just still haven't really managed to adopt it J Well who cares would you tell me?

Just one thing to be aware of: I am telling a lot of great thing about Llblgen Pro, just be aware that you will have to go through a learning curve before smoothly master the framework. However it is the same with any framework and believe me: it really is worth it. And with the addition of Link to Llblgen, developers knowing Link will have their opportunity to leverage their knowledge and shorten the time needed to master the tool.

Ok enough for now, you can just go to their website to get more information on the tool. And I will write more posts on scenarios in which I am using Llblgen Pro. So go, and try it! And NO, I don't have any shares on the product, just like to tell when there is a tool that deserve attention. And I will dedicate a section in this blog, dedicated to registering interesting and useful tools and framework, as it is one part of the whole "Building Business Oriented Software Solutions" concept.

You can also read my post about Object Relational Mapping (ORM) overview