Linq to Entities, ordre aléatoire

c# entity-framework linq-to-entities

Question

Comment puis-je retourner des entités correspondantes dans un ordre aléatoire?
Soyons clairs: il s’agit de choses relatives à Entity Framework et à LINQ to Entities.

(code aérien)

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

Merci

Modifier:
J'ai essayé d'ajouter ceci au contexte:

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

Et en utilisant cette requête:

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

Mais j'ai eu cette erreur:

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

Modifier (code actuel):

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

Réponse acceptée

La solution simple consisterait à créer un tableau (ou une List<T> ) et à randomiser ses index.

MODIFIER:

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

EDIT: Personnellement, je trouve la réponse de Jon Skeet plus élégante:

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

Et bien sûr, vous pouvez utiliser un générateur de nombres aléatoires au lieu de Guid.NewGuid() .


Réponse populaire

Une méthode simple consiste à Guid.NewGuid() commande par Guid.NewGuid() mais la commande est ensuite effectuée côté client. Vous pourrez peut-être persuader EF de faire quelque chose d’aléatoire sur le serveur, mais ce n’est pas forcément simple - et le faire en utilisant "ordre par nombre aléatoire" est apparemment rompu .

Pour que la commande se passe du côté .NET au lieu de EF, vous avez besoin de AsEnumerable :

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

Il serait préférable d’obtenir la version non ordonnée dans une liste et de la mélanger ensuite.

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>

Le shuffling est plus efficace que le tri, mis à part quoi que ce soit d'autre. Voir mon article sur le hasard pour des détails sur l'acquisition d'une instance Random appropriée. Il existe de nombreuses implémentations de mélange aléatoire Fisher-Yates disponibles sur Stack Overflow.



Related

Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow
Sous licence: CC-BY-SA with attribution
Non affilié à Stack Overflow