9

类似的问题已经在这里提出，但没有一个适合我的需要。
我制作了测试用例，看看哪个更快。但我觉得我的 linq 代码仍然很慢。如何构建 linq 代码以获得更快的性能？

其他人说使用 double.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

提琴手：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提供最终代码。

4

1 回答 1

6

以下是每个人都按原样执行的原因以及您所见所闻的原因：

测试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();

这绝对是最快的。它是最快的，因为ordering、skip 和take 都是在服务器上执行的。因为你可能有索引，服务器很强大（强大）等等。它可以比你在客户端实现整个集合然后在那里执行操作更快地处理这些操作。

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 服务器或一些基于 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 中。

于 2012-10-25T13:27:10.060 回答