构建Linq查询以实现最快性能的正确方法是什么？

Question

有类似的问题已经在这里问过，但都不符合我的需求。
我编写了测试用例来查看哪个更快。但我觉得我的linq代码仍然很慢。如何构建更快的性能的linq代码？

其他人说使用双倍.Tolist()会导致操作变慢，但当我测试它时，它比任何其他测试都要快。

测试：

Preparation
---------------------------------------------------------------
return Properties of UserInfo(userinf, true){
    UserID = userinf.UserID;
    FirstName = userinf.user.FirstName;
    MiddleName = userinf.user.MiddleName;
    LastName = userinf.user.LastName;
    LoginID = userinf.user.LoginID;
    Birthday = userinf.Birthday;
}

skip = 0;
take = 100;

total table records = 304;

Linq to Entity Framework 

Fiddler: v2.4.0.0

https://127.0.0.1/..../RetrieveUserInfo?skip=0&take=100
{
    "client":{
        "SessionID":"5433ab64-7e0d-444f-b886-a901ea9a0601"
    },
    "session":{
        "SessionID":"35b75daa-25ad-45a4-9f99-0e69ec3b66a4"
    }
}

---

//Test 1
//1) 00:00:15.3068755 -- Attempt1
//2) 00:00:13.8207905 -- Attempt2
//3) 00:00:16.2489294 -- Attempt3

var list = (from usr in dbase.userinfoes
            select usr).OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();

userlist = (from i in list
            select new UserInfo(i, true)).ToList();


///Test 2
//1) 00:00:15.3908803
//2) 00:00:14.8818512
//3) 00:00:19.4761140

var list = (from usr in dbase.userinfoes.AsEnumerable().OrderBy(i => i.UserID).Skip(skip).Take(take).ToList()
            select new UserInfo(usr, true)).ToList();


//Test 3
//1) 00:00:30.1937270
//2) 00:00:24.1003784
//3) 00:00:28.8806519

var list = dbase.userinfoes.OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();
userlist = (from i in list select new UserInfo(i, true)).ToList();


//Test 4
//1) 00:00:57.2652754
//2) 00:00:54.4051118
//3) 00:00:55.3251644

var list = (from usr in dbase.userinfoes
            select usr).ToList();

userlist = (from i in list
            select new UserInfo(i, true)).OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();


//Test 5
//1) 00:01:06.8378229
//2) 00:01:01.2845053
//3) 00:00:55.0721499

var list = from usr in dbase.userinfoes
           select usr;

userlist = (from i in list.AsEnumerable()
            select new UserInfo(i, true)).OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();


// Test 6
// VERY LONG. It tooks all records first and construct UserInfo one by one before doing the skip and take

var list = (from usr in dbase.userinfoes.AsEnumerable()
            select new UserInfo(usr, true)).OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();


//Test 7
// VERY LONG. It tooks all records first and construct UserInfo one by one before doing the skip and take

var list = from usr in dbase.userinfoes.AsEnumerable()
           select new UserInfo(usr);

为了更快的搜索，需要正确的代码。感谢casperOne指出在服务器上执行排序、跳过和取出操作会更快。

以下是最终代码：

var list = (from usr in dbase.userinfoes
                .OrderBy(i => i.UserID)
                .Skip(skip)
                .Take(take)
                .AsEnumerable()
            select new UserInfo(usr, true)).ToList();   

1) 00:00:10.9210513
2) 00:00:10.8270973
3) 00:00:10.8250151

感谢Richard Neil Ilagan提供最终代码。

- fiberOptics

---

我对测试如何实现有一些疑问。无论如何，有一篇很长的文章解决了这类问题：http://msdn.microsoft.com/en-us/data/hh949853.aspx - as-cii

谢谢链接，我正在阅读它。 - fiberOptics

你应该同时发布基准测试代码，因为这些结果似乎没有太多意义。例如，测试1和3非常相似，除了测试1中有一个额外的Select调用，但是测试3需要两倍的时间。 - Mike Zboray

我不知道哪个代码更好，但是正如你所说的，测试1和3是相同的，那么在实现相同数据结果的同时，它们的性能也是相同的吗？ - fiberOptics

Answer 1

以下是每个测试的表现原因以及您所看到的内容的原因：

测试1： 该测试旨在评估网站的加载速度。如果测试结果显示速度较慢，则可能是由于服务器响应时间过长或者页面文件太大导致的。要提高速度，可以考虑优化代码，压缩图像和静态文件等。

///Test 2
//1) 00:00:15.3068755 -- Attempt1
//2) 00:00:13.8207905 -- Attempt2
//3) 00:00:16.2489294 -- Attempt3

var list = (from usr in dbase.userinfoes
            select usr).OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();

userlist = (from i in list
            select new UserInfo(i, true)).ToList();

这是绝对最快的方法。它之所以最快，是因为排序、跳过和取出操作都在服务器上执行。由于您可能拥有索引、服务器很强大等原因，它可以比在客户端上将整个集合实现后再执行操作要快得多。

UserInfo仅在后处理列表上构建。

测试2：

///Test 2
//1) 00:00:15.3908803
//2) 00:00:14.8818512
//3) 00:00:19.4761140

var list = (
    from usr in dbase.userinfoes.AsEnumerable().
        OrderBy(i => i.UserID).Skip(skip).Take(take).ToList()
    select new UserInfo(usr, true)
).ToList();

这个操作与测试7的性能影响应该是一样的；调用AsEnumerable会强制所有后续操作在内存中执行（调用OrderBy将要求您在对实例进行排序之前将它们全部实例化）。

这有点反常。我很想看看发送到服务器的SQL是什么（假设您正在使用SQL Server或某个基于SQL的后端），以确保它选择了所有记录。

UserInfo只在后处理列表上构建。

测试3：

//Test 3
//1) 00:00:30.1937270
//2) 00:00:24.1003784
//3) 00:00:28.8806519

var list = dbase.userinfoes.OrderBy(i => i.UserID).
    Skip(skip).Take(take).ToList();
userlist = (from i in list select new UserInfo(i, true)).ToList();

再次强调，order by、skip 和 take 都是在服务器上执行的。你将列表实例化了两次（有两个 ToList 调用），这是我能看到的唯一的开销解释。

UserInfo 只在后处理列表上构建。

测试 4：

//Test 4
//1) 00:00:57.2652754
//2) 00:00:54.4051118
//3) 00:00:55.3251644

var list = (from usr in dbase.userinfoes
            select usr).ToList();

userlist = (from i in list select new UserInfo(i, true)).
    OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();

现在，您正在内存中完整地实例化整个列表，因此现在有更多的开销。

UserInfo 构建于预处理列表上。

测试 5：

//Test 5
//1) 00:01:06.8378229
//2) 00:01:01.2845053
//3) 00:00:55.0721499

var list = from usr in dbase.userinfoes
           select usr;

userlist = (from i in list.AsEnumerable()
            select new UserInfo(i, true)).
    OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();

与测试二相同，您将在客户端执行所有操作。

在预处理列表上构建了“UserInfo”。

测试6：

// Test 6
// VERY LONG. It tooks all records first and construct 
// UserInfo one by one before doing the skip and take

var list = (from usr in dbase.userinfoes.AsEnumerable()
            select new UserInfo(usr, true)).
    OrderBy(i => i.UserID).Skip(skip).Take(take).ToList();

在预处理列表上构建UserInfo。

再次，所有操作都在客户端上执行。

// Test 7
// VERY LONG. It tooks all records first and construct 
// UserInfo one by one before doing the skip and take

var list = from usr in dbase.userinfoes.AsEnumerable()
           select new UserInfo(usr);

再次强调，所有操作都在客户端上执行。

UserInfo基于预处理列表构建。

我注意到所有这些测试中有一个区别，那就是您调用UserInfo实例的构造函数的位置。在性能良好的地方，您尽可能推迟构造UserInfo实例的时间（在执行order、take、skip操作之后），而当性能较差时，您提前构造UserInfo实例，即在这些操作发生之前（通常会更多地调用UserInfo构造函数）。

也就是说，您的性能问题可能在UserInfo类的构造函数中，而不是在LINQ中。一般来说，当您让IQueryable<T>提供程序在底层数据源上执行操作时，它比在客户端内存中执行这些操作通常更快。

但是，如果没有看到构造函数代码，就无法确定问题所在，但您的数字确实表明问题在那里，而不是在LINQ中。

- casperOne