Un'altro interessante metodo della classe System.Query.QueryExpression (presente nell'assembly System.Query.dll della preview di LINQ) è Parse: riceve in input una espressione (e gli eventuali argomenti) sotto forma di stringa e restituisce in output un oggetto Expression, ovvero una rappresentazione ad oggetti della stessa. Si consideri il seguente codice:

using System;
using System.Collections.Generic;
using System.Text;
using System.Query;
using System.Expressions;

class ExpressionBuilder
{
   private Expression expression;
   private ParameterExpression[] parameters;

   public ExpressionBuilder(string expression, params ParameterExpression[] parameters)
   {
      this.parameters = parameters;
      if (parameters == null || parameters.Length == 0)
      {
         this.expression = QueryExpression.Parse(expression);
         return;
      }

      Dictionary<string, Expression> scope = new Dictionary<string, Expression>();
      foreach (ParameterExpression parameter in parameters)
      {
         ParameterExpression tmp = Expression.Parameter(parameter.Type, parameter.Name);
         scope.Add(tmp.Name, tmp);
      }

      this.expression = QueryExpression.Parse(expression, scope); // Parsing!
   }

   public override string ToString()
   {
      StringBuilder sb = new StringBuilder();
      expression.BuildString(sb);
      return sb.ToString();
   }
}

La classe ExpressionBuilder è un semplice wrapper su alcune funzionalità di QueryExpression. Data la classe precedente è quindi possibile scrivere cose del tipo:

ExpressionBuilder expr = new ExpressionBuilder(
   "(x + y) * 2",
   new ParameterExpression[]
   {
       Expression.Parameter(typeof(int), "x")
      ,Expression.Parameter(typeof(int), "y")
   }
);

Console.WriteLine(expr);  // Multiply(Add(x, y), 2)