목록의 항목을 기반으로 쿼리 결과를 필터링하는 방법은 무엇입니까?

Question

내 웹 사이트에는 검색 기능이 있습니다. 사용자가 검색하기를 원할 때, 검색 기준을 보유하는 객체가 생성됩니다. 그것은 다음과 같습니다

public class SearchJSON : ISearchObject 
{ 
    public List<String> sites { get; set; } 
    public int minWage { get; set; } 
    public int maxWage { get; set; } 
    public List<String> countries { get; set; } 
    public int minRating { get; set; } 
    public int maxRating { get; set; } 
    public int pageNumber { get; set; } 
    public List<String> skills { get; set; } 

} 

내 응용 프로그램 데이터베이스 구조, 클래스와의 관계 : 검색을 기반으로 데이터베이스를 조회하고 프리랜서의 목록을 검색하는 기능이있다

사용자가 입력 한 기준 :

var query = db.Freelancers 
        .Include("Skills").Include("Countries") 
        .Where(x => x.HourWageMin >= data.minWage) 
        .Where(x => x.HourWageMax <= data.maxWage) 
        .Where(x => x.Stars >= data.minRating) 
        .Where(x => x.Stars <= data.maxRating) 
        .Where(x => x.Countries != null && data.countries.Contains(x.Countries.Name)); 

문제는 기술이없는 사람들을 걸러 내고 싶습니다 이 파일은 SearchJSON 개체의 "skills"목록에 있습니다. 내 람다 식으로 어떻게 할 수 있니?

Answer 1

var query = db.Freelancers 
       .Include("Skills").Include("Countries") 
       .Where(x => x.HourWageMin >= data.minWage) 
       .Where(x => x.HourWageMax <= data.maxWage) 
       .Where(x => x.Stars >= data.minRating) 
       .Where(x => x.Stars <= data.maxRating) 
       .Where(x => x.Countries != null && data.countries.Contains(x.Countries.Name)) 
       .Where(x => x.Skills.Any(s => data.skills.Contains(s.Name))); 

샘플 테스트 :이 SQL 쿼리를 생성

internal void Run() 
{ 
    //Seed(); 
    List<string> skills = new List<string>() { "Skill 1", "Skill 2" }; 
    var query = context.Freelancers 
      .Include("Skill") 
      .Where(x => x.Skill.Any(s => skills.Contains(s.Name))); 
    // query returns two freelancers, 1 and 3. 
} 

private void Seed() 
{ 

    Skill s1 = new Skill() { Name = "Skill 1" }; 
    Skill s2 = new Skill() { Name = "Skill 2" }; 
    Skill s3 = new Skill() { Name = "Skill 3" }; 
    Skill s4 = new Skill() { Name = "Skill 4" }; 
    Skill s5 = new Skill() { Name = "Skill 5" }; 
    Skill s6 = new Skill() { Name = "Skill 6" }; 

    Freelancer f1 = new Freelancer() { Name = "Freelancer 1" }; 
    f1.Skill.Add(s1); 
    f1.Skill.Add(s3); 
    f1.Skill.Add(s4); 
    f1.Skill.Add(s6); 

    Freelancer f2 = new Freelancer() { Name = "Freelancer 2" }; 
    f2.Skill.Add(s4); 
    f2.Skill.Add(s6); 

    Freelancer f3 = new Freelancer() { Name = "Freelancer 3" }; 
    f3.Skill.Add(s1); 
    f3.Skill.Add(s6); 

    Freelancer f4 = new Freelancer() { Name = "Freelancer 4" }; 
    f4.Skill.Add(s5); 

    context.Freelancers.Add(f1); 
    context.Freelancers.Add(f2); 
    context.Freelancers.Add(f3); 
    context.Freelancers.Add(f4); 

    context.SaveChanges(); 
} 

: - : - 어디에요 (X => X

{SELECT 
[Project2].[Id] AS [Id], 
[Project2].[Name] AS [Name], 
[Project2].[Country_Id] AS [Country_Id], 
[Project2].[C1] AS [C1], 
[Project2].[Id1] AS [Id1], 
[Project2].[Name1] AS [Name1] 
FROM (SELECT 
[Extent1].[Id] AS [Id], 
[Extent1].[Name] AS [Name], 
[Extent1].[Country_Id] AS [Country_Id], 
[Join1].[Id] AS [Id1], 
[Join1].[Name] AS [Name1], 
CASE WHEN ([Join1].[Skill_Id] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1] 
FROM [dbo].[Freelancers] AS [Extent1] 
LEFT OUTER JOIN (SELECT [Extent2].[Skill_Id] AS [Skill_Id], [Extent2].[Freelancer_Id] AS [Freelancer_Id], [Extent3].[Id] AS [Id], [Extent3].[Name] AS [Name] 
    FROM [dbo].[SkillFreelancer] AS [Extent2] 
    INNER JOIN [dbo].[Skills] AS [Extent3] ON [Extent3].[Id] = [Extent2].[Skill_Id]) AS [Join1] ON [Extent1].[Id] = [Join1].[Freelancer_Id] 
WHERE EXISTS (SELECT 
    1 AS [C1] 
    FROM [dbo].[SkillFreelancer] AS [Extent4] 
    INNER JOIN [dbo].[Skills] AS [Extent5] ON [Extent5].[Id] = [Extent4].[Skill_Id] 
    WHERE ([Extent1].[Id] = [Extent4].[Freelancer_Id]) AND ([Extent5].[Name] IN (N'Skill 1',N'Skill 2')) 
) 
) AS [Project2] 
ORDER BY [Project2].[Id] ASC, [Project2].[C1] ASC} 

Answer 2

열망하는로드가 필요한 이유가 있습니까? 당신이 게으른 로딩을 사용할 수없는 경우에는 경우, 지금까지 내가 당신이 할 수 있다고 생각하지 않습니다 아래

db.Freelancers 
    .Collection(p => p.Skills) 
    .Query() 
    .Where(u => u.Name.StartsWith("B")) 
    .Load(); 

처럼 명시 적 로딩을 사용할 수 있습니다 게으른 로딩 갈 지금

db.Freelancers.Where(f => f.Skills.Where(s => s.Name == data.Name).Any()).ToList(); 

같은 것을 쓰기 include (문자열)로 원하는 것을 얻을 수 있습니다. 이 프리랜서를 반환