我在网上找到了一个有趣的解决办法。

礼貌:https://improveandrepeat.com/2018/08/a-simple-way-to-shuffle-your-lists-in-c/

var shuffled = myList。OrderBy(x => Guid.NewGuid()).ToList();

通过使用元组进行交换，可以使Fisher-Yates shuffle更加简洁和富有表现力。

private static readonly Random random = new Random();

public static void Shuffle<T>(this IList<T> list)
{
    int n = list.Count;
    while (n > 1)
    {
        n--;
        int k = random.Next(n + 1);
        (list[k], list[n]) = (list[n], list[k]);
    }
}

编辑 RemoveAt是我以前版本的一个弱点。这个解决方案克服了这个问题。

public static IEnumerable<T> Shuffle<T>(
        this IEnumerable<T> source,
        Random generator = null)
{
    if (generator == null)
    {
        generator = new Random();
    }

    var elements = source.ToArray();
    for (var i = elements.Length - 1; i >= 0; i--)
    {
        var swapIndex = generator.Next(i + 1);
        yield return elements[swapIndex];
        elements[swapIndex] = elements[i];
    }
}

请注意可选的Random生成器，如果Random的基本框架实现不是线程安全的，或者加密性不够强，您可以将您的实现注入到操作中。

在这个答案中可以找到线程安全的加密强随机实现的合适实现。

这里有一个想法，以一种(希望)有效的方式扩展IList。

public static IEnumerable<T> Shuffle<T>(this IList<T> list)
{
    var choices = Enumerable.Range(0, list.Count).ToList();
    var rng = new Random();
    for(int n = choices.Count; n > 1; n--)
    {
        int k = rng.Next(n);
        yield return list[choices[k]];
        choices.RemoveAt(k);
    }

    yield return list[choices[0]];
}

这里是Fisher-Yates shuffle的实现，允许指定返回的元素数量;因此，在获取所需数量的元素之前，没有必要首先对整个集合进行排序。

交换元素的顺序与默认值相反;从第一个元素到最后一个元素，因此检索集合的一个子集与洗牌整个集合产生相同的(部分)序列:

collection.TakeRandom(5).SequenceEqual(collection.Shuffle().Take(5)); // true

该算法基于Durstenfeld在维基百科上的(现代)Fisher-Yates shuffle。

public static IList<T> TakeRandom<T>(this IEnumerable<T> collection, int count, Random random) => shuffle(collection, count, random);
public static IList<T> Shuffle<T>(this IEnumerable<T> collection, Random random) => shuffle(collection, null, random);
private static IList<T> shuffle<T>(IEnumerable<T> collection, int? take, Random random)
{
    var a = collection.ToArray();
    var n = a.Length;
    if (take <= 0 || take > n) throw new ArgumentException("Invalid number of elements to return.");
    var end = take ?? n;
    for (int i = 0; i < end; i++)
    {
        var j = random.Next(i, n);
        (a[i], a[j]) = (a[j], a[i]);
    }

    if (take.HasValue) return new ArraySegment<T>(a, 0, take.Value);
    return a;
}

肯定是旧帖子，但我只是使用GUID。

Items = Items.OrderBy(o => Guid.NewGuid().ToString()).ToList();

GUID总是唯一的，因为它每次都会重新生成，所以每次结果都会改变。

如果您有一个固定的数字(75)，您可以创建一个包含75个元素的数组，然后枚举您的列表，将元素移动到数组中的随机位置。您可以使用Fisher-Yates shuffle生成列表号到数组索引的映射。