Using linq, how can I retrieve a list of items where its list of attributes match another list?
Take this simple example and pseudo code:
List<Genres> listofGenres = new List<Genre>() { "action", "comedy" });
var movies = _db.Movies.Where(p => p.Genres.Any() in listofGenres);
Sounds like you want:
var movies = _db.Movies.Where(p => p.Genres.Intersect(listOfGenres).Any());
.StartWith, .EndsWith, .Contains from here it works, but what can be done to use your query
Contains repeatedly ends up as an O(x*y) operation in time, but O(1) in space, where x is the size of the first collection and y is the size of the second. Using Intersect is O(x+y) in time but O(y) in space - it constructs a hashset from the second collection, which makes it quick to check for inclusion for any item from the first collection. See codeblog.jonskeet.uk/2010/12/30/… for detailsYou can use a Contains query for this:
var movies = _db.Movies.Where(p => p.Genres.Any(x => listOfGenres.Contains(x));
If you use HashSet instead of List for listofGenres you can do:
var genres = new HashSet<Genre>() { "action", "comedy" };
var movies = _db.Movies.Where(p => genres.Overlaps(p.Genres));
I guess this is also possible like this?
var movies = _db.Movies.TakeWhile(p => p.Genres.Any(x => listOfGenres.Contains(x));
Is "TakeWhile" worse than "Where" in sense of performance or clarity?
TakeWhile is a different function - it will stop iterating when it does not find a match.Or like this
class Movie
{
public string FilmName { get; set; }
public string Genre { get; set; }
}
...
var listofGenres = new List<string> { "action", "comedy" };
var Movies = new List<Movie> {new Movie {Genre="action", FilmName="Film1"},
new Movie {Genre="comedy", FilmName="Film2"},
new Movie {Genre="comedy", FilmName="Film3"},
new Movie {Genre="tragedy", FilmName="Film4"}};
var movies = Movies.Join(listofGenres, x => x.Genre, y => y, (x, y) => x).ToList();
If the Genre is an Entity and has its own Properties such as Title, use the following code:
var listofGenresName = new List<string> { "action", "comedy" };
var movies = _db.Movies.Where(p => p.Genres.Any(x => listofGenresName.Any(g=> g == x.Title)));
This is also a great use case for an extension method ContainsAny like this:
public static class IEnumerableExtensions
{
/// <summary>
/// Determines whether a sequence contains any of the specified items.
/// </summary>
/// <typeparam name="T">The type of the elements in the sequences.</typeparam>
/// <param name="source">The sequence to search.</param>
/// <param name="items">The sequence of items to search for in the source sequence.</param>
/// <returns><c>true</c> if the source sequence contains any of the specified items; otherwise, <c>false</c>.</returns>
/// <remarks>
/// If either the source or items sequence is null, it will be treated as an empty sequence.
/// This method uses a HashSet for efficient lookup of items.
/// </remarks>
public static bool ContainsAny<T>(this IEnumerable<T> source, IEnumerable<T> items)
{
source ??= Array.Empty<T>();
items ??= Array.Empty<T>();
var itemSet = new HashSet<T>(items);
return source.Any(itemSet.Contains);
}
}
And then you can use like this:
var dbMovies = new List<Movie>
{
new Movie("Moana", new [] { "Animation", "Comedy" }),
new Movie("Mulan", new [] { "Animation", "Family" }),
new Movie("Brave", new [] { "Adventure", "Comedy" }),
};
var listOfGenres = new [] { "Comedy", "Western" };
var movies = dbMovies.Where(m => m.Genres.ContainsAny(listOfGenres));
Console.WriteLine(string.Join(", ", movies.Select(m => m.Title)));
// Moana, Brave
Searching for a list in a list in a list is already confusing enough, and this helps abstract some of he parts away to make the code more readable.
See Also: How to use Linq to check if a list of strings contains any string in a list
Genreis defined.