LINQ的两种写法有什么区别吗？
一直很疑惑的两种写法，
两种写法相同效果的例子
SampleData.Books// 查询操作符 from book in SampleData.Books //查询表达式
.Where(book => book.Title == "Funny Stories") where book.Title == "Funny Stories"
.OrderBy(book => book.Title) orderby book.Title
.Select(book => new {book.Title, book.Price}); select new {book.Title, book.Price};
我经常用“查询操作符”，因为我觉得那更接近于c#编程，容易理解。
你们呢？
请问它们两种的区别除了写法不同还有什么区别，效率上有什么不同？
谢谢呀，
[解决办法]
“Lambda 表达式”是一个匿名函数，Lambda 运算符 =>
LINQ
编译器都是一样的认，也没有性能区别
[解决办法]
+1
[解决办法]
都一样的，我觉得表达式更贴近人的思维
[解决办法]
都一样的
[解决办法]
一种是Lambda表达式
一种是标准查询表达式
最后编译成都会转化成相同的SQL语句
[解决办法]
是的。
[解决办法]
两个当然是一样的。
linq的操作符、linq to sql、linq to xml都是 对linq的扩展,你可以自定义Provider。
利用 表达式树 实现自己的功能。
[解决办法]
如梦出现了。。。。
[解决办法]
这是因为你写的太简单了。试试经常写一些5、6个数据集合join的表达式，看看哪一种更清晰？！
比说这个方法：
internal void Render(Scene scene, bool parallel)
{
int[] rgb = new int[screenWidth * screenHeight];
var pixelsQuery = from y in Enumerable.Range(0, screenHeight).AsParallel().WithDegreeOfParallelism(parallel ? 2 : 1)
let recenterY = -(y - (screenHeight / 2.0)) / (2.0 * screenHeight)
select from x in Enumerable.Range(0, screenWidth)
let recenterX = (x - (screenWidth / 2.0)) / (2.0 * screenWidth)
let point =
Vector.Norm(Vector.Plus(scene.Camera.Forward,
Vector.Plus(Vector.Times(recenterX, scene.Camera.Right),
Vector.Times(recenterY, scene.Camera.Up))))
let ray = new Ray() { Start = scene.Camera.Pos, Dir = point }
let computeTraceRay = (Func<Func<TraceRayArgs, Color>, Func<TraceRayArgs, Color>>)
(f => traceRayArgs =>
(from isect in
from thing in traceRayArgs.Scene.Things
select thing.Intersect(traceRayArgs.Ray)
where isect != null
orderby isect.Dist
let d = isect.Ray.Dir
let pos = Vector.Plus(Vector.Times(isect.Dist, isect.Ray.Dir), isect.Ray.Start)
let normal = isect.Thing.Normal(pos)
let reflectDir = Vector.Minus(d, Vector.Times(2 * Vector.Dot(normal, d), normal))
let naturalColors =
from light in traceRayArgs.Scene.Lights
let ldis = Vector.Minus(light.Pos, pos)
let livec = Vector.Norm(ldis)
let testRay = new Ray() { Start = pos, Dir = livec }
let testIsects = from inter in
from thing in traceRayArgs.Scene.Things
select thing.Intersect(testRay)
where inter != null
orderby inter.Dist
select inter
let testIsect = testIsects.FirstOrDefault()
let neatIsect = testIsect == null ? 0 : testIsect.Dist
let isInShadow = !((neatIsect > Vector.Mag(ldis))
[解决办法]
(neatIsect == 0))
where !isInShadow
let illum = Vector.Dot(livec, normal)
let lcolor = illum > 0 ? Color.Times(illum, light.Color) : Color.Make(0, 0, 0)
let specular = Vector.Dot(livec, Vector.Norm(reflectDir))
let scolor = specular > 0
? Color.Times(Math.Pow(specular, isect.Thing.Surface.Roughness),
light.Color)
: Color.Make(0, 0, 0)
select Color.Plus(Color.Times(isect.Thing.Surface.Diffuse(pos), lcolor),
Color.Times(isect.Thing.Surface.Specular(pos), scolor))
let reflectPos = Vector.Plus(pos, Vector.Times(.001, reflectDir))
let reflectColor = traceRayArgs.Depth >= MaxDepth
? Color.Make(.5, .5, .5)
: Color.Times(isect.Thing.Surface.Reflect(reflectPos),
f(new TraceRayArgs(new Ray()
{
Start = reflectPos,
Dir = reflectDir
},
traceRayArgs.Scene,
traceRayArgs.Depth + 1)))
select naturalColors.Aggregate(reflectColor,
(color, natColor) => Color.Plus(color, natColor))
).DefaultIfEmpty(Color.Background).First())
let traceRay = Y(computeTraceRay)
select new { X = x, Y = y, Color = traceRay(new TraceRayArgs(ray, scene, 0)) };
int rowsProcessed = 0;
pixelsQuery.ForAll(row =>
{
foreach (var pixel in row)
{
rgb[pixel.X + (pixel.Y * screenWidth)] = pixel.Color.ToInt32();
}
int processed = Interlocked.Increment(ref rowsProcessed);
if (processed % rowsPerUpdate == 0
[解决办法]
processed >= screenHeight) updateImageHandler(rgb);
});
}
它就采取了清晰自然的写法。