The document discusses expressions in C# and LINQ. It provides examples of expression trees representing lambda expressions and method calls. It also describes using expressions to implement reflection at compile time and build an IQueryable provider by compiling expressions to IL.

1. Expressions и все-все-все

2. http://sane.habrahabr.ru
http://der-waldgeist.blogspot.com
http://twitter.com/AlexSane
http://www.google.com/profiles/shurickFomin
http://crew.taucraft.com/

3. Expression
…остальные trees
плюшки
Expression
Visitor

5. 2+3*4
2+(3*4)

6. private static void Main()
{
Func<int, int, int> f = (x, y) => x + y;
Console.WriteLine(f);
}
System.Func`3[System.Int32,System.Int32,System.Int32]
[CompilerGenerated]
private static int <Main>b__0(int x, int y)
{
return x+y;
}
private static void Main()
{
var f = new Func<int, int, int>(Program.<Main>b__0));
Console.WriteLine(f);
}

7. static void Main()
{
Expression<Func<int, int, int>> f = (x, y) => x + y;
Console.WriteLine(f);
}
(x, y) => (x + y)
ParameterExpression CS0 = Expression.Parameter(typeof (int), "x");
ParameterExpression CS1 = Expression.Parameter(typeof (int), "y");
Expression<Func<int, int, int>> f =
Expression.Lambda<Func<int, int, int>>(
Expression.Add(CS0, CS1),
new ParameterExpression[] {CS0, CS1}
);

8. Expression<Func<DateTime, int>> f =
d => (int) Math.Abs((DateTime.Now - d).TotalSeconds);

9. d => (int) Math.Abs((DateTime.Now - d).TotalSeconds);
ParameterExpression CS0 = Expression.Parameter(typeof (DateTime), "d");
Expression<Func<DateTime, int>> f =
Expression.Lambda<Func<DateTime, int>>(
Expression.Convert(
Expression.Call(
null,
(MethodInfo) methodof (Math.Abs),
new Expression[]
{
Expression.Property(
Expression.Subtract(
Expression.Property(null, (MethodInfo) methodof (DateTime.get_Now)),
CS0,
(MethodInfo) methodof (DateTime.op_Subtraction)
),
(MethodInfo) methodof (TimeSpan.get_TotalSeconds)
)
}
), typeof (int)
), new ParameterExpression[] {CS0} );

10. Expression
tree

11. d => (int) Math.Abs((DateTime.Now - d).TotalSeconds);

12. .NET 3.0 .NET 4.0
• Operators • Blocks
• Method calls • Loops
• Property getters • Try/Catch/Finally
• Collection initializers • Goto/Labels
• Object initializers • Variables
• Convert/Cast • Assignments
• Constants • If/Then/Else
(x,y)=>x+y (x,y) => { return x+y; }*

14. ExpressionVisitor

15. protected virtual Expression VisitBinary(BinaryExpression b)
{
Expression left = this.Visit(b.Left);
Expression right = this.Visit(b.Right);
return b;
}

16. protected virtual Expression VisitBinary(BinaryExpression b)
{
Expression left = this.Visit(b.Left);
Expression right = this.Visit(b.Right);
if (left != b.Left || right != b.Right)
{
return Expression.MakeBinary(
b.NodeType, left, right, b.Method
);
}
return b;
}

22. IQueryable<Tree> forest = // ...
var queryable = from tree in forest
where tree.HasHollow
select tree.ColectSomeHoney();
var queryable = forest.Where(tree => tree.HasHollow)
.Select(tree => tree.ColectSomeHoney());
var queryable = Queryable.Select(
Queryable.Where(forest, tree => tree.HasHollow),
tree => tree.ColectSomeHoney() );
var queryable = Enumerable.Select(
Enumerable.Where(forest.AsEnumerable (), tree => tree.HasHollow),
tree => tree.ColectSomeHoney() );

23. internal override Expression VisitMethodCall(MethodCallExpression m)
{
Expression instance = base.VisitMethodCall(m);
if (m.Method.DeclaringType == typeof(Queryable))
{
MethodInfo info = FindEnumerableMethod(m.Method);
return Expression.Call(instance, info, source);
}
return m;
}

24. internal override Expression VisitMethodCall(MethodCallExpression m)
{
Expression instance = base.VisitMethodCall(m);
if (m.Method.DeclaringType == typeof(Queryable))
{
MethodInfo info = FindEnumerableMethod(m.Method);
return Expression.Call(instance, info, source);
}
return m;
}

27. Compiled expressions
string PasswordPhrase(bool isBear)
{
return string.Format("{0} очень любит {1}",
isBear ? "Мишка" : "Ослик",
isBear ? "мёд" : "йод");
}

28. ILGenerator generator = //...
var label1 = generator.DefineLabel();
var label2 = generator.DefineLabel();
var label3 = generator.DefineLabel();
var label4 = generator.DefineLabel();
generator.Emit(OpCodes.Ldstr, "{0} очень любит {1}");
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Brtrue_S, label1);
generator.Emit(OpCodes.Ldstr, "Мишка");
generator.Emit(OpCodes.Br_S, label2);
generator.MarkLabel(label1);
generator.Emit(OpCodes.Ldstr, ”Ослик");
generator.MarkLabel(label2);
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Brtrue_S, label3);
generator.MarkLabel(label3);
generator.Emit(OpCodes.Ldstr, ”мёд");
generator.Emit(OpCodes.Br_S, label4);
generator.Emit(OpCodes.Ldstr, "йод");
generator.MarkLabel(label4);
generator.EmitCall(OpCodes.Call, typeof(String).GetMethod("Format"), new[] { typeof(string), typeof(ob
ject), typeof(object) });
generator.Emit(OpCodes.Ret);

29. Func<bool, string> Emit()
{
var isBear = Expression.Parameter(typeof (bool), "isBear");
var lambda = Expression.Lambda<Func<bool, string>>(
Expression.Call(
Method(() => string.Format("", null, null)),
Expression.Constant("{0} очень любит {1}"),
Expression.Condition(isBear, Expression.Constant("Мишка"),
Expression.Constant("Ослик")),
Expression.Condition(isBear, Expression.Constant("мёд"), Expression.C
onstant("йод") )
)
);
Func<bool, string> func = lambda.Compile();
return func;
}

30. Reflection in compile time
public class Tree
{
public Honey ColectSomeHoney()
{
//...
return new Honey();
}
}
private static void Main()
{
MethodInfo method =
typeof(Tree).GetMethod( "ColectSomeHoney",
BindingFlags.Public | BindingFlags.Instance
);
}

31. Reflection in compile time
public class Tree
{
public Honey CollectSomeHoney()
{
//...
return new Honey();
}
}
private static void Main()
{
MethodInfo method =
typeof(Tree).GetMethod( "ColectSomeHoney",
BindingFlags.Public | BindingFlags.Instance
);
}

32. Reflection in compile time
public class Tree
{
public Honey CollectSomeHoney()
{
//...
return new Honey();
}
}
private static void Main()
{
MethodInfo method =
typeof(Tree).GetMethod( "ColectSomeHoney",
BindingFlags.Public | BindingFlags.Instance
);
}

33. Reflection in compile time
private static void Main()
{
var method = GetMethod<Tree>(x => x.ColectSomeHoney());
}
public static MethodInfo GetMethod<T>(Expression<Action<T>> e)
{
return ((MethodCallExpression) e.Body)
.Method;
}

34. Reflection in compile time
private static void Main()
{
var method = GetMethod<Tree>(x => x.CollectSomeHoney());
}
public static MethodInfo GetMethod<T>(Expression<Action<T>> e)
{
return ((MethodCallExpression) e.Body)
.Method;
}

35. IQueryable
interface IQueryable<T> : IEnumerable<T> , IQueryable
{
Type ElementType { get; }
Expression Expression { get; }
IQueryProvider Provider { get; }
}
interface IQueryProvider
{
IQueryable CreateQuery(Expression e) ;
IQueryable<T> CreateQuery<T> (Expression e);
object Execute (Expression expression);
object Execute (Expression expression);
}

36. IQueryable

38. Expressions в C# — impress yourself!
http://habrahabr.ru/blogs/net/83169/

39. LINQ: Building an IQueryable provider
series
http://blogs.msdn.com/b/mattwar/archive/2008/11/18/linq-links.aspx

40. Винни-Пух и Все-Все-все
ISBN: 978-5-17-064151-2