除了mquander的回答和Dan Blanchard的评论，这里有一个LINQ友好的扩展方法，它执行Fisher-Yates-Durstenfeld shuffle：

// take n random items from yourCollection
var randomItems = yourCollection.Shuffle().Take(n);

// ...

public static class EnumerableExtensions
{
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
    {
        return source.Shuffle(new Random());
    }

    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source, Random rng)
    {
        if (source == null) throw new ArgumentNullException("source");
        if (rng == null) throw new ArgumentNullException("rng");

        return source.ShuffleIterator(rng);
    }

    private static IEnumerable<T> ShuffleIterator<T>(
        this IEnumerable<T> source, Random rng)
    {
        var buffer = source.ToList();
        for (int i = 0; i < buffer.Count; i++)
        {
            int j = rng.Next(i, buffer.Count);
            yield return buffer[j];

            buffer[j] = buffer[i];
        }
    }
}

另一个选项是使用OrderBy并根据GUID值进行排序，您可以使用以下命令执行此操作：

var result = sequence.OrderBy(elem => Guid.NewGuid());

我做了一些实证测试来说服自己，上面的结果实际上是随机分布的（看起来确实如此）。

这与“随机偏差”有一些问题，我确信这不是最优的，这是另一种可能性：

var r = new Random();
l.OrderBy(x => r.NextDouble()).Take(n);

Shuffle将集合转换为随机顺序，并从结果中取出前n项。

随机性稍低，但效率较高：

var rnd = new Random();
var toSkip = list.Count()-n;

if (toSkip > 0)
    toSkip = rnd.Next(toSkip);
else
    toSkip=0;

var randomlySelectedSequence = list.Skip(toSkip).Take(n);

我今天就得这么做。下面是我的尝试：

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> enumerable)
    => enumerable.Shuffle(new Random());
    
private static IEnumerable<T> Shuffle<T>(this IEnumerable<T> enumerable, Random random)
    => enumerable
       .Select(t => (t, r: random.Next())) // zip with random value
       .OrderBy(tr => tr.r)
       .Select(tr => tr.t);

这里的主要思想是“zip”，但没有使用Zip，因为我们只想迭代一次可枚举对象。在排序中，原始可枚举对象的每个元素都有相同的“值”。

我写这个重写方法：

public static IEnumerable<T> Randomize<T>(this IEnumerable<T> items) where T : class
{
     int max = items.Count();
     var secuencia = Enumerable.Range(1, max).OrderBy(n => n * n * (new Random()).Next());

     return ListOrder<T>(items, secuencia.ToArray());
}

private static IEnumerable<T> ListOrder<T>(IEnumerable<T> items, int[] secuencia) where T : class
        {
            List<T> newList = new List<T>();
            int count = 0;
            foreach (var seed in count > 0 ? secuencia.Skip(1) : secuencia.Skip(0))
            {
                newList.Add(items.ElementAt(seed - 1));
                count++;
            }
            return newList.AsEnumerable<T>();
        }

然后，我有我的来源列表（所有项目）

var listSource = p.Session.QueryOver<Listado>(() => pl)
                        .Where(...);

最后，我调用“Randomize”，得到一个随机的子集合，在我的例子中，有5个项目：

var SubCollection = Randomize(listSource.List()).Take(5).ToList();

很抱歉代码很难看：-），但是

var result =yourCollection.OrderBy(p => (p.GetHashCode().ToString() + Guid.NewGuid().ToString()).GetHashCode()).Take(n);