如何在EF中使用子查询编写T-SQL多对多

Question

I have two classes with a many-to-many relationship in a ASP.NET EF application. I'm trying to find all Listings that have any Categories which is posted from a view. The categories are checkboxes on the view form.

These are the classes with navigation properties simplified for example:

public class Listing
{
    public int ID { get; set; }
    public ICollection<Category> Categories { get; set; }    
    ...
}


public class Category
{
    public int ID { get; set; }
    public ICollection<Listing> Listings { get; set; }
    ...
}

// this is the join table created by EF code first for reference
public class CategoryListings
{
    public int Category_ID { get; set; }
    public int Listing_ID { get; set; }        
}

This is the query I am trying to use in my MVC Controller but it doesn't work and I don't really know what else to try:

if (model.Categories !=null && model.Categories.Any(d => d.Enabled))
        {                
            List<Listing> itemsSelected = null;                
            foreach (var category in model.Categories.Where(d => d.Enabled))
            {                    
                var itemsTemp = items.Select(x => x.Categories.Where(d => d.ID == category.ID));
                foreach (var item1 in itemsTemp)
                {
                    itemsSelected.Add((Listing)item1); //casting error here
                }
            }                
            items = itemsSelected;

        }

In SQL, I would write this using a subquery (the subquery represents the multiple categories that can be searched for):

select l.id, cl.Category_ID
from 
listings as l inner join CategoryListings as cl 
    on l.id=cl.Listing_ID
inner join Categories as c on c.ID = cl.Category_ID
where c.id in (select id from Categories where id =1 or id=3)

How do I write that SQL query in EF using navigators or lambda? The subquery in the SQL will change each search and can be any id or IDs.

Answer 1

Do you have a relation between Listing/Category and CategoryListings ? Here is example for EF 6: http://www.entityframeworktutorial.net/code-first/configure-many-to-many-relationship-in-code-first.aspx

If you have it the query will be simple, something like that:

CategoryListing.Where(cl => new List<int>{1, 3}.Contains(cl.CategoryRefId)) .Select(x => new {x.ListingRefId, x.CategoryRefId});

If you need all properties of Listing or Category , Include() extension will help.

Answer 2

You forgot to tell us what objects are in your collection items . I think they are Listings . Your case doesn't work, because itemsTemp is a collection of Categories , and every item1 is a Category , which of course can't be cast to a Listing .

Advice: to debug casting problems, replace the word var with the type you actually expect. The compiler will warn you about incorrect types. Also use proper identifiers in your lambda expressions. This makes them easier to read

 IQueryable<???> items = ...             // collection of Listings?
 List<Listing> itemsSelected = null;    
 IQueryable<Category> enabledCategories = model.Categories.Where(category => category.Enabled));  
 foreach (Category category in enabledCategories)
 {                    
     IEnumerable<Category> itemsTemp = items
         .Select(item => item.Categories
                .Where(tmpCategory => tmpCategory.ID == category.ID));
     foreach (Category item1 in itemsTemp)
     {
         // can't cast a Category to a Listing

We'll come back to this code later.

If I look at your SQL it seems that you want the following:

I have a DbContext with (at least) Listings and Categories . I want all Listings with their Categories that have category Id 1 or 3

It's good to see that you followed the entity framework code-first conventions , however you forgot to declare your collections virtual :

In entity framework the columns in a table are represented by non-virtual properties. The virtual properties represent the relations between the table.

With a slight change your many-to-many relation can be detected automatically by entity framework. Note the virtual before the ICollection

class Listing
{
    public int ID { get; set; }

    // every Listing has zero or more categories (many-to-many)
    public virtual ICollection<Category> Categories { get; set; }    
    ...
}

class Category
{
    public int ID { get; set; }

    // every Category is used by zero or more Listings (many-to-many)
    public ICollection<Listing> Listings { get; set; }
    ...
    public bool Enabled {get; set;}
}

And the DbContext

public MyDbContext : DbContext
{
    public DbSet<Listing> Listings {get; set;}
    public DbSet<Category> Categories {get; set;}
}

Although a relational database implements a many-to-many relationship with a junction table, you don't need to declare it in your DbContext . Entity framework detects that you want to design a many-to-many and creates the junction table for you.

But how can I perform my joins without access to the junction table?

Answer: Don't do joins, use the ICollections !

Entity Framework knows which inner joins are needed and will do the joins for you.

Back to your SQL code:

Give me all (or some) properties of all Listings that have at least one Category with Id equal to 1 or 3

var result = myDbcontext.Listings
    .Select(listing => new
    {   // select only the properties you plan to use
        Id = listing.Id,
        Name = listing.Name,
        ...

        Categories = listing.Categories
            // you don't want all categories, you only want categories with id 1 or 3
            .Where(category => category.Id == 1 || category.Id == 3)
            .Select(category => new
            {
                 // again select only the properties you plan to use
                 Id = category.Id,
                 Enabled = category.Enabled,
                 ...
            })
            .ToList(),
    })
    // this will also give you the Listings without such Categories,
    // you only want Listings that have any Categories left
    .Where(listing => listing.Categories.Any());

One of the slower parts of database queries is the transfer of the selected data from the DBMS to your local process. Hence it is wise to only transfer the properties you actually plan to use. For example, you won't need the foreign keys of one-to-many relationships, you know it equals the Id value of the one part in the one-to-many.

Back to your code

It seems to me, that your items are Listings . In that case your code wants all Listings that have at least one enabled Category

var result = myDbContext.Listings
   .Where(listing => ...)                   // only if you don't want all listings
   .Select(listing => new
   {
        Id = listing.Id,
        Name = list.Name,

        Categories = listing.Categories
            .Where(category => category.Enabled) // keep only the enabled categories
            .Select(category => new
            {
                Id = category.Id,
                Name = category.Name,
                ...
            })
            .ToList(),
       })
    // this will give you also the Listings that have only disabled categories,
    // so listings that have any categories left. If you don't want them:
    .Where(listing => listing.Categories.Any());