LINQ and Entity Framework are both commonly used in the .Net ecosystem, but even well-written applications can have LINQ queries that are difficult to understand. Because LINQ is so flexible, it can be written in ways that fail to communicate the developer’s intent. Well-written LINQ should be so clear as to be self-documenting. To write clear LINQ, it helps to understand the details of a few LINQ components that improve LINQ’s readability.

1. Giving Clarity to LINQ Queries
by Extending Expressions

2. Ed Charbeneau
Developer Advocate for Progress<Telerik>
Author<T>
Podcast => “Eat Sleep Code the Official Telerik Podcast”
Twitter.Where(user = @EdCharbeneau)

3. Are
Do you use
expressions?

4. Common uses
Entity
Framework
LINQ
HTML
Helpers
Expression<Func<TModel, TResult>>
@Html.LabelFor(obj => obj.Prop)
Expression<Func<TModel, bool>>
People.Where(p => p.Title == “Developer”)

5. Expressions in C#
• Representation of code as data
• Meta-programming
– Analyze, rewrite, and translate code at runtime

6. Expression Factory
+
11
Add
constant constant
SimpleBinaryExpression

7. Homo-iconicity
Same syntax for executable code as data
representation

8. Compile

9. Runtime Modification
ExpressionVisitor
• used to traverse or rewrite expression trees
• Abstract class
– Inherit and override
• .Visit(expression)
– Recursively walks the tree
– Returns an Expression
https://msdn.microsoft.com/en-us/library/bb882521(v=vs.90).aspx

10. Are
How is this
useful?

11. Pipeline
Pipes and filters
Filter
Rule Rule
Data
Data
Data
Consumer
Results
Database Filter
Rule Rule
dbContext.Where(rule).Where(rule)

12. Maintainability & Readability

13. Refactoring
What’s
going on
here?

14. Let’s start simple
What’s
going on
here?

15. Distinction
The tale of two extension methods
IEnumerable.Where(q => q.Value == true)
Func (delegate)
Func<T, bool>
IQueryable.Where(q => q.Value == true)
Expression
Expression<Func<T, bool>

16. LINQ Where Chaining

17. Custom Filters
(Expression<Func<TSource, bool>> predicate)
ParameterMethod
.Where<TSource>
Extends type
IQueryable<TSource>
Return type
IQueryable<TSource>
Generic type
Extends type
IQueryable<MyType>
Return type
IQueryable<MyType>
Method
.CustomMethodName()
public static IQueryable<Post> ArePublished(this IQueryable<Post> posts)
{
return posts.Where(post => post.IsPublished);
}

18. Readability?
Before After
What’s
the
intent?

19. Now what?
What’s
the
intent?

20. Lambda as an Expression tree
post => post.PostedOn >= cutoffDate
>=
cutoffDatePostedOn
GreaterThanOrEqual
=>
post
Lambda
parameter
parameter constant
Body

21. Combine Like Expressions?
>=
=>
post
Body
==
=>
post
Body
AND / OR?

22. Housekeeping
Left
Body.NodeType == ExpressionType.Constant
Right
if (IsExpressionBodyConstant(left)) return (right);
>=
constantPost.Property
=>
post
Body
bool true

23. CombineLambdas
>=
constantPost.Property
=>
post
Body
==
constantPost.Property
=>
post
Body
AND / OR?
CombineLambdas(left, right, ExpressionType.AndAlso)

24. Get Paramters
>=
constantPost.Property
=>
post
Body
==
constantPost.Property
=>
post
Body
SubstituteParameterVisitor(left.Parameters[0], right.Parameters[0])

25. Replace Parameters
>=
constantPost.Property
Body
==
constantPost.Property
post
Body
post
Post.Property
SubstitutionVisitor.VisitParameter

26. Combined Expressions
=>
post
Lambda
parameter
Body
>=
&&
==
Expression.MakeBinary
Expression.Lambda<Func<T, bool>>

27. Readability?
Before
After

28. New Requirements!
Now we must support multiple featured authors
Dynamic
LINQ query?
No problem, now we’re equipped for it!

29. Dynamic Queries
Try this without expressions.

30. Are
Questions?

31. Resources
• Article
– https://goo.gl/kAM05P
• GitHub
– https://github.com/EdCharbeneau/PredicateExtensions
• Nuget
– https://www.nuget.org/packages?q=predicate+extensions
• Twitter
– @EdCharbeneau