Requête LINQ optimale pour obtenir une sous-collection aléatoire - Shuffle

Question

Veuillez suggérer une méthode simple pour obtenir une collection aléatoire de nombre 'n' à partir d'une collection de 'N' éléments, où n <= N.

Answer 1

Suite à la réponse de mquander et au commentaire de Dan Blanchard, voici une méthode d'extension conviviale pour LINQ qui exécute un Le remaniement Fisher-Yates-Durstenfeld :

// 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];
        }
    }
}

Answer 2

Une autre option est d'utiliser OrderBy et de trier sur une valeur GUID, ce que vous pouvez faire en utilisant :

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

J'ai effectué quelques tests empiriques pour me convaincre que la méthode ci-dessus génère réellement une distribution aléatoire (ce qui semble être le cas). Vous pouvez voir mes résultats à Techniques de réordonnancement aléatoire d'un tableau .

Answer 3

Cela pose quelques problèmes de "biais aléatoire" et je suis sûr que ce n'est pas optimal, mais c'est une autre possibilité :

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

Answer 4

Shuffle la collection dans un ordre aléatoire et prendre le premier n des éléments du résultat.

Answer 5

J'écris cette méthode de contournement :

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>();
        }

Ensuite, j'ai ma liste de sources (tous les articles)

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

Enfin, j'appelle "Randomize" et j'obtiens une sous-collection aléatoire d'éléments, dans mon cas, 5 éléments :

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