Linq has been shipped with VS2008/.Net 3.5 and is not really new. If more and more people are getting used to its syntax, it’s sometimes hard to imagine all the scenarii where Linq to object can replace the classical way we program. During some Silverlight coding, I changed my code to make it run in a better Linq spirit and I wanted to share with you this little sample.

Silverlight (and WPF) maintains a tree of visuals. A useful class named VisualTreeHelper provides a very simple api to navigate this tree. One very common scenario is to look for the first visual parent of a T type for a given control. For instance, your control is in a template and you want to retrieve the templated control which you know is a ListBoxItem.

The VisualTreeHelper.GetParent() method (see prototype below) simply gives the graphical parent of any visual (as DependencyObject).

public static class VisualTreeHelper
{
    //
    // Summary:
    //     Returns an object's parent object in the visual tree.
    //
    // Parameters:
    //   reference:
    //     The object to get the parent object for.
    //
    // Returns:
    //     The parent object of the reference object in the visual tree.
    //
    // Exceptions:
    //   System.InvalidOperationException:
    //     reference is null, or is not a valid System.Windows.UIElement.
    public static DependencyObject GetParent(DependencyObject reference);
    ...
}

Let’s try to implement this simple scenario.

public static class MyDependencyObjectExtensions
{
    public static T GetVisualParent<T>(this DependencyObject source) 
        where T : class
    {
        do
        {
            source = VisualTreeHelper.GetParent(source);
        } while (!(source is T) && (source != null));
        return source as T;
    }
}

var lbi = button1.GetVisualParent<ListBoxItem>();

In a first step we will just try to retrieve the list of parents :

public static class MyDependencyObjectExtensions
{
    public static IEnumerable<DependencyObject>
        GetVisualParents(this DependencyObject source)
    {
        while (true)
        {
            source = VisualTreeHelper.GetParent(source);
            if (source != null)
                yield return source;
            else
                yield break;
        }
    }
}

public static class MyDependencyObjectExtensions
{
    public static IEnumerable<DependencyObject>
        GetVisualParents(this DependencyObject source)
    {
        while (true)
        {
            source = VisualTreeHelper.GetParent(source);
            if (source != null)
                yield return source;
            else
                yield break;
        }
    }
    public static T GetVisualParent<T>(this DependencyObject source)
        where T : class
    {
        return source.GetVisualParent<T>(0);
    }
    public static T GetVisualParent<T>(this DependencyObject source, int level)
        where T : class
    {
        return source.GetVisualParents().OfType<T>().Skip(level).FirstOrDefault();
    }
}

Last effort, let’s try to imagine a generic way to create enumerables from functional parts.

In our case we have :

• the starting value
• the way we get the next value
• the exit condition

public static class EnumerableHelper
{
    public static IEnumerable<T> Create<T>(T startElement,
        Func<T, T> nextElementProvider, Predicate<T> exitCondition)
    {
        while (true)
        {
            startElement = nextElementProvider(startElement);
            if (!exitCondition(startElement))
                yield return startElement;
            else
                yield break;
        }
    }
    public static IEnumerable<T> Create<T>(T startElement,
        Func<T, T> nextElementProvider)
    {
        return Create(startElement, nextElementProvider, e => e == null);
    }
}

var parents = EnumerableHelper.Create(
    button1 as DependencyObject,
    d => VisualTreeHelper.GetParent(d));

var lbi = parents.OfType<ListBoxItem>().FirstOrDefault(); 

.Net 4.0 expression API also brings new instructions such as Loop, Goto, Label, IfThenElse, etc.

We will add them with always the same process: adding a comprehensive method in the Block class and implement the appropriate transformation in the visitor.

First, here is the Block class with all our meta language dictionary. I have never written so many methods without implementing them ! :)

public class Block
{
  //prevents the use of the default public
  //constructor
  //so we hare sure that the only way to get 
  //Block instances is to use Block.Start()
  private Block()
  {
  }
  
  public static Block Start<T>(T locals,
    Action<T> block)
  {
    throw new NotImplementedException();
  }
  
  public static R Start<T, R>(T locals,
    Func<T, R> block)
  {
    throw new NotImplementedException();
  }
  
  public static Block Default 
    { get; private set; }
  
  public Block _(Action action)
  {
    throw new NotImplementedException();
  }
  
  public Block Assign<T>(Func<T> leftExpression, 
    T rightExpression)
  {
    throw new NotImplementedException();
  }
  
  public Block Loop(Action block)
  {
    throw new NotImplementedException();
  }
  
  public Block IfThen(bool testExpression, 
    Action thenBlock)
  {
    throw new NotImplementedException();
  }
  
  public Block IfThenElse(bool testExpression, 
    Action thenBlock, Action elseBlock)
  {
    throw new NotImplementedException();
  }
  
  public Block While(bool testExpression,
    Action block)
  {
    throw new NotImplementedException();
  }
  
  public Block For(int from, Predicate<int> 
    condition, Action<int> block)
  {
    throw new NotImplementedException();
  }
  
  public Block Label(string name)
  {
    throw new NotImplementedException();
  }
  
  public Block Goto(string name)
  {
    throw new NotImplementedException();
  }
}

private Expression VisitBlockMethodCall(MethodCallExpression node)
{
  if (IsMethodOf<Block>(node, "Label"))
  {
    string labelName = 
      (string)(node.Arguments[0] as
        ConstantExpression).Value;
    return Expression.Label(
      GetLabelTarget(labelName));
  }
    
  if (IsMethodOf<Block>(node, "IfThen"))
    return 
      Expression.IfThen(
        Visit(node.Arguments[0]),
        Visit((node.Arguments[1] as 
          LambdaExpression).Body));
    
  if (IsMethodOf<Block>(node, "IfThenElse"))
    return 
      Expression.IfThenElse(
        Visit(node.Arguments[0]), 
        Visit((node.Arguments[1] as
          LambdaExpression).Body),
            Visit((node.Arguments[2] as 
        LambdaExpression).Body));

  if (IsMethodOf<Block>(node, "Goto"))
    {
      string labelName = 
        (string)(node.Arguments[0] as 
          ConstantExpression).Value;
      return Expression.Goto(
        GetLabelTarget(labelName));
    }

  if (IsMethodOf<Block>(node, "Loop"))
    {
      var result = (node.Arguments[0] as 
        LambdaExpression).Body;
      return Expression.Loop(Visit(result));
    }

  if (IsMethodOf<Block>(node, "While"))
    {
      var exitLabel = Expression.Label();

      var block =
        Expression.Block(
          new Expression[] {
            Expression.Loop(
              Expression.Block(
                new Expression[] {
                  Expression.IfThen(
                    Expression.Not(
                Visit(node.Arguments[0])),
                    Expression.Goto(exitLabel)),
                    Visit((node.Arguments[1] 
                as LambdaExpression).Body)
                })),
            Expression.Label(exitLabel)
          });
        return block;
    }
  if (IsMethodOf<Block>(node, "For"))
    {
      var l = node.Arguments[2]
        as LambdaExpression;
      var i = l.Parameters[0];
      var test = node.Arguments[1] 
        as LambdaExpression;
      var exitLabel = Expression.Label();
      
      var block =
        Expression.Block(
          new ParameterExpression[] { i },
          new Expression[] {
            Expression.Assign(i,
              Visit(node.Arguments[0])),
            Expression.Loop(
              Expression.Block(
                new Expression[] {
                  Expression.IfThen(
                    VisitWithReplaceParameter(
                      test.Parameters[0], i,
                      Expression.Not(test.Body)), 
                  Expression.Goto(exitLabel)),
                  VisitWithReplaceParameter(
                    l.Parameters[0], i, l.Body),
                  Expression.Assign(i,
                    Expression.Add(i,
                      Expression.Constant(1)))
                })),
              Expression.Label(exitLabel)
            });
      return block;
    }
  return null; 
}

So I had to implement a bigger transformation logic, using many functions of the expression API.

I can now write richer expressions mixing all those features:

Expression<Action> expLabel = () =>
  Block.Default
    ._(() => Console.WriteLine("Start"))
    .Goto("exit")
    ._(() => Console.WriteLine("not printed"))
    .Label("exit")
    ._(() => Console.WriteLine("end"));

expLabel = ExpressionHelper.Translate(expLabel);
expLabel.Compile()();

Console.WriteLine("\nIfThenElse support");

Expression<Action> expIfThenElse = () =>
  Block.Start(new { s = "" }, b =>
    Block.Default
        ._(() => Console.Write("Enter 'OK'"))
        .Assign(() => b.s, Console.ReadLine())
        .IfThenElse(b.s == "OK",
            () => Console.WriteLine(
              "Good for me"),
            () => Console.WriteLine("Sorry"))
        );

expIfThenElse = ExpressionHelper.Translate(expIfThenElse);
expIfThenElse.Compile()();

Console.WriteLine("\nLoop support");

Expression<Action> expLoop = () =>
  Block.Start(new { i = 0 }, b =>
    Block.Default
      .Loop(() =>
        Block.Default
          ._(() => 
            Console.WriteLine("loop: " + b.i))
          .Assign(() => b.i, b.i + 1)
          .IfThen(b.i >= 4,
            () => Block.Default.Goto("break"))
          )
      .Label("break")
      ._(() => Console.WriteLine("end"))
  );

expLoop = ExpressionHelper.Translate(expLoop);
expLoop.Compile()();

Console.WriteLine("\nFor support");

Expression<Action> expFor = () =>
  Block.Default
    .For(0, i => i < 4,
      i => Console.WriteLine("For:" + i));

expFor = ExpressionHelper.Translate(expFor);
expFor.Compile()();

Console.WriteLine("\nWhile support");

Expression<Action> expWhile = () =>
  Block.Start(new { i = 0 }, b =>
    Block.Default
      .While(b.i < 4, 
        () => Block.Default
          ._(() => 
            Console.WriteLine("While:" + b.i))
          .Assign(() => b.i, b.i + 1))
      ._(() => Console.WriteLine("end"))
    );

expWhile = ExpressionHelper.Translate(expWhile);
expWhile.Compile()();

Mitsu

The whole project is available here: http://code.msdn.microsoft.com/CSharp4Expressions/

The goal is still the same: enhance the C# 4 expression capabilities.

Now we have block support, let’s find a way to add variables. We can not really ‘code’ something without them…

In our first sample, the main lambda already had a parameter and we were able to use it inside our expression. Technically, adding variables is just creating new local parameters which is easy:

Expression.Parameter(typeof(int), “param”) then we can add this parameter as a variable of a block.

Once again, what is hard is to find a way to express and recognize them easily.

First idea, creating :

Block.DefineVariable(typeof(int), “param”)
Block.ReadVariable(“param”)
Block.AssignVariable(“param”, 1);

Easy to do and easy to transform, except it’s long to write and non typed. We would need a lot of cast instructions to make it run for real, heavy, no test at compile time, unsafe…not good.

Here is what I propose. As lambda can have access to the scope of their hosting method (see this article), we could imagine to create our needed variables outside the expression and then convert them to local parameter during the transformation.
Quite a strange solution with unnecessary declarations inside the hosting method but the idea is here. Let’s create an intermediate scope between the lambda and its hosting method.

public class Block
{
    public static Block Start<T>(T locals, Action<T> block)
    {
        throw new NotImplementedException();
    }
    ...

Now imagine we use an anonymous type to define this first instance.

Expression<Action<int>> exp = i =>
    Block.Start(new { j = 1 }, b =>
        Console.WriteLine(b.j)
    );

The only default is b.j is read-only because such are anonymous types properties. But whatever, C# does not supports affectation in expressions. So we will symbolically write something like :

Block.Assign(() => b.j, 1);

Let’s talk about the transformation. We need to recognize Block.Start, analyze the type of the first argument, create as many local parameters as the first argument exposes properties (same name, same type of course) and then replace all the references to b.X by the corresponding parameter. Last feature, we can initialize all the parameters with the values found in the anonymous type definition.
We also have to make it run correctly recursively.

private Expression VisitBlockMethodCall(MethodCallExpression node)
{
    if (IsMethodOf<Block>(node, "Assign"))
    {
      var left = node.Arguments[0]
        as LambdaExpression;
      return Expression.Assign(Visit(left.Body
        ,Visit(node.Arguments[1]));
    }
    if (IsMethodOf<Block>(node, "Start", true))
    {
      //Anonymous type analyzed to generate
      //parameters
      var newExpression = node.Arguments[0]
        as NewExpression;
      var variablesToAdd =
        newExpression.Type.GetProperties()
          .Select((p, i) =>
            new {
              Parameter = Expression.Parameter(
                p.PropertyType,
                p.Name),
              Value = newExpression.Arguments[i]
              }).ToArray();
      
      //Prepares properties to be replaced
      //by parameters and adds them to a
      //global collection
      var blockStartLambda = node.Arguments[1]
        as LambdaExpression;
      var parameters =
        variablesToAdd.ToDictionary(
          v => v.Parameter.Name,
          v => v.Parameter);
          
      blockStartParameters.Add(
        blockStartLambda.Parameters[0],
        parameters);
      //VisitMember will make the right
      //replacements during this recursive
      //call
      var body = Visit(blockStartLambda.Body);
      //Removes from collection
      blockStartParameters.Remove(
        blockStartLambda.Parameters[0]);
        
      //Creates a block with parameters 
      //declaration and initialization
      var blockWithVariablesInitialization =
        variablesToAdd.Select(v => 
          Expression.Assign(v.Parameter, v.Value))
          .Concat(new Expression[] { body });

      var block = Expression.Block(
          variablesToAdd.Select(v => v.Parameter),
          blockWithVariablesInitialization);
      return block;
    }
    ...

protected override Expression VisitMember(MemberExpression node)
{
  if ((node.Member.MemberType 
    == MemberTypes.Property)
      && (node.Expression is ParameterExpression))
    {
      Dictionary<string, ParameterExpression>
        parameters = null;
      if (blockStartParameters.TryGetValue(
        node.Expression as ParameterExpression,
        out parameters))
      return parameters[node.Member.Name];
    }
    return base.VisitMember(node);
}

Expression<Action<int>> exp = i =>
    Block.Start(new { j = 1 }, b =>
        Console.WriteLine(b.j)
    );

.Lambda #Lambda1<System.Action`1[System.Int32]>(System.Int32 $i) {
    .Call CSharp4Expressions.Block.Start(
        .New <>f__AnonymousType0`1[System.Int32](1),
        .Lambda #Lambda2<System.Action`1[<>f__AnonymousType0`1[System.Int32]]>)
}

.Lambda #Lambda2<System.Action`1[<>f__AnonymousType0`1[System.Int32]]>(<>f__AnonymousType0`1[System.Int32] $b) {
    .Call System.Console.WriteLine($b.j)
}

.Lambda #Lambda1<System.Action`1[System.Int32]>(System.Int32 $i) {
    .Block() {
        .Block(System.Int32 $j) {
            $j = 1;
            .Call System.Console.WriteLine($j)
        }
    }
}

Let’s test if we can nest declarations (variables local to child blocks).

Expression<Action<int>> exp = i =>
    Block.Start(new { j = 1 }, b =>
        Block.Start(new { i = 2 }, b2 =>
            Console.WriteLine(b.j + b2.i)));

Ok we now have block support and a way to declare variables.
If reading is natural, we need to be able to assign values to those variables.

It’s a quite easy transformation. We first create an Assign() method in the Block class.

public class Block 
{
  public Block Assign<T>(Func<T> leftExpression, T rightExpression)
  {
    throw new NotImplementedException();
  }
  ...

private Expression VisitBlockMethodCall(MethodCallExpression node)
{
  if (IsMethodOf<Block>(node, "Assign"))
  {
    var left = node.Arguments[0] as
      LambdaExpression;
    return Expression.Assign(
      Visit(left.Body),
      Visit(node.Arguments[1]));
  }
  ...

Expression<Action<int>> exp = i =>
    Block.Start(new { j = 1 }, b =>
        Block.Default
            ._(() => Console.WriteLine(b.j))
            .Assign(() => b.j, 2)
            ._(() => Console.WriteLine(b.j))
            );

Enough for this post !

Next article will add Label, Goto, Loop, IfThenElse, While and For instructions.

The whole project is available here : http://code.msdn.microsoft.com/CSharp4Expressions/

Since .Net 3.5 and Linq, the C# compiler is capable of generating expression trees instead of standard executable IL. Even if Linq opens the door of meta-programming (using the code to define something else, like a Sql query), we still have a lot of limitations.

A C# expression is limited to a single instruction returning a value, given some parameters. Method calls, properties access, constructors, and operators are allowed but no block, no loops, etc…

Expression<Action<string>> printExpression =
    s => Console.WriteLine(s);
var Print = printExpression.Compile();
Print("Hello !!!");

Of course, compiling the expression is not the only final goal but I will not go further in this article.

With .Net 4.0, Linq expressions implementation has moved to the DLR. The dynamic language runtime is using a richer expression API that allows a lot of thing. We can consider that C# 4.0 compiler is using a subset of the DLR expressions.

So, even if C# 4.0 now allows expressions based on Actions, we still have all the other limitations.

Therefore we can use the expression API programmatically to express more complex expressions like explained in this post from Alexandra Rusina. But we won’t be able to express those complex expressions from the C# language.

Let’s try to find a work around for the first big barrier: statements…

The new expression API offers the BlockExpression class to define a block of statements.
It’s quite easy to use since we just have to provide a list of expressions.

public static BlockExpression Block(params Expression[] expressions);

So the first very big restriction is we can only provide one single instruction !
Now imagine we use a syntax comparable to the one explained in this article where some instance methods always return the instance itself (this) so we can create a sequence of them.

public class Block
{
    public Block _(Action action)
    {
        throw new NotImplementedException();
    }
    public static Block Default
        { get; private set; }

I know it’s very strange but I’ve chosen to name my method “_”. It’s authorized by C# and it’s legal :)
I have also defined a Default property to avoid to have to create Block instances every time and because it’s an easy signature to recognize.

Now we can write things like:

Expression<Action<string>> exp = s =>
    Block.Default
        ._(() => Console.WriteLine("I"))
        ._(() => Console.WriteLine("would like"))
        ._(() => Console.WriteLine("to say: "))
        ._(() => Console.WriteLine(s));

You can notice that there is only one “;” in my code.

Of course, my idea is to use this strange syntax to transform this expression into a BlockExpression. To achieve this I have to analyze my expression, find the Block.Default signature, remove it, and then extract the body from all the actions to finally get the collection of expressions to build my BlockExpression.

To do this, I have implemented an expression visitor. You can notice that the base class is now part of .Net (through the DLR once again): System.Linq.Expressions.ExpressionVisitor.

The visitor is a massively recursive code that helps you analyze all the possible nodes of an expression tree. For this first step, I will override the VisitMethodCall method to catch my sequence of Block methods.

protected override Expression VisitMethodCall(MethodCallExpression node)
{
    if (IsMethodOf<Block>(node))
    {
        var expressions = new List<Expression>();
        do 
        {
            var r = VisitBlockMethodCall(
                node as MethodCallExpression);
            expressions.Insert(0, r);
            node = node.Object as
                MethodCallExpression;
        } while (node != null);

        return Expression.Block(expressions);
    }
    return base.VisitMethodCall(node);
}

There is an important thing to know about method call sequences. The visitor is discovering them in the opposite order of the C# syntax.

For example, if I write :

test.Do().Print();

Of course we are doing all this work only if the method is declared by the Block type. The IsMethodOf helper method is used here.

private bool IsMethodOf<T>(MethodCallExpression node, string methodName)
{
    if (node == null)
        return false;
    return ((node.Method.DeclaringType 
        == typeof(T))
        && (node.Method.Name == methodName));
}
private bool IsMethodOf<T>(MethodCallExpression node)
{
    if (node == null)
        return false;
    return (node.Method.DeclaringType 
        == typeof(T));
}

private Expression VisitBlockMethodCall(MethodCallExpression node)
{
    if (IsMethodOf<Block>(node, "_"))
        return Visit((node.Arguments[0] as
            LambdaExpression).Body);
    ...
}

Once I have collected all those expressions, I just have to build and return Expression.Block(expressions). '”Block.Default” is naturally skipped at this moment.

Important point: all the Block members are not important in the end because there goal are to be removed by this transformation step. After the transformation, they must have all disappeared. I just consider them as markers for my transformation engine (metadata and not code). That’s also why they are never implemented (throw new NotImplementedException()). BUT whatever the transformation we make on the expression, it MUST respect the C# syntax in the first place.

Now we have to apply the visitor on our sample expression.

Expression<Action<string>> expWithBlock = s =>
    Block.Default
        ._(() => Console.WriteLine("I"))
        ._(() => Console.WriteLine("Would like"))
        ._(() => Console.WriteLine("To say: "))
        ._(() => Console.WriteLine(s));


expWithBlock = 
    ExpressionHelper.Translate(expWithBlock);
expWithBlock.Compile()("Hello !!!");

public static class ExpressionHelper
{
    public static Expression<TDelegate> Translate<TDelegate>(Expression<TDelegate> expression)
    {
        var visitor = 
            new BlockCompilerVisitor<TDelegate>();
        return visitor.StartVisit(expression);
    }
}

I this very first step we managed to create multiline C# expressions based on actions.

Visual Studio 2010 has a very useful new debug viewer for expressions that you can call at debug time.

Here is our expression before…

.Lambda #Lambda1<System.Action`1[System.String]>(System.String $s) {
    .Call (.Call (.Call (.Call (CSharp4Expressions.Block.Default)._(.Lambda #Lambda2<System.Action>))._(.Lambda #Lambda3<System.Action>)
    )._(.Lambda #Lambda4<System.Action>))._(.Lambda #Lambda5<System.Action>)
} 

.Lambda #Lambda2<System.Action>() {
    .Call System.Console.WriteLine("I")
} 

.Lambda #Lambda3<System.Action>() {
    .Call System.Console.WriteLine("Would like")
} 

.Lambda #Lambda4<System.Action>() {
    .Call System.Console.WriteLine("To say: ")
} 

.Lambda #Lambda5<System.Action>() {
    .Call System.Console.WriteLine($s)
}

.Lambda #Lambda1<System.Action`1[System.String]>(System.String $s) {
    .Block() {
        .Call System.Console.WriteLine("I");
        .Call System.Console.WriteLine("Would like");
        .Call System.Console.WriteLine("To say: ");
        .Call System.Console.WriteLine($s)
    }
}

It’s not finished but enough for a single post.

Next part will propose a solution for creating variables and then other expression API features like Loop, Goto, Label, Assign and even new features like For.

You can get the whole solution here: http://code.msdn.microsoft.com/CSharp4Expressions

Expressions are used to evaluate something. We usually use them in the right side of an affectation or at any place where a value is expected. It can be composed with many other values, with computations or function calls.

When using objects we often retrieve values accessing properties or sub properties, defining property paths. This is what I will work on in this post.

Linq brought the Select method that we all know (one of my favorites).

We often use it to project from an entity to a new expression and many times we just use a property path.

customers.Select(c => c.Company.Address.Country);

Those of you who are familiar to Xaml are very used to property paths in binding expressions:

<TextBlock Text=”{Binding Path=Company.Address.Country}” />

Even if there are some differences, we could easily compare those two features.
One of the difference is WPF and Silverlight binding expressions can be “TwoWay”. This means that the property path expression can be used to both read or write the property value.

In C#, the selector is just pure code, so of course it compiles the natural access to the property (read only). Let’s think about how to make it possible to have a write access…

It’s not very difficult. If the expression only allows a sequence of chained properties, we just need to get the last one (Country in my example). Evaluating the rest of the expression (Company.Address) gives us the instance where we can get or set the last property value from.

To achieve this we need to be able to analyze the code which is not possible if it’s directly compiled into IL. The lambda syntax allows to use the same code to generate an expression instead of IL. Then we get an expression tree representing our property path, so we can analyze and understand it.

Let’s first try to do this in C# 3. Let’s imagine the final code we would like to have.

namespace CSharpRWSelector

{

    class Program

    {

        static void Main(string[] args)

        {

            var ps = PropertySelector<Customer>.Create(c => c.Address.Country);

            var cust = new Customer();

            cust.Address.Country = "FRANCE";

            Console.WriteLine(ps.GetValue(cust));

            ps.SetValue(cust, "FRANCE !");

            Console.WriteLine(cust.Address.Country);

        }

    }

    public class Customer

    {

        public Customer()

        {

            Address = new Address();

        }

        public string ID { get; set; }

        public Address Address { get; set; }

    }

    public class Address

    {

        public string Country { get; set; }

    }

}

Let’s imagine a PropertySelector class with a Create() method having the same prototype as the Linq Select().

public static PropertySelector<T, R> Create<R>(Expression<Func<T, R>> source)

{

}

You can notice that the Func<T, R> is surrounded with the Expression<T> class.
The use is exactly the same but we will get an Lambda expression instead of just a delegate reference.

First of all, getting a selector for reading is easy. We just need to compile the expression (source.Compile()) and we retrieve the right selector (Func<T,R>).

All the following is to get a way to write to the property.

Now let’s try to analyze this expression to retrieve the instance just before the last property of our property path.

We will have to implement a custom expression visitor. (see MSDN reference here)

I will quickly comment this part, but all the code is provided at the end of this post.

The expression visitor is massively recursive and is walking along all the expression tree.

We are only looking for properties (ie MemberAccess) and our goal is to catch the last one’s parent ! What I am mainly doing here is finding it and then wait for the next call to get the parent. You can notice that the properties of the path are discovered from right to left (last to first).

protected override Expression VisitMemberAccess(MemberExpression m)

{

    if ((m.Member.MemberType == System.Reflection.MemberTypes.Property) && 
        (!passed))

    {

        var lambda = Expression.Lambda(m.Expression, source.Parameters.ToArray());

        instanceSelector = lambda.Compile();

        propertyName = m.Member.Name;

        passed = true;

    }

    return base.VisitMemberAccess(m);

}

Once we get the parent (Address) we keep this reduced lamba expression (without the last property), we compile it and then we get a selector on the parent.

We can now implement the SetValue() method, using the selector to retrieve the parent instance given the source. Then, using reflection, we can retrieve the PropertyInfo and call the SetValue().

public void SetValue(T source, R value)

{

    var parent = instanceSelector.DynamicInvoke(source);

    var prop = parent.GetType().GetProperty(propertyName);

    prop.SetValue(parent, value, null);

}

As I said previously, the GetValue() is easy to implement. We just need to call the initial selector.

public R GetValue(T source)

{

    return selector(source);

}

I will also add some security code to be sure that only property paths are allowed.

code like c => c.SomeMethod().Property; must be rejected.

The expression visitor Visit() method is called for each node whatever its type. So it’s the perfect place to only accept property paths.

protected override Expression Visit(Expression exp)

{

    if ((exp.NodeType != ExpressionType.Parameter) &&

        (exp.NodeType != ExpressionType.Lambda) &&

        ((exp.NodeType != ExpressionType.MemberAccess) 

          && ((exp as MemberExpression).Member.MemberType 

          == System.Reflection.MemberTypes.Property)))

        throw new ArgumentException("Only Properties are allowed with PropertyPath");

    return base.Visit(exp);

}

Unfortunately, we have no way to check this at compile time.

Last but not least, let’s add an interesting improvement using C# 4.

In this first sample, you can notice that the GetValue is efficient because it’s a real ‘compiled’ selector but the SetValue is using reflection.

As explained in this very interesting post, C# 4 has new lambda expression features. Actually, not in the C# language itself but in the lambda expression APIs.

Affectation of a value was impossible to be described in a C# 3 lambda expression and it’s still not in C# 4, but we can build this expression tree bye code as the Expression.Assign() method now exists.

So now the goal is still to provide a Write access to my selector.

The visitor is now more complex as we want to make a real transformation of the tree.

From a selector Func<T, R> we want to infer an Action<T, R>.

The following code is very symbolic as it does not compiles but it gives a good idea of what we will try to generate:

From the analysis of

Func<Customer, string> f = c => c.Address.Country;

We will generate

Action<Customer, string> a = (cust, country) => cust.Address.Country = country;

Let’s modify the visitor:

protected override Expression VisitMemberAccess(MemberExpression m)

{

    var result = base.VisitMemberAccess(m);

    currentNode = Expression.MakeMemberAccess(currentNode, m.Member);

    return result;

}

In this first step, I am building a parallel expression tree copying the property path definition, excepted the lambda root.

We now need to build our Action<T, R>.

public PropertySelector<T, R> Compile(Expression<Func<T, R>> source)

{

    this.source = source;

    parameters = new List<ParameterExpression>();

    Visit(source);

    var valueParameter = Expression.Parameter(typeof(R), "value");

    parameters.Add(valueParameter);

    currentNode = Expression.Assign(currentNode, valueParameter);

    var setter = Expression.Lambda(typeof(Action<T, R>), currentNode, parameters);

    var result = new PropertySelector<T, R>() { 

        selector = source.Compile(), setter = (Action<T, R>)setter.Compile() };

    return result;

}

After running the visitor (Visit() method), I am retrieving the property path from currentNode and I am building the affectation with Expression.Assign().

Compared to the Func<T,R>, I also need to add a new R parameter which is the value to affect. (see parameters.Add(valueParameter); ).

Finally, a lambda expression groups all this stuff to create the Action<T,R>.

We can compile it and get the corresponding delegate (setter) which is real code instead of the reflection we’ve used in the C# 3 version.

We now just need to call it from the SetValue() method.

public void SetValue(T source, R value)

{

    setter(source, value);

    //var parent = instanceSelector.DynamicInvoke(source);

    //var prop = parent.GetType().GetProperty(propertyName);

    //prop.SetValue(parent, value, null);

}

The main application remains the same and we of course have the same result but we know use a dynamic solution by compiling code thanks to new C#4 expression tree features !

You can find the two relative solutions here for C# 3/VS2008 and C# 4/VS2010.

Mitsu

Just a quick post to share this project with you.
Microsoft France organized a 2 month long internship in Paris to develop a Surface Toolkit.

We have provided a bunch of controls, including a Card Game Surface Starter kit that you can see here:

The project on Codeplex: http://surfaceacademy2009.codeplex.com/

Even if mobile dev is not my every day work, thanks to the .Net Compact Framework, it’s still .Net programming.

Here is the scenario:

You come back home, you have a windows mobile phone wifi capable and you want to quickly get access to your phone pictures from your home network.
You just activate the Wifi, run my app and then browse to the provided link from any computer on the network.

Then a silverlight application is loaded from the phone and you can see any of your pictures.

Here is how it works:

I decided to use windows mobile to host a Silverlight application.

I had just needed a Mobile Web Server that I found here (thanks to Pavel Bánský). The code is full C# and really small and easy to use. I just had to add cookie support but I will talk about it later.

Now I have a basic web server hosted on my phone, I will publish some stuff.

- the main html page containing the silverlight application. I renamed the one provided by Visual Studio to “Default.html” to make it the default page of my web site.

- the xap file which is the Silverlight application itself.

- a web service to expose the list of pictures available on my phone. As I had no web service infrastructure available on my very small web server, I have decided to expose a rss feed which is made with just a few lines of Linq to Xml. Exposing pictures on http gives a lot of advantages like getting the benefits of the browser local cache. In this project it’s very useful because the mobile phone does not have a large and powerful bandwidth, so we appreciate not to reload pictures ever time. Now we just need to link some Silverlight Image controls to the pictures urls and the Silverlight image loader will work for us.

- make the pictures visible. The web server contains a virtual folder feature. I just had to make it point to the local pictures path.

Linq to Xml rss content creation on server side (Compact Framework):

Regarding the client development, I have created a simple Silverlight 3 application (yes I also wanted to play with those new features like 3D and non linear animations).

The Silverlight application calls the web service, reads the rss content (using Linq to Xml again !) and binds the pictures paths to a listbox. The selected picture is displayed in the biggest part of the window. When you change the selected picture, an animation wipes out the existing one and another is bringing the new one with a 3D effect.

Analysing rss content with Linq to Xml on client side (Silverlight):

And that’s it !

Now let’s talk about security. Once again, it’s just a little demo but we can not talk about opening a web server on your phone without talking about security.

The web server is made to respond to the user for a short time. https is complex and even basic authentication needs credentials on the server side. I have chosen another solution that I found to be more appropriate. In my scenario, the web server is requested by a single user who’s got the phone in his hands. So when a first request comes (no cookie), I am asking for a human validation (MessageBox). Of course during this time the server is stopped. The user just has to validate on the phone and then the server answers and provides an authentication cookie. Next requests will carry the cookie and the user will not have to validate again.

This remains a really really small demo. We could of course imagine having a more robust web server and some optimizations like thumbnails creation on server side but this was just a test and I hope it gave some interesting ideas to some of you.

In addition to hosting a Silverlight application on my mobile phone, the funniest was to be able to use .Net both on server and client side (Compact Framework and Silverlight) without using the Windows .Net Framework !

The source code is attached to this post.

When using Linq to objects, you will quickly feel the need to pass some parameters from a method to another but it’s not so easy because each Linq method is not calling the following one. In a Linq sequence, each method is using the result computed by the previous one. So, local contexts are not visible from one method to another.
The compiler is using two technical different ways to let parameters go out of a method.

As an example, let’s first see how the .SelectMany() method is working.

This very little example shows that s1 and s2 are both accessible in the select. It’s nice, but how does this work ?
You must know that the ‘from’ statement of the Linq sugar syntax does not match any existing Linq method. Let’s see how we would have written this using the classical C# syntax.

Let’s focus on the SelectMany parameter:

SelectMany(Func<TSource, IEnumerable<TResult>> selector).

The method must return an IEnumerable<TResult>. In our example, we get it using values2.Select(). We are now touching the interesting point. The parameter of the .Select() is also a lambda “s2 => s1 + s2”. In Linq to object a lamda generates an anonymous method and anonymous methods can access their host scope. Here, s1 is visible inside values2.Select().

So the first solution to share parameters between methods is to nest them

like “.SelectMany(s => s.Select(s2 =>’s in accesible here’ ))”

instead of creating a sequence “source.Skip(‘scope1’).Take(‘scope2’)”

Now what if we would like to share a parameter between two following methods like Skip() and Take() ?

Let’s see how the “let” keyword works.

In the next example, I will start from a list of numbers stored as strings.
I would like to get only numbers greater than 10 and order them by their value but keeping the result as an enumeration of string.

We can write it quickly this way:

This works fine but we all notice the ugly “Convert.ToInt32(s)” used twice on the same value. Thanks to the “let” keyword we can create a new parameter that will be accessible in all the query.

We can see that the “let” keyword solves this problem extremely easily. But once again the sugar syntax of Linq is really magic. As we always want to know the secrets of magic tricks, let’s try to get the same result without using the “let” keyword and we will find out what the C# compiler is really doing.

Let’s start by decomposing all the steps using the regular C# syntax.

I have chosen to decompose this way to show that the only place to share something between the Where() and the OrderBy() is the result.

Now we have to make a new parameter travel across the sequence in addition to the current result. The idea is to create a new type to group the current result and the new value. To achieve this easily we can just use a anonymous type.

We can of course write this in a single Linq query

which is the exact equivalent of what is compiled when using the ‘let’ keyword

Of course the Linq syntax is extremely short but it’s always nice to know what’s happening behind the scene.

I hope this sample can also help you to solve some other problems when playing with Linq.

Contrarily to the title, this is a serious article !

From 10th to 12th of February Microsoft France have organized the Paris Techdays event.
During the developer keynote, I have presented some Surface development features with a funny demo.

Here is a video of this demo but in french.

Now let me explain what happened.

Here is the idea:

Get a Surface table, setup a windows extended desktop using the VGA output of the table and an external display. The Surface application is very simple and similar to the very classical application where many people can move, rotate and resize pictures. In our case, pictures were slides exported from Powerpoint. When the applications runs, it creates a classical WPF window (not Surface specific) and put it on the secondary display, in a maximized state.
The goal is to output a defined part of what we have on the table on the external display. I have choose to use Tag to define this part (a rectangle) on the table. Placing the tag will define the center of this output rectangle. Then you can change the position of the output rectangle by moving the tag. As the Surface also recognizes the orientation, I have used the delta orientation value to increase or decrease the output rectangle size depending on the direction you are turning the tag (clockwise/counter clockwise).

As many people (including me :-) ) can't test this application at home, I have simulated feature in a WPF application using mouse move and mouse wheel events.

How to implement it:

It's quite fast to implement but let's see the interesting points.

First, how to capture the targeted visual part ? We will use a WPF VisualBrush.
This component is a Brush, comparable to a image brush, a plain color or a gradient brush but will use another WPF Visual as for painting. What you can notice is that the VisualBrush is not based on a kind of bitmap capture but is redrawing the visual using the wpf vector information. This means that if the VisualBrush is growing the original size, you will still keep a sharp rendered image keeping the benefits of the vector based drawing.

So the output window is simply defined this way:

<Window x:Class="SurfaceMedia.OutputWindow"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    Title="OutputWindow" Height="300" Width="300">

    <Window.Background>

        <VisualBrush x:Name="vb" />

    </Window.Background>

</Window>

Now we need to define which part of the main window we want to output.
We will surround our main content with a grid and then put a Canvas over it. Then we can define a Rectangle in our canvas to visually define our output region.
No the problem is we have our Rectangle over the main content but we want our main content to still receive inputs (mouse, keyboard) and we want the Rectangle to respond to some mouse events.

To achieve this, we will define the Canvas IsHitTestVisible attribute to "False". Easy to do but now the Rectangle will no longer receive mouse events.
In our surrounding grid, we will catch the needed mouse events. As the main content can potentially stop the bubble events from going up to their parents, we will prefer using PreviewMouseMove and PreviewMouseWheel.

<Grid PreviewMouseMove="Canvas_MouseMove" PreviewMouseWheel="Grid_MouseWheel">

    <Grid>

        ...main content

    </Grid>

    <Canvas x:Name="canvas" IsHitTestVisible="False">

        <Rectangle x:Name="outputRect" Width="100" Height="100" Stroke="Black"

            StrokeThickness="1" Opacity="0.5" Canvas.Left="6" Canvas.Top="72" />

    </Canvas>

</Grid>

Now we get what we wanted. We just need to adjust the VisualBrush playing on its Viewbox property to define exactly which part of the source we want to display.

private void Canvas_MouseMove(object sender, MouseEventArgs e)

{

    RefreshOutputWindow(e);

}

private void Grid_MouseWheel(object sender, MouseWheelEventArgs e)

{

    if ((outputRect.Width < 40) && (e.Delta < 0))

        return;

    outputRect.Width += e.Delta / 10;

    outputRect.Height += e.Delta / 10;

    RefreshOutputWindow(e);

}

private void RefreshOutputWindow(MouseEventArgs e)

{

    var pos = e.GetPosition(canvas);

    pos.Offset(-outputRect.Width / 2, -outputRect.Height / 2);

    Canvas.SetTop(outputRect, pos.Y);

    Canvas.SetLeft(outputRect, pos.X);

    outputWindow.vb.Viewbox = new Rect(pos, new Size(outputRect.Width, outputRect.Height));

    outputWindow.vb.ViewboxUnits = BrushMappingMode.Absolute;

}

How to programmatically place a WPF window on a secondary display ?

This one is not really related to WPF but is a little bit tricky.
We will need to make some interop with Window Forms because Screens information is not accessible from WPF APIs.
For this demo, if an extended desktop is available, we will place our output window on it in full screen. If not, we will just put it as a regular window on the main screen.

private void ShowOutputWindow()

{

    outputWindow = new OutputWindow();

    if (System.Windows.Forms.Screen.AllScreens.Length > 1)

    {

        outputWindow.WindowStartupLocation = WindowStartupLocation.Manual;

        System.Drawing.Rectangle workingArea

            = System.Windows.Forms.Screen.AllScreens[1].WorkingArea;

        outputWindow.Left = workingArea.Left;

        outputWindow.Top = workingArea.Top;

        outputWindow.Width = workingArea.Width;

        outputWindow.Height = workingArea.Height;

        outputWindow.WindowStyle = WindowStyle.None;

        outputWindow.Topmost = true;

    }

    outputWindow.Show();

    outputWindow.vb.Visual = mainGrid;

}

Why using the popfly duck ?!

I was just looking for something to stick the tag on and when looking around me I have found this funny duck that we had received when organizing the Paris ReMix a few years ago. It's hard to stick the tag under the duck but once it's done the duck shape is quite handy !

The source code is attached to this post.

DesignTimeForm.zip