LINQ return items in a List that matches any Names

Question

I have 2 lists. 1 is a collection of products. And the other is a collection of products in a shop.

I need to be able to return all shopProducts if the names match any Names in the products.

I have this but it doesn't seem to work. Any ideas?

    var products = shopProducts.Where(p => p.Name.Any(listOfProducts.
             Select(l => l.Name).ToList())).ToList();

I need to say give me all the shopproducts where name exists in the other list.

Answer 1

You could create an IEqualityComparer<T> that says products with equal names are equal.

class ProductNameEqulity : IEqualityComparer<Product>
{
    public bool Equals(Product p1, Product p2)
    {
        return p1.Name == p2.Name
    }

    public int GetHashCode(Product product)
    {
        return product.Name.GetHashCode();
    }
}

Then you can use this in the Intersect extension method.

var products = shopProducts.Intersect(listOfProducts, new ProductNameEquality());

Answer 2

Try this please

var products  = shopProducts.Where(m=> listOfProducts.Select(l=>l.Name).ToList().Contains(m=>m.Name));

Answer 3

You could use a join, for example:

var q = from sp in shopProducts
        join p in listOfProducts on sp.Name equals p.Name
        select sp;

A fuller guide on join is here.

Answer 4

var products = shopProducts
        .Where(shopProduct =>
                listOfProducts.Any(p => shopProduct.Name == p.Name))
        .ToList();

Answer 5

var products = shopProducts.Where(p => listOfProducts.Any(l => p.Name == l.Name))
                           .ToList();

For LINQ-to-Objects, if listOfProducts contains many items then you might get better performance if you create a HashSet<T> containing all the required names and then use that in your query. HashSet<T> has O(1) lookup performance compared to O(n) for an arbitrary IEnumerable<T>.

var names = new HashSet<string>(listOfProducts.Select(p => p.Name));
var products = shopProducts.Where(p => names.Contains(p.Name))
                           .ToList();

For LINQ-to-SQL, I would expect (hope?) that the provider could optimise the generated SQL automatically without needing any manual tweaking of the query.