linq inside

LINQ Inside

赵劼

http://jeffreyzhao.cnblogs.com

jeffz@live.com

About Me

• Shanghai Baisheng Technology Co., Ltd.

• Architect? Programmer!

– Be a happy programmer

• 日写代码三百行，不辞长作程序员

• Have fun with the technology

• Good at losing weight.

– Lost 40kg in 10 months

The session is for you if…

• You know nothing about LINQ.

• You don’t like LINQ.

• You want to learn how LINQ works in real world.

• You’re not using LINQ for any reasons

Agenda

• LINQ and the related things

• LINQ inside.

• Performance tips

• Advanced usages

• Others

What’s LINQ

• Is it just a db access technology?

• Is it just a piece of “syntactic sugar”?

NO!

“I’ll never use C# without LINQ”

- Dflying ChenCTO

Shanghai Baisheng Tech Co., Ltd.

WHAT’S LINQ

var odd =

from i in new int[] { 1, 2, 3, 4, 5 }

where i % 2 != 0

select i;

About LINQ

• Language Integrated Query

• Since .NET Framework 3.5 with C# 3.0/VB 9.0

• The technology combined serveral others

– Extension Method

– Lambda Expression

– Anonymous Method

– Anonymous Class

– etc.

LINQ to…

• LINQ != LINQ to SQL– A new way to access and manipulate data

– Not only the data in SQL Server

• What can we “LINQ to”?– LINQ to SQL

– LINQ to XML

– LINQ to Object

– LINQ to Entity (from MS ADO.NET Entity Fx)

• And we can also…

LINQ to… (Cont.)

• LINQ to Google

• LINQ to System Search

• LINQ to NHibernate

• LINQ to Active Directory

• LINQ to Lucene

• LINQ to Flickr

• LINQ to Excel

• and more and more and more…

Some Concerpts

• LINQ

• LINQ to SQL

• LINQ Provider

• http://jeffreyzhao.cnblogs.com/archive/2008/06/04/ajax-linq-lambda-expression.html

THINGS RELATED TO LINQ

Extension Method

Anonymous Method

Lambda Expression

Anonymous Class

…

Extension Method

• “syntactic sugar” – I agree with that.

• More elegant programming style

<%=

HttpUtility.HtmlEncode(

"<script>…</script>")

%>

<%=

"<script>…</script>".HtmlEnocde();

%>

public static class StringExtensions{

public static string HtmlEncode(this s){

return HttpUtility.HtmlEncode(s);

}

}

=>

Anonymous Method

• Inline delegates without method declaration

• Can easily access the local variables

– Magic of compiler

void SomeMethod {

int intVar;

Action action = delegate() { intVar = 10; };

action();

}

Lambda Expression

• Functional programming style

• “=>” operator

• A lambda expression can represent:

– An anonymous method

– An expression tree

– http://jeffreyzhao.cnblogs.com/archive/2008/06/04/ajax-linq-lambda-expression.html

Things below are all equivalent

Func<int, int, bool> predicate = (x, y) => { return x > y; };

Func<int, int, bool> predicate = (x, y) => x > y;

Func<int, int, bool> predicate = delegate(int x, int y) { return x > y; };

And we can do more like…

Func<int, int, bool> predicate = (x, y) => {

var dayService = new DayService();

if (dayService.IsApirlFools(DateTime.Today)){

return x < y;

} else {

return x > y;

}

};

DEMO 1

Extension Method

Lambda Expression for Anonymous method

Expression Tree

• A GREAT way to represent in lots of scenarios

• Can be constructed by lambda expression in compile time

• Can also be constructed programically

– Lambda expression would be convert to this by compiler

System.Linq.Expressions.Expression<TDelegate>

Expression Tree Samples

Expression<Func<int>> constantExpr = () => 5;

Expression<Func<int, int, int>> simpleExpr = (x, y) => x + y;

Expression<Func<int, int, bool>> complexExpr =

(x, y) => new Random(DateTime.Now.Millisecond).Next(x) > y;

Programmically Construction

• See what complier do for us…

Expression<Func<int, int>> negateExpr = x => -x;

ParameterExpression param = Expression.Parameter(typeof(int), "x");

Expression<Func<int, int>> negateExpr =

Expression.Lambda<Func<int, int>>(

Expression.Negate(param),

new ParameterExpression[] { param });

Expression Hierarchy

System.Linq.Expressions.ExpressionBinaryExpressionConditionalExpressionConstantExpressionInvocationExpressionLambdaExpressionMemberExpressionMethodCallExpressionNewExpressionNewArrayExpressionMemberInitExpressionListInitExpressionParameterExpressionTypeBinaryExpressionUnaryExpression

The Factory Methods

• There’re factory methods in Expression class for us to build an Expression Tree.

• Examples– New: Creates a NewExpression.

– Negate: Creates a UnaryExpression that represents an arithmetic negation operation

– And: Creates a BinaryExpression that represents a bitwise AND operation.

– ArrayIndex: Creates an Expression that represents applying an array index operator.

Tips of Construct Expression Trees

• Process

– Preparing parameter expressions at first.

– Construct the body of expression tree with the factory methods.

– Wrap the whole expression body with LambdaExpression at the end.

• Tools can help us

– Expression Tree Visualizer

– .NET Reflector (a must-have for .NET programmer)

DEMO 2

Lambda Expression for Expression Tree

Construct an Expression Tree Programically

Question

• What’s the difference between these two?

var intList = new List<int>() { 1, 2, 3, 4, 5 };

foreach (int i in intList.Where(i => i % 2 == 1))

{

Console.WriteLine(i);

}

var intList = new List<int>() { 1, 2, 3, 4, 5 }.AsQueryable();

foreach (int i in intList.Where(i => i % 2 == 1))

{

Console.WriteLine(i);

}

Answer:

• The lambda expression in the first code snippet represents an Anonymous Method

• The lambda expression in the second code snippet constructs an Expression Tree

Now we know about Extension Method and Lambda Expression, but…

Where’s LINQ?

Please wait for the

second part of the session…

Next, We’ll Focus More on…

• LINQ– Usage– Pros & Cons

• Performance– Benchmark– Improvements

• Advanced topics– Use Expression Tree in different scenarios.– LINQ Provider

• Others

References

• http://msdn.microsoft.com

• http://en.wikipedia.org/wiki/Linq

• http://rednaxelafx.javaeye.com/blog/237822

• http://code.msdn.microsoft.com/csharpsamples