C# 使用列表中的值筛选linq查询结果

我正在尝试筛选我的查询结果

作业

。我正在使用传递的列表参数

类型

尝试筛选

作业

。

类型

来自多个选中的复选框。问题是我在这里得到了错误的作业结果

foreach（var type in types）

。我只得到

foreach

中最后一项的结果

public JobsOutPut GetJobs(List<string> types, string country)
{
    //Getting the jobs here
    var jobs =
    (
        from row in _jobCategoryRepository.GetAll().ToList()
        join rowT in _jobTypeRepository.GetAll().ToList()
        on row.JobId equals rowT.JobId
        orderby row.CreationTime descending
        select new JobDto
        {
            Id = row.JobId,
            Title = row.Job.Title,
        }
    )
        .AsEnumerable()
        .Where(j => j.Country.Contains(country));

    if (types.Any())//if that List has stuff filter jobs using those values.
    {
        //is there a better approach leading to correct results?I ran out of ideas 
        foreach (var type in types)
        {
            jobs = jobs.Where(j => j.TypeName == type);

        }
    }

    var fJobs = jobs.ToList();
    return new FilterJobOutPut
    {
        JobsList = fJobs,
    };
}

public JobsOutPut GetJobs（列表类型，字符串国家/地区）
{
//在这里找工作
var作业=
(
来自_jobCategoryRepository.GetAll（）.ToList（）中的行
在_jobTypeRepository.GetAll（）.ToList（）中加入rowT
在row.JobId上等于row.JobId
orderby row.CreationTime降序
选择“新建作业”按钮
{
Id=行.JobId，
Title=row.Job.Title，
}
)
.可计算的（）
其中（j=>j.Country.Contains（Country））；
if（types.Any（））//如果该列表具有使用这些值的填充过滤器作业。
{
//有没有更好的方法可以得到正确的结果？我没有主意了
foreach（类型中的变量类型）
{
jobs=jobs.Where（j=>j.TypeName==type）；
}
}
var fJobs=jobs.ToList（）；
返回新的FilterJobOutPut
{
JobsList=fJobs，
};
}

使用

Contains（）

使您的代码更简单，只需确保

j.TypeName

的大小写和

类型的内容应相同即可

if (types.count >0)
{
      return new FilterJobOutPut
      {
        JobsList = jobs.Where(j => types.Contains(j.TypeName)).ToList()
      };
}
else
    return null //make null check where ever you call this method else use new FilterJobOutPut()

使用
Contains（）

if (types.count >0)
{
      return new FilterJobOutPut
      {
        JobsList = jobs.Where(j => types.Contains(j.TypeName)).ToList()
      };
}
else
    return null //make null check where ever you call this method else use new FilterJobOutPut()

在我看来，你想要这个：

public JobsOutPut GetJobs(List<string> types, string country)
{
    //Getting the jobs here
    var jobs =
    (
        from row in _jobCategoryRepository.GetAll().ToList()
        join rowT in _jobTypeRepository.GetAll().ToList() on row.JobId equals rowT.JobId
        let jobDto = new JobDto
        {
            Id = row.JobId,
            Title = row.Job.Title,
        }
        where jobDto.Country.Contains(country)
        where !types.Any() || types.Any(t => jobDto.TypeName == t)
        orderby row.CreationTime descending
        select jobDto
    );

    return new FilterJobOutPut
    {
        JobsList = jobs.ToList(),
    };
}

public JobsOutPut GetJobs（列表类型，字符串国家/地区）
{
//在这里找工作
var作业=
(
来自_jobCategoryRepository.GetAll（）.ToList（）中的行
将rowT加入到_jobTypeRepository.GetAll（）.ToList（）中，在row.JobId上等于rowT.JobId
让jobDto=新jobDto
{
Id=行.JobId，
Title=row.Job.Title，
}
其中jobDto.Country.Contains（国家）
其中！types.Any（）| | types.Any（t=>jobDto.TypeName==t）
orderby row.CreationTime降序
选择jobDto
);
返回新的FilterJobOutPut
{
JobsList=jobs.ToList（），
};
}

或者，如果您想变得更花哨，请执行以下操作：

public JobsOutPut GetJobs(List<string> types, string country) =>
    new FilterJobOutPut
    {
        JobsList =
        (
            from row in _jobCategoryRepository.GetAll().ToList()
            join rowT in _jobTypeRepository.GetAll().ToList() on row.JobId equals rowT.JobId
            let jobDto = new JobDto
            {
                Id = row.JobId,
                Title = row.Job.Title,
            }
            where jobDto.Country.Contains(country)
            where !types.Any() || types.Any(t => jobDto.TypeName == t)
            orderby row.CreationTime descending
            select jobDto
        ).ToList()
    };

public JobsOutPut GetJobs（列表类型，字符串国家）=>
新过滤器作业输出
{
工作清单=
(
来自_jobCategoryRepository.GetAll（）.ToList（）中的行
将rowT加入到_jobTypeRepository.GetAll（）.ToList（）中，在row.JobId上等于rowT.JobId
让jobDto=新jobDto
{
Id=行.JobId，
Title=row.Job.Title，
}
其中jobDto.Country.Contains（国家）
其中！types.Any（）| | types.Any（t=>jobDto.TypeName==t）
orderby row.CreationTime降序
选择jobDto
)托利斯先生（）
};
在我看来，您希望：

public JobsOutPut GetJobs(List<string> types, string country)
{
    //Getting the jobs here
    var jobs =
    (
        from row in _jobCategoryRepository.GetAll().ToList()
        join rowT in _jobTypeRepository.GetAll().ToList() on row.JobId equals rowT.JobId
        let jobDto = new JobDto
        {
            Id = row.JobId,
            Title = row.Job.Title,
        }
        where jobDto.Country.Contains(country)
        where !types.Any() || types.Any(t => jobDto.TypeName == t)
        orderby row.CreationTime descending
        select jobDto
    );

    return new FilterJobOutPut
    {
        JobsList = jobs.ToList(),
    };
}

public JobsOutPut GetJobs（列表类型，字符串国家/地区）
{
//在这里找工作
var作业=
(
来自_jobCategoryRepository.GetAll（）.ToList（）中的行
将rowT加入到_jobTypeRepository.GetAll（）.ToList（）中，在row.JobId上等于rowT.JobId
让jobDto=新jobDto
{
Id=行.JobId，
Title=row.Job.Title，
}
其中jobDto.Country.Contains（国家）
其中！types.Any（）| | types.Any（t=>jobDto.TypeName==t）
orderby row.CreationTime降序
选择jobDto
);
返回新的FilterJobOutPut
{
JobsList=jobs.ToList（），
};
}

或者，如果您想变得更花哨，请执行以下操作：

public JobsOutPut GetJobs(List<string> types, string country) =>
    new FilterJobOutPut
    {
        JobsList =
        (
            from row in _jobCategoryRepository.GetAll().ToList()
            join rowT in _jobTypeRepository.GetAll().ToList() on row.JobId equals rowT.JobId
            let jobDto = new JobDto
            {
                Id = row.JobId,
                Title = row.Job.Title,
            }
            where jobDto.Country.Contains(country)
            where !types.Any() || types.Any(t => jobDto.TypeName == t)
            orderby row.CreationTime descending
            select jobDto
        ).ToList()
    };

public JobsOutPut GetJobs（列表类型，字符串国家）=>
新过滤器作业输出
{
工作清单=
(
来自_jobCategoryRepository.GetAll（）.ToList（）中的行
将rowT加入到_jobTypeRepository.GetAll（）.ToList（）中，在row.JobId上等于rowT.JobId
让jobDto=新jobDto
{
Id=行.JobId，
Title=row.Job.Title，
}
其中jobDto.Country.Contains（国家）
其中！types.Any（）| | types.Any（t=>jobDto.TypeName==t）
orderby row.CreationTime降序
选择jobDto
)托利斯先生（）
};
我相信
if（types.Any（））
在这里并不是必需的，因为这里只有一个
foreach
循环，并且
foreach
只有在至少有一条记录的情况下才会执行。
foreach（var-type in-types）{jobs=jobs.Where（j=>j.TypeName==type）从逻辑上讲，很难理解这些代码。假设类型包含“A”、“B”和“C”。看起来您正试图生成一个WHERE-clase，表示WHERE-TypeName='a'和TypeName='B'以及TypeName='C'
（这显然是毫无意义的-这三个条件不可能都是真的）。是吗？@AD8，我需要它来检查那里是否有东西。因为如果我不这样做，那个么程序将总是进入那个foreach，而这不是我想要的want@AneleNgqandu即使程序尝试执行foreach
，它也不会有效地执行任何操作，因为集合无论如何都是空的。摆脱它是完全安全的。@mjwills是的，先生，逻辑是使用foreach中的类型来搜索作业，其中TypeName='A'和'B'以及'C'等等……我相信这里不需要
if（types.Any（））
，因为这里只有
foreach
循环，只有当至少有一条记录时，
foreach
才会执行。
foreach（类型中的变量类型）{jobs=jobs.Where（j=>j.TypeName==type）；}
逻辑上很难理解该代码。比如说类型