Wybierz wiele rekordów na podstawie listy identyfikatorów za pomocą linq

Mam listę zawierającą identyfikatory mojego UserProfilestołu. Jak mogę wybrać wszystko UserProfilesna podstawie listy identyfikatorów, które mam w varużyciu LINQ?

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

Utknąłem tutaj. Mogę to zrobić używając pętli for itp. Ale wolałbym to zrobić z LINQ.

Możesz użyć Contains()do tego. Będzie to trochę cofnięte, gdy naprawdę próbujesz stworzyć INklauzulę, ale powinno to wystarczyć:

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

Zakładam też, że każdy UserProfilerekord będzie miał int Idpole. Jeśli tak nie jest, musisz odpowiednio dostosować.

Rozwiązanie z .Where i .Contains ma złożoność O (N kwadrat). Prosty .Join powinien mieć dużo lepszą wydajność (blisko O (N) ze względu na haszowanie). Więc poprawny kod to:

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

A teraz wynik mojego pomiaru. Wygenerowałem 100 000 profili użytkowników i 100 000 identyfikatorów. Dołączenie zajęło 32 ms, a gdzie z .Contains zajęło 2 minuty i 19 sekund! Użyłem czystego IEnumerable do tego testu, aby udowodnić moje stwierdzenie. Jeśli używasz listy zamiast IEnumerable, .Where i .Contains będą działać szybciej. Zresztą różnica jest znacząca. Najszybszy .Gdzie .Contains to Set <>. Wszystko zależy od złożoności bazowych kolekcji dla .Contains. Spójrz na ten post, aby dowiedzieć się o złożoności linq Spójrz na moją próbkę testową poniżej:

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

Wyjście konsoli:

Upłynęło. Czas dołączenia: 00: 00: 00,0322546

Upłynęło .Gdzie .Zawiera czas: 00: 02: 19.4072107

Ładne odpowiedzi powyżej, ale nie zapominaj o jednej WAŻNE - dają różne wyniki!

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

Spowoduje to zwrócenie 2 wierszy z bazy danych (i może to być poprawne, jeśli chcesz mieć tylko odrębną posortowaną listę użytkowników)

ALE w wielu przypadkach możesz potrzebować niesortowanej listy wyników. Zawsze musisz myśleć o tym jak o zapytaniu SQL. Zobacz przykład z koszykiem sklepu internetowego, aby zilustrować, co się dzieje:

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

To zwróci 5 wyników z DB. W tym przypadku użycie atrybutu „zawiera” byłoby niewłaściwe.

To powinno być proste. Spróbuj tego:

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