我在内存中有一个大的List，这个List来自一个包含大约20个属性的类。
我想基于其中一个属性来过滤这个列表，对于我只需要这个属性的任务，我只需要这个属性的列表。因此我的查询结果如下：
data.Select(x => x.field).Where(x => x == "desired value").ToList()
使用 Select 还是使用 Where 会给我带来更好的性能表现？
data.Where(x => x.field == "desired value").Select(x => x.field).ToList()
请告诉我这是否与我所保存的数据类型或字段类型有关。请注意，我还需要这些对象进行其他任务，因此无法在加载到内存之前首先对它们进行过滤。
使用Where先过滤集合再进行Select操作的方法性能更佳，因为它在仅对过滤后的值执行
Select时。从数学上讲，使用Where先进行筛选需要N + N'个操作，在此处N'是符合Where条件的集合项数量。因此，它最少需要N + 0 = N个操作（如果没有任何项通过此Where条件），最多需要N + N = 2 * N个操作（如果所有项均满足条件）。同时，使用
Select优先的方法始终需要2 * N个操作，因为它会遍历所有对象以获取属性，然后遍历所有对象以过滤它们。基准测试证明
我已经完成了基准测试来证明我的答案。
结果：
Condition value: 50
Where -> Select: 88 ms, 10500319 hits
Select -> Where: 137 ms, 20000000 hits
Condition value: 500
Where -> Select: 187 ms, 14999212 hits
Select -> Where: 238 ms, 20000000 hits
Condition value: 950
Where -> Select: 186 ms, 19500126 hits
Select -> Where: 402 ms, 20000000 hits
如果您多次运行基准测试，那么您会发现Where -> Select方法的性能会不时地变化，而Select -> Where方法总是需要2N次操作。
IDEOne演示:
代码：
class Point
{
public int X { get; set; }
public int Y { get; set; }
}
class Program
{
static void Main()
{
var random = new Random();
List<Point> points = Enumerable.Range(0, 10000000).Select(x => new Point { X = random.Next(1000), Y = random.Next(1000) }).ToList();
int conditionValue = 250;
Console.WriteLine($"Condition value: {conditionValue}");
Stopwatch sw = new Stopwatch();
sw.Start();
int hitCount1 = 0;
var points1 = points.Where(x =>
{
hitCount1++;
return x.X < conditionValue;
}).Select(x =>
{
hitCount1++;
return x.Y;
}).ToArray();
sw.Stop();
Console.WriteLine($"Where -> Select: {sw.ElapsedMilliseconds} ms, {hitCount1} hits");
sw.Restart();
int hitCount2 = 0;
var points2 = points.Select(x =>
{
hitCount2++;
return x.Y;
}).Where(x =>
{
hitCount2++;
return x < conditionValue;
}).ToArray();
sw.Stop();
Console.WriteLine($"Select -> Where: {sw.ElapsedMilliseconds} ms, {hitCount2} hits");
Console.ReadLine();
}
}
这些问题可能对您也很有趣。它们与 Select 和 Where 无关，但涉及到 LINQ 的性能顺序：
Point只有两个属性且轻量级的情况下，这可能是正确的，但如果我们处理大型对象，则可能会有所不同。 - Hari Prasad更新：
@YeldarKurmangaliyev 给出了具体的示例和基准测试的答案。我运行了类似的代码来验证他的说法，我们的结果完全相反，因为我使用的测试对象不像他用于运行测试的简单的Point类型那么简单。
这段代码看起来非常像他的代码，只是我将类名从Point更改为EnumerableClass。
以下是我用于构成EnumerableClass类的类：
public class EnumerableClass
{
public int X { get; set; }
public int Y { get; set; }
public String A { get; set; }
public String B { get; set; }
public String C { get; set; }
public String D { get; set; }
public String E { get; set; }
public Frame F { get; set; }
public Gatorade Gatorade { get; set; }
public Home Home { get; set; }
}
public class Home
{
private Home(int rooms, double bathrooms, Stove stove, InternetConnection internetConnection)
{
Rooms = rooms;
Bathrooms = (decimal) bathrooms;
StoveType = stove;
Internet = internetConnection;
}
public int Rooms { get; set; }
public decimal Bathrooms { get; set; }
public Stove StoveType { get; set; }
public InternetConnection Internet { get; set; }
public static Home GetUnitOfHome()
{
return new Home(5, 2.5, Stove.Gas, InternetConnection.Att);
}
}
public enum InternetConnection
{
Comcast = 0,
Verizon = 1,
Att = 2,
Google = 3
}
public enum Stove
{
Gas = 0,
Electric = 1,
Induction = 2
}
public class Gatorade
{
private Gatorade(int volume, Color liquidColor, int bottleSize)
{
Volume = volume;
LiquidColor = liquidColor;
BottleSize = bottleSize;
}
public int Volume { get; set; }
public Color LiquidColor { get; set; }
public int BottleSize { get; set; }
public static Gatorade GetGatoradeBottle()
{
return new Gatorade(100, Color.Orange, 150);
}
}
public class Frame
{
public int X { get; set; }
public int Y { get; set; }
private Frame(int x, int y)
{
X = x;
Y = y;
}
public static Frame GetFrame()
{
return new Frame(5, 10);
}
}
类Frame、Gatorade和Home都有一个静态方法，用于返回它们类型的实例。
以下是主程序：
public static class Program
{
const string Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
private static readonly Random Random = new Random();
private static string RandomString(int length)
{
return new string(Enumerable.Repeat(Chars, length)
.Select(s => s[Random.Next(s.Length)]).ToArray());
}
private static void Main()
{
var random = new Random();
var largeCollection =
Enumerable.Range(0, 1000000)
.Select(
x =>
new EnumerableClass
{
A = RandomString(500),
B = RandomString(1000),
C = RandomString(100),
D = RandomString(256),
E = RandomString(1024),
F = Frame.GetFrame(),
Gatorade = Gatorade.GetGatoradeBottle(),
Home = Home.GetUnitOfHome(),
X = random.Next(1000),
Y = random.Next(1000)
})
.ToList();
const int conditionValue = 250;
Console.WriteLine(@"Condition value: {0}", conditionValue);
var sw = new Stopwatch();
sw.Start();
var firstWhere = largeCollection
.Where(x => x.Y < conditionValue)
.Select(x => x.Y)
.ToArray();
sw.Stop();
Console.WriteLine(@"Where -> Select: {0} ms", sw.ElapsedMilliseconds);
sw.Restart();
var firstSelect = largeCollection
.Select(x => x.Y)
.Where(y => y < conditionValue)
.ToArray();
sw.Stop();
Console.WriteLine(@"Select -> Where: {0} ms", sw.ElapsedMilliseconds);
Console.ReadLine();
Console.WriteLine();
Console.WriteLine(@"First Where's first item: {0}", firstWhere.FirstOrDefault());
Console.WriteLine(@"First Select's first item: {0}", firstSelect.FirstOrDefault());
Console.WriteLine();
Console.ReadLine();
}
}
结果：
我运行了多次测试并发现，在集合大小为1000000时，
表现更好。.Select().Where() 比 .Where().Select().
这是第一个测试结果，我强制将每个
EnumerableClass对象的Y值设置为5，因此每个项目都通过了Where：
Condition value: 250
Where -> Select: 149 ms
Select -> Where: 115 ms
First Where's first item: 5
First Select's first item: 5
EnumerableClass对象的Y值为251，因此没有任何项目通过了Where:Condition value: 250
Where -> Select: 110 ms
Select -> Where: 100 ms
First Where's first item: 0
First Select's first item: 0
显然，结果非常依赖于集合的状态:
我一遍又一遍地提到的集合的状态包括:
回应评论：
此外，@Enigmativity说，在知道Where的结果以便确定先放置Where还是先放置之前，这是一个进退两难的局面。理论上，他是正确的，而且不出所料，在计算机科学的另一个领域Scheduling中也存在这种情况。
最佳调度算法是最短作业优先，我们首先安排执行时间最短的作业。但是，有人怎么知道一个特定作业需要多长时间才能完成呢？嗯，答案是：
在准确估计运行时间的专门环境中使用最短作业优先。
因此，正如我在一开始时所说的（这也是我的回答的第一个、较短版本），这个问题的正确答案将取决于集合的当前状态。
一般来说，
那么本答案开头提到的指导方针将对您有用。
Where根据条件返回的记录比Select返回的记录少。而Select首先返回所有记录，然后对其进行条件过滤。因此，使用Where应该会提高性能。不过，你可以尝试在一个包含 10000 条以上记录的巨大测试数据库中测试你的查询。好问题！ - Keyur PATEL