Giving Clarity to LINQ Queries by Extending Expressions R2

Giving Clarity to LINQ Queries
by Extending Expressions

Entity Framework & LINQ
Expression<Func<TModel, bool>>
People.Where(p => p.Title == “Developer”)

Automapper
Expression<Func<TSource, object>>
AutoMapper.Mapper.CreateMap<Post, BlogPostView>()
.ForMember(dest => dest.Heading,
opts => opts.MapFrom(src => src.Title));

HTML Helpers
Expression<Func<TModel, TResult>>
@Html.LabelFor(obj => obj.Prop)

Telerik Data Grid
@(Html.Kendo().Grid<Post>
.Columns(columns => {
columns.Bound(p => p.Title);
columns.Bound(p => p.Author);
columns.Bound(p => p.Pubished);
})
)

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

Homo-iconicity
Same syntax for executable code as data representation
1 //Executable representation
2 Func<int, int> plusOne = n => n + 1;
3
4 //Data representation
5 Expression<Func<int, int>> plusOne = n => n + 1;

Expression Factory
1 // new Expression() invalid!
2
3 var x = Expression.Constant(1);
1
constant

Expression Factory
2
4 var y = Expression.Constant(1);
1
constant
1
constant

Expression Factory
2
5 var sum = Expression.Add(x,y); +
11
Add
constant constant

Expression Factory
2
5 var sum = Expression.Add(x,y);
6
7 Console.WriteLine(sum);
8 // (1 + 1)
9
10 Console.WriteLine(sum.GetType());
11 // SimpleBinaryExpression
+
11
Add
constant constant
SimpleBinaryExpression

Compile
2 Console.WriteLine(plusOne.ToString());
3 // n => (n + 1)

Compile
2 Console.WriteLine(plusOne.ToString());
3 // n => (n + 1)
4
5 var x = plusOne.Compile();
6 Console.WriteLine(x(1));
7 // 2

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

Are
OMG He’s
showing docs
in a
presentation

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

Refactoring
What’s
going
on here?
1 postRepository.GetAll()
2 .Where(post => post.IsPublished &&
3 post.PostedOn <= today &&
4 (post.PostedOn >= cutoffDate ||
5 post.Author == featuredAuthor &&
6 post.PostedOn >= featuredAuthorCutoffDate));

Let’s start simple
What’s
going on
here?
2 .Where(post => post.IsPublished && post.PostedOn <= today);

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

LINQ Where Chaining
1 //Both statements produce the same result
2
3 //Concise
4 var query = query.Where(x => x.Value == 1 && x.Name == ”foo”);
5
6 //Configurable
7 var query = query.Where(x => x.Value == 1)
8 .Where(x => x.Name == ”foo”);
SELECT x
FROM table
WHERE (value = 1 AND name = ‘foo’)

LINQ Where Chaining
1 var query = query.Where(x => x.Value == 1);
SELECT x
FROM table
WHERE (value = 1)
=>
x
==
value 1

LINQ Where Chaining
1 var query = query.Where(x => x.Value == 1)
2 .Where(x => x.Name == ”foo”);
SELECT x
FROM table
WHERE (value = 1 AND name = ‘foo’)
&&
=>
x
==
name foo
==
value 1

LINQ Where Chaining
1 var query = query.Where(x => x.Value == 1);
2 query.Where(x => x.Name == ”foo”);
3 query.Where(x => x.IsDeleted == ”true”);
SELECT x
FROM table
WHERE (value = 1 AND name = ‘foo’ AND IsDeleted = 1)
&&
=>
x
==
name foo
==
value 1
&&
==
isDeleted
1

Custom Filters
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);
}

2 .Where(post => post.IsPublished &&
3 post.PostedOn <= today);
Readability?
Before After
What’s
the
intent?
2 .ArePublished()
3 .PostedOnOrBefore(today);

Now what?
What’s
the
intent?
1 IQueryable<Post> posts = postRepository.GetAll()
2 .Where(post => post.IsPublished && post.PostedOn <= today &&
3 (post.PostedOn >= cutoffDate || post.Author == featuredAuthor &&

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

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

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

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

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

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

Readability?
Before
After
2 .Where(post => post.IsPublished && post.PostedOn <= today &&
3 (post.PostedOn >= cutoffDate || post.Author == featuredAuthor &&
2 .ArePublished()
3 .PostedOnOrBefore(today)
4 .Where(PostedOnOrAfter(cutoffDate)
5 .Or(FeaturedAuthorPostedrOnOrAfter(featuredAuthor,featuredAuthorCutoffDate)));

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

Dynamic Queries
Try this without expressions.
1 var rule = PredicateExtensions.PredicateExtensions.Begin<Post>();
2 foreach (var authorName in featuredAuthorNames)
3 {
4 rule = rule.Or(FeaturedAuthorPostedOnOrAfter(authorName, featuredAuthorCutoffDate));
5 }
6 return rule;

Dynamic Expression
Left
Body.NodeType == ExpressionType.Constant
Right
if (IsExpressionBodyConstant(left)) return (right);
>=
=>
post
Body
bool true

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

Resources
• Article
– https://goo.gl/kAM05P
• GitHub
– https://github.com/EdCharbeneau/PredicateExtensions
• Telerik
– www.Telerik.com
• Twitter
– @EdCharbeneau

Giving Clarity to LINQ Queries by Extending Expressions R2

More Related Content

What's hot (20)

Similar to Giving Clarity to LINQ Queries by Extending Expressions R2 (20)

More from Ed Charbeneau (19)

Recently uploaded (20)

Giving Clarity to LINQ Queries by Extending Expressions R2

Editor's Notes