是的，两者都会让你延期执行。

区别在于IQueryable<T>是允许LINQ-to- sql (LINQ. sql)的接口。对任何事情)去工作。因此，如果在IQueryable<T>上进一步细化查询，该查询将在数据库中执行(如果可能的话)。

对于IEnumerable<T>情况，它将是LINQ-to-object，这意味着所有与原始查询匹配的对象都必须从数据库加载到内存中。

在代码:

IQueryable<Customer> custs = ...;
// Later on...
var goldCustomers = custs.Where(c => c.IsGold);

该代码将只对选择的黄金客户执行SQL。另一方面，下面的代码将在数据库中执行原始查询，然后在内存中过滤出非黄金客户:

IEnumerable<Customer> custs = ...;
// Later on...
var goldCustomers = custs.Where(c => c.IsGold);

这是一个非常重要的区别，在许多情况下，使用IQueryable<T>可以避免从数据库返回太多行。另一个主要的例子是分页:如果你在IQueryable上使用Take和Skip，你将只得到请求的行数;在IEnumerable< t>上这样做会导致你所有的行都被载入内存。

是的，两者都使用延迟执行。让我们使用SQL Server分析器....来说明两者的区别

当我们运行以下代码时:

MarketDevEntities db = new MarketDevEntities();

IEnumerable<WebLog> first = db.WebLogs;
var second = first.Where(c => c.DurationSeconds > 10);
var third = second.Where(c => c.WebLogID > 100);
var result = third.Where(c => c.EmailAddress.Length > 11);

Console.Write(result.First().UserName);

在SQL Server分析器中，我们发现一个命令等于:

"SELECT * FROM [dbo].[WebLog]"

在有100万条记录的WebLog表上运行这段代码大约需要90秒。

因此，所有的表记录都作为对象加载到内存中，然后每个. where()都将是内存中针对这些对象的另一个过滤器。

当我们在上面的例子(第二行)中使用IQueryable而不是IEnumerable时:

在SQL Server分析器中，我们发现一个命令等于:

"SELECT TOP 1 * FROM [dbo].[WebLog] WHERE [DurationSeconds] > 10 AND [WebLogID] > 100 AND LEN([EmailAddress]) > 11"

使用IQueryable运行这段代码大约需要4秒钟。

IQueryable有一个名为Expression的属性，它存储了一个树表达式，当我们在示例中使用结果时开始创建这个树表达式(称为延迟执行)，在结束时，这个表达式将被转换为一个SQL查询，在数据库引擎上运行。

除了上面的，有趣的是，如果你使用IQueryable而不是IEnumerable，你可以得到异常:

如果products是一个IEnumerable，下面的工作很好:

products.Skip(-4);

然而，如果products是一个IQueryable对象，并且它试图从DB表中访问记录，那么你会得到这个错误:

offset子句中指定的偏移量不能为负。

这是因为构造了以下查询:

SELECT [p].[ProductId]
FROM [Products] AS [p]
ORDER BY (SELECT 1)
OFFSET @__p_0 ROWS

OFFSET不能为负值。

一般来说，您希望保留查询的原始静态类型，直到有必要。

出于这个原因，你可以将你的变量定义为'var'，而不是IQueryable<>或IEnumerable<>，你会知道你没有改变类型。

如果您开始使用IQueryable<>，通常希望将其保留为IQueryable<>，直到有一些令人信服的理由更改它。这样做的原因是您希望为查询处理器提供尽可能多的信息。例如，如果你只打算使用10个结果(你已经调用Take(10))，那么你想让SQL Server知道这一点，这样它就可以优化它的查询计划，只向你发送你将使用的数据。

A compelling reason to change the type from IQueryable<> to IEnumerable<> might be that you are calling some extension function that the implementation of IQueryable<> in your particular object either cannot handle or handles inefficiently. In that case, you might wish to convert the type to IEnumerable<> (by assigning to a variable of type IEnumerable<> or by using the AsEnumerable extension method for example) so that the extension functions you call end up being the ones in the Enumerable class instead of the Queryable class.

“IEnumerable”和“IQueryable”之间的主要区别在于在哪里执行筛选逻辑。一个在客户端(内存中)执行，另一个在数据库中执行。

例如，我们可以考虑一个例子，我们的数据库中有一个用户的10,000条记录，假设只有900个是活动用户，所以在这种情况下，如果我们使用“IEnumerable”，那么首先它将所有10,000条记录加载到内存中，然后应用IsActive筛选器，最终返回900个活动用户。

而另一方面，在同样的情况下，如果我们使用“IQueryable”，它将直接应用数据库上的IsActive过滤器，直接从那里将返回900个活跃用户。

之前已经说了很多，但回到根源，以一种更专业的方式:

IEnumerable是一个在内存中可以枚举的对象的集合——一个在内存中的序列，使得迭代成为可能(使得在每一个循环中都很容易，尽管你可以只使用IEnumerator)。它们就这样存在于记忆中。 IQueryable是一个表达式树，它将在某个时刻被转换成其他东西，并具有枚举最终结果的能力。我想这就是大多数人困惑的地方。

它们显然有着不同的内涵。

IQueryable表示一个表达式树(简单地说，就是一个查询)，一旦调用了发布api，它就会被底层查询提供者转换成其他东西，比如LINQ聚合函数(Sum, Count等)或ToList[数组，字典，…]。IQueryable对象也实现了IEnumerable, IEnumerable<T>，因此如果它们表示一个查询，那么该查询的结果可以被迭代。这意味着IQueryable不只是查询。正确的术语是它们是表达式树。

现在，这些表达式如何执行以及它们转向什么都取决于所谓的查询提供者(我们可以想到表达式执行器)。

在实体框架世界(即神秘的底层数据源提供程序或查询提供程序)中，IQueryable表达式被转换为本地T-SQL查询。Nhibernate对它们做了类似的事情。例如，您可以按照《LINQ:构建IQueryable Provider链接》中描述的概念编写自己的查询工具，并且您可能希望为您的产品存储提供者服务提供一个自定义查询API。

基本上，IQueryable对象一直在被构造直到我们显式地释放它们并告诉系统把它们重写成SQL或者其他什么然后发送到执行链进行后续处理。

就像延迟执行一样，它是一个LINQ特性，在内存中保留表达式树方案，并仅在需要时将其发送到执行中，无论何时针对序列调用某些api(相同的Count、ToList等)。

The proper usage of both heavily depends on the tasks you're facing for the specific case. For the well-known repository pattern I personally opt for returning IList, that is IEnumerable over Lists (indexers and the like). So it is my advice to use IQueryable only within repositories and IEnumerable anywhere else in the code. Not saying about the testability concerns that IQueryable breaks down and ruins the separation of concerns principle. If you return an expression from within repositories consumers may play with the persistence layer as they would wish.

A little addition to the mess :) (from a discussion in the comments)) None of them are objects in memory since they're not real types per se, they're markers of a type - if you want to go that deep. But it makes sense (and that's why even MSDN put it this way) to think of IEnumerables as in-memory collections whereas IQueryables as expression trees. The point is that the IQueryable interface inherits the IEnumerable interface so that if it represents a query, the results of that query can be enumerated. Enumeration causes the expression tree associated with an IQueryable object to be executed. So, in fact, you can't really call any IEnumerable member without having the object in the memory. It will get in there if you do, anyways, if it's not empty. IQueryables are just queries, not the data.