linq 的不同操作方法的区别

.Net技术 码拜 4年前 (2016-02-22) 174次浏览
var q = from x in db.User where x.Error == false && x.USE == true select x;
var z = db.User.Where(s => s.Error == false && s.USE == true);
比方说这两条都能得到本人想要的结果。但是这两者有什么区别?效率上和功能上。
谢谢。
解决方案

3

下面的是拉姆达表达式,个人认为更易懂

3

linq和 lambda的写法。
个人偏向于lambda,原因是看起来简短干净。

3

效率功能都一样,只是书写方式不一样

3

两种写着都很顺手,本质上无区别

5

所谓“效率”,本人动手测试。
所谓功能,你可以看一下微软的示例 LINQRayTracer 中表示这个小程序的核心算法时是怎么写的

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

也就是说,别人写几百条语句,你写一条。这就好像 sql 语言,有的人在一个存储过程中写几百行独立过程化语句,有的人则用一、两条说明性的sql 语句来描述查询。这就是区别。这不是纠结什么“效率”,而是为了得到不同的“表现力”。

3

基本上,你的大多数“过程”设计都可以用几十行查询代码来作为“引擎”。假如你能把几十行离散的查询代码表示为一条相似 sql 一样的关系查询语言代码,就非常规整。当然,前提是你花至少半年时间专门学习过、训练过 sql 关系查询语言在各类型、各行业查询模式的系统应用上的表示方式(假如只是自学的,可能就不太会)。
当你做的事情比较简单时,基本上选择适合本人的方式。但是当你做的事情是比较复杂的时候,脱离了过程化、面向说明而非面向过程的方式,往往成为最终标准。

CodeBye 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权 , 转载请注明linq 的不同操作方法的区别
喜欢 (0)
[1034331897@qq.com]
分享 (0)