In this post I dealt with a  simple extension function to flatten a tree and in one of the comment Robert shared an interesting link that deal with the creation of a wrapper structure to use LINQ style function on tree structure. That article is really interesting, but the adopted solution requires to create a wrapper for every structure you need to iterate into and I decided to spend a couple of minutes to verify how difficult is writing a generic solution.

Thanks to Func<T> is quite easy to write a wrapper that does not relay on code generation to wrap a specific tree type.

   1: public class TreeWrapper<T> where T : class 

   2:  {

   3:      private readonly T _node;

   4:      private readonly Func<T, IEnumerable<T>> _getChildernFunc;

   5:      private readonly Func<T, T> _getParentFunc;

   6:  

   7:      public TreeWrapper(

   8:          T node,  

   9:          Func<T, IEnumerable<T>> getChildernFunc,

  10:          Func<T, T> getParentFunc)

  11:      {

  12:          _node = node;

  13:          _getChildernFunc = getChildernFunc;

  14:          _getParentFunc = getParentFunc;

  15:      }

As you can see I created a wrapper that takes a node, and a couple of functions, one to find all child of the element, and the other to find the parent of the node. With this simple wrapper writing a Descendants() function is supereasy.

   1: public IEnumerable<T> Descendants()

   2:  {

   3:      return Descendants(_getChildernFunc(_node));

   4:  }

   5:  

   6:  private IEnumerable<T> Descendants(IEnumerable<T> elements)

   7:  {

   8:      return elements.Concat(

   9:          elements.SelectMany(e => Descendants(_getChildernFunc(e))));

  10:  }

Et voilà, this simple method makes this test pass.

   1: [Test]

   2: public void VerifyGenericTreeNodeDescendants()

   3: {

   4:     GenericTreeNode r1 = new GenericTreeNode(1,

   5:             new GenericTreeNode(2,

   6:                         new GenericTreeNode(4)),

   7:             new GenericTreeNode(3),

   8:             new GenericTreeNode(5,

   9:                new GenericTreeNode(6), new GenericTreeNode(7)));

  10:  

  11:     var w = TreeWrapper.Create(r1, n => n.GenericTreeNodes, n => n.Parent);

  12:     w.Descendants().Select(e => e.Id)

  13:         .Should().Have.SameSequenceAs(new int[] {2, 3, 5, 4, 6, 7});

  14: }

The GenericTreeNode class is used only for testing purpose and is a simple class that maintains a reference to parent and a collection of childs. The ancestors function is even simplier.

   1: public IEnumerable<T> Ancestors()

   2: {

   3:     T parent = _getParentFunc(_node);

   4:     while (parent != null)

   5:     {

   6:         yield return parent;

   7:         parent = _getParentFunc(parent);

   8:     }

   9: }

Simply iterate to all parents until the parent is null (reached the root node), but we can still add more interesting methods.

   1: public IEnumerable<T> ElementBeforeSelf()

   2: {

   3:     T parent = _getParentFunc(_node);

   4:     if (parent != null)

   5:     {

   6:         return _getChildernFunc(parent)

   7:             .TakeWhile(e => e != _node);

   8:     }

   9:     return new T[] {};

  10: }

  11:  

  12: public IEnumerable<T> ElementAfterSelf()

  13: {

  14:     T parent = _getParentFunc(_node);

  15:     if (parent != null)

  16:     {

  17:         return _getChildernFunc(parent)

  18:             .SkipWhile(e => e != _node)

  19:             .Skip(1);

  20:     }

  21:     return new T[] { };

  22: }

ElementsBeforeSelft() and ElementsAfterSelf() return all sibling elements (node at same level) before and after the current node element, this makes this test pass.

   1: [Test]

   2: public void VerifyGenericTreeElementBeforeSelf()

   3: {

   4:     GenericTreeNode node;

   5:    new GenericTreeNode(1,

   6:                 new GenericTreeNode(2,

   7:                             new GenericTreeNode(4)),

   8:                 new GenericTreeNode(3),

   9:                 node = new GenericTreeNode(5,

  10:                     new GenericTreeNode(6), new GenericTreeNode(7)),

  11:                  new GenericTreeNode(8),

  12:                  new GenericTreeNode(9));

  13:  

  14:    var w = TreeWrapper.Create(node, n => n.GenericTreeNodes, n => n.Parent);

  15:     w.ElementBeforeSelf().Select(e => e.Id)

  16:         .Should().Have.SameSequenceAs(new int[] { 2, 3 });

  17:  

  18:     w.ElementAfterSelf().Select(e => e.Id)

  19:         .Should().Have.SameSequenceAs(new int[] { 8, 9 });

  20: }

The only disadvantage of this technique, is that I’m not able to write something like this.

   1: w.Descendants().Single(e => e.Id == 5)

   2:     .ElementBeforeSelf().Select(e => e.Id)

   3:     .Should().Have.SameSequenceAs(new int[] { 2, 3 });

This query simple select a single element and then iterates on all the element before self, but it does not compile, because the Descendants() method returns an IEnumerable<T> (T is the wrapped object) and not a IEnumerable<TreeWrapper<T>>. You could modify the Descendants() function to wrap each returned element, but this is not optimal, so I prefer a simply extension method to rewrap an element, that permits me to write this test.

   1: w.Descendants().Single(e => e.Id == 5)

   2:     .TreeWrap(n => n.GenericTreeNodes, n => n.Parent)

   3:     .ElementBeforeSelf().Select(e => e.Id)

   4:     .Should().Have.SameSequenceAs(new int[] { 2, 3 });

This syntax is not bad, the Single LINQ operator permits me to iterate in all Descendants node of the wrapped node, then I need to rewrap again the result to use the ElementBeforeSelf method to use again a function of the TreeWrapper class.

Alk.

If you ever tried to implement a linq provider, you know that this is not a simple task. This is true for a full linq provider, but sometimes we need only a basic support, and in these situations there is probably a simpler approach.

Suppose you need to give LINQ support to find user in Active Directory via LDAP, you need to make query for the various properties of the User object, and you need also to make change to some of these properties and propagate those changes back in the AD. Sounds complicated? Maybe not.

Look at this class.

public class ADUser
{
    System.DirectoryServices.DirectoryEntry userDirEntry = null;
    private DirectoryEntry root;
    public ADUser(DirectoryEntry userDirEntry, DirectoryEntry root)
    {
        this.root = root;
        this.userDirEntry = userDirEntry;
    }

    public String Description
    {
        get { return (String)userDirEntry.Properties["description"].Value; }
        set { userDirEntry.Properties["description"].Value = value; }
    }

    public String UserName
    {
        get { return (String)userDirEntry.Properties["samaccountname"].Value; }

    }

    public void Update()
    {
        userDirEntry.CommitChanges();
    }

    public ADGroupCollection Groups { get; private set; }
}

As you can see, this is a simple object that wraps a DirectoryEntry related to an ActiveDirectory user, it wraps only Name and Description, but it can be updated to support all user properties. Now I create another simply class.

public class ADUsers : IEnumerable<ADUser>
{
    private IList<ADUser> Users;
    System.DirectoryServices.DirectoryEntry root = null;
    public ADUsers(System.DirectoryServices.DirectoryEntry root)
    {
        this.root = root;
        Users = new List<ADUser>();
        DirectorySearcher search = new DirectorySearcher(root);
        search.Filter = "(&(objectClass=user)(objectCategory=person))";
        search.PropertiesToLoad.Add("cn");
        SearchResultCollection results = search.FindAll();
        foreach (SearchResult result in results)
        {
            var de = result.GetDirectoryEntry();
            Users.Add(new ADUser(de, root));
        }
    }
    public IEnumerator<ADUser> GetEnumerator()
    {
        return Users.GetEnumerator();
    }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

This is a real simple classes, it accepts a DirectoryEntry root used to query the Ldap, then it retrieves all the users object with a simple LDap query issued by DirectorySearcher object, for each result, it builds a wrapper ADuser. Now that we have these two simple classes we can write.

Since I loaded in memory a wrapper for each object, I can issue LINQ queries against the AdUsers, because I can rely on the support of Linq 2 Object, simply making AdUsers implementing IEnumerable. Since everything is in memory we can issue condition like u.UserName.Contains(“amp”) or whatever you like.

Surely this is not the optimal solution, but is quick and works well. The main drawback is that all Users needs to be loaded into memory, so we are using more resources respect a full LINQ provider, that can analyze the expression and retrieve only users that satisfies the query. But since we are not expecting Thousands of users, this can be a viable KISS solution.

This simple example shows that, to support LINQ for some source, sometimes there is no reason to pass for the full IQueryable<T>.

Alk.

Tags: LINQ

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

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

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

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

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

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

static Assembler() {

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

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

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

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

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

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

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

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

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

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

static Assembler() {

    ExpressionSelector = ...
    ParseSelector();
}

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

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

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

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

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

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

alk.

Tags: T4 Generator Expression Tree LINQ

I have a little validation library that must support localized error messages, it uses a simple techniques, when you set an error message for a specific validator, if you do not want localization you can simply pass a single string, but if you want message to be localized, you specified two strings, one is the name of the resource that contains the message and the other is the key of the message.

All this logic is inserted into a class called ErrorMessage that was created at the time of .NET 2.0; here is a typical test

[Test]
public void TestLocalizationIt()
{
    ErrorMessage sut =
        new ErrorMessage("Test", "DotNetMarche.Validator.Tests.ResourcesFiles.TestRes, DotNetMarche.Validator.Tests");
    Assert.That(sut.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("It-It")), Is.EqualTo("Questa è una stringa di test"));
}

This is far from being usable, because the needs to specify the full name of the resource file that contains resources is not usable. The user can mistype the Resource File name and introduce errors that will be discovered only at runtime,  and only when an object does not pass validation. At that time it was acceptable, we included all error messages into a resource file, then Store the name of the resource file into a constant and all went good.

Now with Expression tree we can obtain more. First of all notice that when you include a .resx file into a solution visual studio creates for you a code behind file to easy the usage of resources.

[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
internal class TestRes {

    private static global::System.Resources.ResourceManager resourceMan;

    private static global::System.Globalization.CultureInfo resourceCulture;

    [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
    internal TestRes() {
    }

    /// <summary>
    ///   Returns the cached ResourceManager instance used by this class.
    /// </summary>
    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
    internal static global::System.Resources.ResourceManager ResourceManager {
        get {
            if (object.ReferenceEquals(resourceMan, null)) {
                global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("DotNetMarche.Validator.Tests.ResourcesFiles.TestRes", typeof(TestRes).Assembly);
                resourceMan = temp;
            }
            return resourceMan;
        }
    }

You can see that this object has an internal property called ResouceManager that is static and contains the resource manager used to access resource file. Now the goal is to make this syntax possible.

[Test]
public void TestLocalizationItFullFluentExplicitCulture()
{
    ErrorMessage sut = new ErrorMessage(() => TestRes.Test);
    Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CreateSpecificCulture("En-Us");
    Assert.That(sut.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("It")), Is.EqualTo("Questa è una stringa di test"));
}

This test create the ErrorMessage object with a lambda, now you can have full intellisense and you cannot mistype anything, in the test I set the currentUICulture to En-us and call ToString() of the ErrorMessage asking for Italian culture, to verify that I can really specify culture different from the CurrentUICulture.

The constructor that permits me to obtain this is the following.

/// <summary>
/// Basic Constructor
/// </summary>
public ErrorMessage(Expression<Func<String>> messageLambda)
{
    MemberExpression me = messageLambda.Body as MemberExpression;
    Type t = me.Member.DeclaringType;
    //now I know that this type is one generated by the visual studio
    PropertyInfo pinfo = t.GetProperty("ResourceManager", BindingFlags.Static | BindingFlags.NonPublic);
    mMessage = me.Member.Name;
    mResourceTypeName = t.FullName;
    lock (mResMangaers)
    {
        if (!mResMangaers.ContainsKey(t.FullName))
        {
            mResMangaers.Add(t.FullName, pinfo.GetValue(null, null));
        }

    }
}

My object was designed to store all resource managers into a static hashtable, to minimize memory usage, so I simply declare this constructor that accepts an Expression<Func<String>>, then I know that I have a MemberExpression, because the user specify one of the autogenerated properties of the .resx file, then with a little bit of reflection I grab the ResourceManager and the game is done.

With Expression tree you can quite always avoid the need for the user of you library to specify object by name if you need to use reflection.

alk.

For those used to ORM like NHibernate, the approach to Entity Framework is quite simple, but I’ve noticed that for people that never heard of ORM in general, EF tends to create some confusion.

I see people that make confusion between LINQ and EF, LINQ is the Language Integrated Query, it can be used to query objects in memory, XML, NHibernate and of course EF, but is not the only way to query EF. A less known method to execute query against a EF context is EntitySql, here is an example.

using (NorthwindEntities context = new NorthwindEntities())
{
    ObjectQuery query = context.CreateQuery<Customers>("Select value C from Customers as C");
    var res = query.Execute(MergeOption.NoTracking) as IEnumerable<Customers>;
    foreach (Customers c in res)
    {
        Console.WriteLine(c.CustomerID + " City:" + c.City);
    }
    Console.ReadKey();
}

working with EntitySql is simple because it resembles quite well the SQL syntax we are used to. Querying with LINQ is simple too, but can surprise the novice user, suppose you write the following code

//Sample1();
using (NorthwindEntities context = new NorthwindEntities())
{
    var result = from Customers c in context.Customers
                 select c;
}

the question is "what is the query that gets executed to the database?". The answer is "NONE". The reason is "deferred execution" of linq query, the above code does only define a query, it returns an object that represent the query, but actually it does not execute any SQL to the server. Now let’s look at this other piece of code

//Sample1();
using (NorthwindEntities context = new NorthwindEntities())
{
    var query = from Customers c in context.Customers
                select c;
    Console.WriteLine("Count is {0}", query.Count());
    Console.WriteLine("Count is {0}", query.Count());
    Console.WriteLine("Count is {0}", query.Count());
}

This code actually executes three SQL query, since Count() is not a deferred operator, to know the result the query object needs to execute SQL against the datasource. This means that this code

1 using (NorthwindEntities context = new NorthwindEntities())
2 {
3     var query = from Customers c in context.Customers
4                 select c;
5     query.GetEnumerator();
6     query.GetEnumerator();
7     query.GetEnumerator();
8 }

execute three selects on the server. This behavior can surprise users that are not used to EF, someone believe that the real data is executed in line 3 and not at the time of the iteration, and they gets surprised when they see a SQL query issued to the database for each enumeration. The fact that the query is deferred can surprise but can be useful too. Let’s look at the following code.

using (NorthwindEntities context = new NorthwindEntities())
{
    var query = from Customers c in context.Customers
                where c.ContactName.Contains("d")
                orderby c.City
                select c;
    foreach (Customers c in query.Where(cst => cst.CustomerID.StartsWith("a")))
    {
        Console.WriteLine(c.CustomerID + " City:" + c.City);
    }
    foreach (Customers c in query.Where(cst => cst.CustomerID.StartsWith("r")))
    {
        Console.WriteLine(c.CustomerID + " City:" + c.City);
    }
}

since the query object build at the beginning is only a "query object" I can use to make subsequent queries based on the original value, in this example the query object create a constraint on the contact name and an order by City. From this base query I actually execute ii two time into two distinct enumeration, adding some more criteria each time, this is possible because all the Queryobject are composable because they support LINQ. Another important fact is that you cannot iterate the result of a query outside the scope of the context.

IQueryable<Customers> query;
using (NorthwindEntities context = new NorthwindEntities())
{
    query = (from Customers c in context.Customers select c);
}
foreach (Customers c in query)
{
    Console.WriteLine(c.CustomerID + " City:" + c.City);
}

This code is wrong and it raise the exception "The ObjectContext instance has been disposed and can no longer be used for operations that require a connection." If the actual query gets executed at each iteration, when you iterate outside the context that creates the query, the underling SqlConnection is disposed and EF cannot issue query anymore. The obvious solution is to use a not deferred operator like ToList() to actually create a list of object that gets disconnected when the context is disposed, but they can be accessed without problem.

1 IList<Customers> query;
2 using (NorthwindEntities context = new NorthwindEntities())
3 {
4     query = (from Customers c in context.Customers select c).ToList();
5 }
6 foreach (Customers c in query)
7 {
8     Console.WriteLine(c.CustomerID + " City:" + c.City);
9 }

The only difference is that in line 4 I used ToList() to actually execute the query and store the result in a list in memory, so it can be accessed even when the context is disposed.

alk.

Tags: EntityFramework LINQ

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

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

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

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

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

private Func<T, Boolean> filterPredicate;

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

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

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

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

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

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

Alk.

Tags: BindingList IBindingView Dynamic Expression Parser

Some time ago I read this post that speaks about dynamic query library. I downloaded the code sample, it is interesting, but is bound to Linq to Sql, now I need an implementation of a Dynamic Linq Query generator. Since I already worked in the past with expression parser and I have some generic Infix to postfix converter in a three hours of work I was able to put everything in a project and now I can write

Func<Customer, Boolean> f = DynamicLinq.ParseToFunction<Customer, Boolean>("Name == 'Gian Maria'");
Assert.That(f(aCustomer), Is.True);

This example shows that I can build a simple function that accepts an entity (Customer) and a string representing some conditions, then I’m able to dynamically parse the string, create an expression tree and call Compile on it to obtain a function that I can use in code. As soon as possible I’ll show a complete example if you are interested in.

alk.

Tags: LINQ Dynamic Expression Generation