如何为每个hashmap？(How to for each the hashmap? [duplicate])

 这取决于您的存储库类的设置方式。 如果您正在立即执行查询，即如果您的GetAll()方法返回类似IEnumerable<T>或IList<T> ，那么是的，这可能很容易成为性能问题，您通常应该避免这种情况，除非你真的想一次加载所有记录。 
 
 另一方面，如果您的GetAll()方法返回IQueryable<T> ，则可能根本没有问题，具体取决于您是否信任编写查询的人。 返回IQueryable<T>将允许调用者在实际生成SQL代码之前进一步细化搜索条件。 性能方面，如果使用您的代码的开发人员在执行查询之前未应用任何过滤器，那么这只会是一个问题。 如果你足够信任它们给它们足够的绳索来挂起它们（并且可能会降低你的数据库性能），那么只返回IQueryable<T>可能就足够了。 
 
 如果您不信任它们，那么，正如其他人所指出的那样，您可以通过使用Skip()和Take()扩展方法来实现简单的分页来限制查询返回的记录数，但请注意，它可以如果人们在进入下一页之前对数据库进行了更改，则记录会滑过裂缝。 与不断变化的数据库无缝地进行分页工作比很多人想象的要困难得多。 
 
 另一种方法是将GetAll()方法替换为需要调用者在返回结果之前应用过滤器的方法： 
 
public IQueryable<T> GetMatching<T>(Expression<Func<T, bool>> filter)
{
  // Replace myQuery with Context.Set<T>() or whatever you're using for data access
  return myQuery.Where(filter);
}
 
 然后像var results = GetMatching(x => x.Name == "foo");一样使用它var results = GetMatching(x => x.Name == "foo"); 或者你想做什么。 请注意，通过调用GetMatching(x => true)可以很容易地绕过这个，但至少它可以明确这个意图。 您还可以将此与第一种方法结合使用，以便对返回的记录数量设置固定上限。 
 
 但我个人的感觉是，所有这些限制查询的方法都只是针对不良开发人员开始使用您的应用程序的保险，如果您的项目开发人员不好，他们会找到一种方法来解决问题，无论如何你想做什么 所以我的投票只是返回一个IQueryable<T>并相信它会被负责任地使用。 如果有人滥用它，请取走GetAll()方法并为它们提供训练轮方法，如GetRecentPosts(int count)或GetPostsWithTag(string tag, int count)或类似的东西，其中查询逻辑不在他们手中。 

It depends on how your repository class is set up. If you're performing the query immediately, i.e. if your GetAll() method returns something like IEnumerable<T> or IList<T>, then yes, that could easily be a performance problem, and you should generally avoid that sort of thing unless you really want to load all records at once.
 
On the other hand, if your GetAll() method returns an IQueryable<T>, then there may not be a problem at all, depending on whether you trust the people writing queries. Returning an IQueryable<T> would allow callers to further refine the search criteria before the SQL code is actually generated. Performance-wise, it would only be a problem if developers using your code didn't apply any filters before executing the query. If you trust them enough to give them enough rope to hang themselves (and potentially take your database performance down with them), then just returning IQueryable<T> might be good enough.
 
If you don't trust them, then, as others have pointed out, you could limit the number of records returned by your query by using the Skip() and Take() extension methods to implement simple pagination, but note that it's possible for records to slip through the cracks if people make changes to the database before you move on to the next page. Making pagination work seamlessly with an ever-changing database is much harder than a lot of people think.
 
Another approach would be to replace your GetAll() method with one that requires the caller to apply a filter before returning results:
 
public IQueryable<T> GetMatching<T>(Expression<Func<T, bool>> filter)
{
  // Replace myQuery with Context.Set<T>() or whatever you're using for data access
  return myQuery.Where(filter);
}
 
and then use it like var results = GetMatching(x => x.Name == "foo");, or whatever you want to do. Note that this could be easily bypassed by calling GetMatching(x => true), but at least it makes the intention clear. You could also combine this with the first method to put a firm cap on the number of records returned.
 
My personal feeling, though, is that all of these ways of limiting queries are just insurance against bad developers getting their hands on your application, and if you have bad developers working on your project, they'll find a way to cause problems no matter what you try to do. So my vote is to just return an IQueryable<T> and trust that it will be used responsibly. If people abuse it, take away the GetAll() method and give them training-wheels methods like GetRecentPosts(int count) or GetPostsWithTag(string tag, int count) or something like that, where the query logic is out of their hands.