Sélectionnez plusieurs enregistrements en fonction de la liste des identifiants avec linq

J'ai une liste contenant les identifiants de ma UserProfiletable. Comment puis-je tout sélectionner en UserProfilesfonction de la liste des identifiants que j'ai obtenus lors d'une varutilisation LINQ?

var idList = new int[1, 2, 3, 4, 5];
var userProfiles = _dataContext.UserProfile.Where(......);

Je suis resté coincé ici. Je peux faire cela en utilisant des boucles for, etc. Mais je préfère le faire avec LINQ.

Vous pouvez utiliser Contains()pour cela. Cela vous semblera un peu en arrière lorsque vous essayez vraiment de produire une INclause, mais cela devrait le faire:

var userProfiles = _dataContext.UserProfile
                               .Where(t => idList.Contains(t.Id));

Je suppose également que chaque UserProfileenregistrement aura un int Idchamp. Si ce n'est pas le cas, vous devrez vous adapter en conséquence.

Solution avec .Where et .Contains a une complexité de O (N carré). Simple .Join devrait avoir de bien meilleures performances (proche de O (N) en raison du hachage). Le code correct est donc:

_dataContext.UserProfile.Join(idList, up => up.ID, id => id, (up, id) => up);

Et maintenant résultat de ma mesure. J'ai généré 100 000 profils utilisateur et 100 000 identifiants. Join a pris 32ms et .Where avec .Contains a pris 2 minutes et 19 secondes! J'ai utilisé IEnumerable pur pour ce test pour prouver ma déclaration. Si vous utilisez List au lieu de IEnumerable, .Where et .Contains seront plus rapides. Quoi qu'il en soit, la différence est significative. Le .Where .Contains le plus rapide est avec Set <>. Tout cela dépend de la complexité des couleurs sous-jacentes pour .Contains. Regardez cet article pour en savoir plus sur la complexité de linq.Regardez mon exemple de test ci-dessous:

    private static void Main(string[] args)
    {
        var userProfiles = GenerateUserProfiles();
        var idList = GenerateIds();
        var stopWatch = new Stopwatch();
        stopWatch.Start();
        userProfiles.Join(idList, up => up.ID, id => id, (up, id) => up).ToArray();
        Console.WriteLine("Elapsed .Join time: {0}", stopWatch.Elapsed);
        stopWatch.Restart();
        userProfiles.Where(up => idList.Contains(up.ID)).ToArray();
        Console.WriteLine("Elapsed .Where .Contains time: {0}", stopWatch.Elapsed);
        Console.ReadLine();
    }

    private static IEnumerable<int> GenerateIds()
    {
       // var result = new List<int>();
        for (int i = 100000; i > 0; i--)
        {
            yield return i;
        }
    }

    private static IEnumerable<UserProfile> GenerateUserProfiles()
    {
        for (int i = 0; i < 100000; i++)
        {
            yield return new UserProfile {ID = i};
        }
    }

Sortie de la console:

Temps écoulé. Rejoindre: 00: 00: 00.0322546

Temps écoulé .Où .Contient l'heure: 00: 02: 19.4072107

Bonnes réponses, mais n'oubliez pas une chose IMPORTANTE - elles fournissent des résultats différents!

  var idList = new int[1, 2, 2, 2, 2]; // same user is selected 4 times
  var userProfiles = _dataContext.UserProfile.Where(e => idList.Contains(e)).ToList();

Cela renverra 2 lignes de DB (et cela pourrait être correct, si vous voulez juste une liste triée distincte d'utilisateurs)

MAIS dans de nombreux cas, vous pourriez vouloir une liste de résultats non triés . Vous devez toujours y penser comme une requête SQL. Veuillez consulter l'exemple avec le panier d'achat d'eshop pour illustrer ce qui se passe:

  var priceListIDs = new int[1, 2, 2, 2, 2]; // user has bought 4 times item ID 2
  var shoppingCart = _dataContext.ShoppingCart
                     .Join(priceListIDs, sc => sc.PriceListID, pli => pli, (sc, pli) => sc)
                     .ToList();

Cela renverra 5 résultats de DB. L'utilisation de «contient» serait erronée dans ce cas.

Cela devrait être simple. Essaye ça:

var idList = new int[1, 2, 3, 4, 5];
var userProfiles = _dataContext.UserProfile.Where(e => idList.Contains(e));