首页 诗词 字典 板报 句子 名言 友答 励志 学校 网站地图
当前位置: 首页 > 教程频道 > 网站开发 > asp.net >

LINQ的两种写法有什么区别吗?解决办法

2013-08-01 
LINQ的两种写法有什么区别吗?一直很疑惑的两种写法,两种写法相同效果的例子SampleData.Books// 查询操作符

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 
编译器都是一样的认,也没有性能区别

[解决办法]
引用:
“Lambda 表达式”是一个匿名函数,Lambda 运算符 =>
LINQ 
编译器都是一样的认,也没有性能区别


+1
[解决办法]
都一样的,我觉得表达式更贴近人的思维
[解决办法]
都一样的
[解决办法]
一种是Lambda表达式
一种是标准查询表达式

最后编译成都会转化成相同的SQL语句
[解决办法]
引用:
都一样的


是的。
[解决办法]
两个当然是一样的。
linq的操作符、linq to sql、linq to xml都是 对linq的扩展,你可以自定义Provider。
利用 表达式树 实现自己的功能。
[解决办法]
引用:
“Lambda 表达式”是一个匿名函数,Lambda 运算符 =>
LINQ 
编译器都是一样的认,也没有性能区别



如梦出现了。。。。
[解决办法]
这是因为你写的太简单了。试试经常写一些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);
                });
        }


它就采取了清晰自然的写法。

热点排行