Linq to Entity，随机顺序

Question

如何以随机顺序返回匹配的实体？
需要明确的是，这是实体框架的东西和 LINQ to Entities。

（航空代码）

IEnumerable<MyEntity> results = from en in context.MyEntity
                                where en.type == myTypeVar
                                orderby ?????
                                select en;

谢谢

编辑：
我尝试将其添加到上下文中：

public Guid Random()
{
    return new Guid();
}

并使用此查询：

IEnumerable<MyEntity> results = from en in context.MyEntity
                                where en.type == myTypeVar
                                orderby context.Random()
                                select en;

但我得到了这个错误：

System.NotSupportedException: LINQ to Entities does not recognize the method 'System.Guid Random()' method, and this method cannot be translated into a store expression..

编辑（当前代码）：

IEnumerable<MyEntity> results = (from en in context.MyEntity
                                 where en.type == myTypeVar
                                 orderby context.Random()
                                 select en).AsEnumerable();

Answer 1

执行此操作的一种简单方法是通过Guid.NewGuid() 订购，但随后订购发生在客户端。你也许可以说服 EF 在服务器端做一些随机的事情，但这并不一定很简单 - 并且使用“按随机数排序”is apparently broken 来做。

要在 .NET 端而非 EF 中进行排序，您需要 AsEnumerable：

IEnumerable<MyEntity> results = context.MyEntity
                                       .Where(en => en.type == myTypeVar)
                                       .AsEnumerable()
                                       .OrderBy(en => context.Random());

最好在列表中获取 无序 版本，然后再随机播放。

Random rnd = ...; // Assume a suitable Random instance
List<MyEntity> results = context.MyEntity
                                .Where(en => en.type == myTypeVar)
                                .ToList();

results.Shuffle(rnd); // Assuming an extension method on List<T>

除其他外，洗牌比排序更有效。 请参阅我的article on randomness，了解有关获取适当Random 实例的详细信息。 Stack Overflow 上有很多 Fisher-Yates shuffle 实现。

Answer 2

简单的解决方案是创建一个数组（或List<T>），然后随机化其索引。

编辑：

static IEnumerable<T> Randomize<T>(this IEnumerable<T> source) {
  var array = source.ToArray();
  // randomize indexes (several approaches are possible)
  return array;
}

编辑：就个人而言，我发现 Jon Skeet 的答案更优雅：

var results = from ... in ... where ... orderby Guid.NewGuid() select ...

当然，您可以使用随机数生成器来代替 Guid.NewGuid()。

Answer 3

这个怎么样：

var randomizer = new Random(); var results = from en in context.MyEntity where en.type == myTypeVar let rand = randomizer.Next() orderby rand select en;

Answer 4

Toro 的答案是我会使用的答案，但更像是这样：

static IEnumerable<T> Randomize<T>(this IEnumerable<T> source)
{
  var list = source.ToList();
  var newList = new List<T>();

  while (source.Count > 0)
  {
     //choose random one and MOVE it from list to newList
  }

  return newList;
}

Answer 5

此处提供的解决方案在客户端上执行。如果你想要在服务器上执行的东西，here is a solution for LINQ to SQL 你可以转换成实体框架。

Answer 6

这是一个很好的方法（主要用于谷歌搜索）。

您也可以在末尾添加 .Take(n) 以仅检索一组数字。

model.CreateQuery<MyEntity>(   
    @"select value source.entity  
      from (select entity, SqlServer.NewID() as rand  
            from Products as entity 
            where entity.type == myTypeVar) as source  
            order by source.rand");

Answer 7

Jon 的回答很有帮助，但实际上您可以让 DB 使用 Guid 和 Linq to Entities 进行排序（至少，您可以在 EF4 中）：

from e in MyEntities
orderby Guid.NewGuid()
select e

这会生成类似的 SQL：

SELECT
[Project1].[Id] AS [Id], 
[Project1].[Column1] AS [Column1]
FROM ( SELECT 
    NEWID() AS [C1],                     -- Guid created here
    [Extent1].[Id] AS [Id], 
    [Extent1].[Column1] AS [Column1],
    FROM [dbo].[MyEntities] AS [Extent1]
)  AS [Project1]
ORDER BY [Project1].[C1] ASC             -- Used for sorting here

在我的测试中，在生成的查询上使用Take(10)（在 SQL 中转换为TOP 10），对于一个有 1,794,785 行的表，查询的运行时间始终在 0.42 到 0.46 秒之间。不知道 SQL Server 是否对此进行了任何优化，或者是否为该表中的 每一 行生成了一个 GUID。无论哪种方式，这都比将所有这些行带入我的流程并尝试在那里对其进行排序要快得多。

Answer 8

从理论上讲（我还没有真正尝试过），以下应该可以解决问题：

将部分类添加到您的上下文类：

public partial class MyDataContext{

        [Function(Name = "NEWID", IsComposable = true)] 
        public Guid Random()
        { 
            // you can put anything you want here, it makes no difference 
            throw new NotImplementedException();
        }
}

实现：

from t in context.MyTable
orderby  context.Random()
select t; 

Answer 9

我认为最好不要在类中添加属性。更好地使用位置：

public static IEnumerable<T> Randomize<T>(this IEnumerable<T> pCol)
    {
        List<T> lResultado = new List<T>();
        List<T> lLista = pCol.ToList();
        Random lRandom = new Random();
        int lintPos = 0;

        while (lLista.Count > 0)
        {
            lintPos = lRandom.Next(lLista.Count);
            lResultado.Add(lLista[lintPos]);
            lLista.RemoveAt(lintPos);
        }

        return lResultado;
    }

并且调用将（如 toList() 或 toArray()）：

var 结果 = IEnumerable.Where(..).Randomize();

Answer 10

（来自EF Code First: How to get random rows 的交叉发帖）

比较两个选项：

---

跳过（随机行数）

方法

private T getRandomEntity<T>(IGenericRepository<T> repo) where T : EntityWithPk<Guid> {
    var skip = (int)(rand.NextDouble() * repo.Items.Count());
    return repo.Items.OrderBy(o => o.ID).Skip(skip).Take(1).First();
}

• 需要 2 次查询

生成的 SQL

SELECT [GroupBy1].[A1] AS [C1]
FROM   (SELECT COUNT(1) AS [A1]
        FROM   [dbo].[People] AS [Extent1]) AS [GroupBy1];

SELECT TOP (1) [Extent1].[ID]            AS [ID],
               [Extent1].[Name]          AS [Name],
               [Extent1].[Age]           AS [Age],
               [Extent1].[FavoriteColor] AS [FavoriteColor]
FROM   (SELECT [Extent1].[ID]                                  AS [ID],
               [Extent1].[Name]                                AS [Name],
               [Extent1].[Age]                                 AS [Age],
               [Extent1].[FavoriteColor]                       AS [FavoriteColor],
               row_number() OVER (ORDER BY [Extent1].[ID] ASC) AS [row_number]
        FROM   [dbo].[People] AS [Extent1]) AS [Extent1]
WHERE  [Extent1].[row_number] > 15
ORDER  BY [Extent1].[ID] ASC;

---

指南

方法

private T getRandomEntityInPlace<T>(IGenericRepository<T> repo) {
    return repo.Items.OrderBy(o => Guid.NewGuid()).First();
}

生成的 SQL

SELECT TOP (1) [Project1].[ID]            AS [ID],
               [Project1].[Name]          AS [Name],
               [Project1].[Age]           AS [Age],
               [Project1].[FavoriteColor] AS [FavoriteColor]
FROM   (SELECT NEWID()                   AS [C1],
               [Extent1].[ID]            AS [ID],
               [Extent1].[Name]          AS [Name],
               [Extent1].[Age]           AS [Age],
               [Extent1].[FavoriteColor] AS [FavoriteColor]
        FROM   [dbo].[People] AS [Extent1]) AS [Project1]
ORDER  BY [Project1].[C1] ASC

所以在较新的 EF 中，您可以再次看到 NewGuid 被转换为 SQL（由 @DrewNoakes https://stackoverflow.com/a/4120132/1037948 确认）。尽管两者都是“in-sql”方法，但我猜 Guid 版本更快？如果您不必对它们进行排序即可跳过，并且您可以合理地猜测要跳过的数量，那么 Skip 方法可能会更好。

Answer 11

lolo_house 有一个非常简洁、简单和通用的解决方案。您只需将代码放在单独的静态类中即可使其工作。

using System;
using System.Collections.Generic;
using System.Linq;

namespace SpanishDrills.Utilities
{
    public static class LinqHelper
    {
        public static IEnumerable<T> Randomize<T>(this IEnumerable<T> pCol)
        {
            List<T> lResultado = new List<T>();
            List<T> lLista = pCol.ToList();
            Random lRandom = new Random();
            int lintPos = 0;

            while (lLista.Count > 0)
            {
                lintPos = lRandom.Next(lLista.Count);
                lResultado.Add(lLista[lintPos]);
                lLista.RemoveAt(lintPos);
            }

            return lResultado;
        }
    }
}

然后使用代码就行了：

var randomizeQuery = Query.Randomize();

如此简单！谢谢lolo_house。

Answer 12

不幸的是，用于在服务器端对其进行排序的 NewGuid hack 会导致实体在连接（或急切获取包含）的情况下重复。

请参阅this question 了解此问题。

为了克服这个问题，您可以在某些唯一值计算的服务器端使用 sql checksum 代替 NewGuid，并在客户端计算一次随机种子以随机化它。有关先前链接的问题，请参阅 my answer。