Linq to sql LINQ到SQL-使用Contains进一步修改IQueryable结果集

我正在使用LINQtoSQL，我允许用户通过在UI中为QueryString赋值来设置查询。我将主查询设置为返回IQueryable结果，然后通过继续对结果IQueryable对象进行操作来不断优化结果集。一切正常，代码与此类似

var result = (from record in db.Companies
select new Company
{
     Id = record.Id,
     Name = record.Name,
     City = record.City,
     Status = record.Status
});
if (queryName != null && queryName!= "")
{
  result = result.Where(p => p.Name.Contains(queryName));
}

if (queryCity != null && queryCity!= "")
{
   result = result.Where(p => p.City.StartsWith(queryCity));
}

现在，我想将查询扩展为一组类似于SQL中“IN子句”的元素。其中有查询中使用的元素列表，例如

string[] queryStatusList = {"x", "y" };

现在我可以像这样写代码了，一切都还可以

var result = (from record in db.Companies
where queryStatusList.Contains(record.status)
   select new Company
   {
      Id = record.Id,
      Name = record.Name,
      City = record.City,
      Status = record.Status
   });
if (queryName != null && queryName!= "")
{
  result = result.Where(p => p.Name.Contains(queryName));
}

if (queryCity != null && queryCity!= "")
{
   result = result.Where(p => p.City.StartsWith(queryCity));
}

但是，我不希望在初始查询中使用where子句。我希望像前面的示例中那样，从优化的查询结果进行构建。我的问题是如何构造这样一个查询。我试过了

if (queryStatusList != null && queryStatusList.Count() > 0)
{
    result = result.Where(queryStatusList.Contains(result.Select(p => p.Status.ToString())));
}

---

但我遇到了一个编译器错误：“无法从用法中推断出方法‘System.Linq.Enumerable.Contains（System.Collections.Generic.IEnumerable，TSource）’的类型参数。请尝试显式指定类型参数”我尝试了一些变体，但不确定如何解决此问题。

我想如果您稍微更改一下，它可能在以下方面发挥作用：

if (queryStatusList != null && queryStatusList.Count() > 0) 
{ 
    result = result.Where( r=> queryStatusList.Contains( r.Status )); 
}

另一方面，您可能希望考虑使用来构建单个Where子句选择器，并改用它。PredicateBuilder将为您提供更多的控制，使您能够使用and和OR子句的组合创建复杂的查询，同时仍然动态地构建它们

var predicate = PredicateBuilder.True<Company>();

if (queryName != null && queryName!= "") 
{ 
    predicate = predicate.And( p => p.Name.Contains(queryName) );
} 

if (queryCity != null && queryCity!= "") 
{ 
   predicate = predicate.And(p => p.City.StartsWith(queryCity)); 
}

if (queryStatusList != null && queryStatusList.Count() > 0) 
{ 
    predicate = predicate.And( p => queryStatusList.Contains( p.Status )); 
}

var result = db.Companies
               .Select( c => new Company 
                { 
                    Id = record.Id, 
                    Name = record.Name, 
                    City = record.City, 
                    Status = record.Status 
                }
               .Where( predicate );

var predicate=PredicateBuilder.True（）；
if（queryName！=null&&queryName！=“”）
{ 
predicate=predicate.And（p=>p.Name.Contains（queryName））；
} 
if（queryCity！=null&&queryCity！=“”）
{ 
predicate=predicate.And（p=>p.City.StartsWith（queryCity））；
}
if（queryStatusList！=null&&queryStatusList.Count（）>0）
{ 
谓词=谓词和（p=>queryStatusList.Contains（p.Status））；
}
var结果=分贝公司
.选择（c=>新公司
{ 
Id=record.Id，
Name=record.Name，
城市，
状态=记录。状态
}
.Where（谓语）；

我认为如果您稍微更改一下，它可能会起作用：

if (queryStatusList != null && queryStatusList.Count() > 0) 
{ 
    result = result.Where( r=> queryStatusList.Contains( r.Status )); 
}

另一方面，您可能希望考虑使用构建一个Where子句选择器，并改用它。PredicateBuilder将为您提供更多的控制，并使您能够使用and和OR子句的组合创建复杂查询，同时仍然动态地构建它们

var predicate = PredicateBuilder.True<Company>();

if (queryName != null && queryName!= "") 
{ 
    predicate = predicate.And( p => p.Name.Contains(queryName) );
} 

if (queryCity != null && queryCity!= "") 
{ 
   predicate = predicate.And(p => p.City.StartsWith(queryCity)); 
}

if (queryStatusList != null && queryStatusList.Count() > 0) 
{ 
    predicate = predicate.And( p => queryStatusList.Contains( p.Status )); 
}

var result = db.Companies
               .Select( c => new Company 
                { 
                    Id = record.Id, 
                    Name = record.Name, 
                    City = record.City, 
                    Status = record.Status 
                }
               .Where( predicate );

var predicate=PredicateBuilder.True（）；
if（queryName！=null&&queryName！=“”）
{ 
predicate=predicate.And（p=>p.Name.Contains（queryName））；
} 
if（queryCity！=null&&queryCity！=“”）
{ 
predicate=predicate.And（p=>p.City.StartsWith（queryCity））；
}
if（queryStatusList！=null&&queryStatusList.Count（）>0）
{ 
谓词=谓词和（p=>queryStatusList.Contains（p.Status））；
}
var结果=分贝公司
.选择（c=>新公司
{ 
Id=record.Id，
Name=record.Name，
城市，
状态=记录。状态
}
.Where（谓语）；

非常感谢。我真的很感谢你的帮助。我花了几个小时试图让它发挥作用。一旦你看到答案，它看起来很简单。再次感谢……还感谢伟大的谓词示例。我从未使用过PredicateBuilder类。这看起来很好。非常感谢。我真的很感谢你的帮助。我花了几个小时尝试使用PredicateBuilder让它起作用。一旦你看到答案，它看起来很简单。再次感谢……还感谢伟大的谓词示例。我从未使用过PredicateBuilder类。这看起来非常好。