C# 基于bools构建LINQ查询

（这个问题的标题不是最好的，但我不知道该怎么说！）

我正在做一个包含价值清单的搜索表单。基本上，选中项表示“在搜索中包含此类型”。大概是这样的：

Search for item: __________
Search in:
      [ ] Fresh Foods
      [ ] Frozen Foods
      [ ] Beverages
      [ ] Deli Counter

public IList<FoodItem> FindFoodItems(FoodSearchCriteria criteria)
// in reality, this is a fuzzy search not an exact match
var matches = _DB.FoodItems.Where(x => x.FoodTitle == SearchString);

var inCategories = new List<FoodItem>();

if (criteria.SearchFreshFoods)
   inCategories.Add(matches.Where(x => x.Type == 'Fresh Foods'));
if (criteria.SearchFrozenFoods)
   inCategories.Add(matches.Where(x => x.Type == 'Frozen Foods'));
//etc etc

return inCategories;
}

我有一个对象来表示此搜索：

class FoodSearchCriteria{
    public string SearchString {get;set;}
    public bool SearchFreshFoods {get;set;}
    public bool SearchFrozenFoods {get;set;}
    public bool SearchBeverages {get;set;}
    public bool SearchDeliCounter {get;set;}
}

我能想到的唯一办法是这样做：

Search for item: __________
Search in:
      [ ] Fresh Foods
      [ ] Frozen Foods
      [ ] Beverages
      [ ] Deli Counter

public IList<FoodItem> FindFoodItems(FoodSearchCriteria criteria)
// in reality, this is a fuzzy search not an exact match
var matches = _DB.FoodItems.Where(x => x.FoodTitle == SearchString);

var inCategories = new List<FoodItem>();

if (criteria.SearchFreshFoods)
   inCategories.Add(matches.Where(x => x.Type == 'Fresh Foods'));
if (criteria.SearchFrozenFoods)
   inCategories.Add(matches.Where(x => x.Type == 'Frozen Foods'));
//etc etc

return inCategories;
}

公共IList FindFoodItems（FoodSearchCriteria）
//实际上，这是一种模糊搜索，而不是精确匹配
var matches=_DB.FoodItems.Where（x=>x.FoodTitle==SearchString）；
var inCategories=新列表（）；
如果（标准.新鲜食品）
inccategories.Add（matches.Where（x=>x.Type==‘新鲜食品’）；
if（标准：SearchFrozenFoods）
inccategories.Add（matches.Where（x=>x.Type==‘冷冻食品’）；
//等等
返回类别；
}

对我来说，这就像是一种代码味道，有什么更好的方法来处理它呢？

看看

PredicateBuilder predicate=PredicateBuilder.False（）；
如果（标准.新鲜食品）
{
谓词=谓词。或（x=>x.Type==“新鲜食品”）；
}
if（标准：SearchFrozenFoods）
{
谓词=谓词。或（x=>x.Type==“冷冻食品”）；
}
...
_DB.FoodItems.Where（谓词）；

看一看

PredicateBuilder predicate=PredicateBuilder.False（）；
如果（标准.新鲜食品）
{
谓词=谓词。或（x=>x.Type==“新鲜食品”）；
}
if（标准：SearchFrozenFoods）
{
谓词=谓词。或（x=>x.Type==“冷冻食品”）；
}
...
_DB.FoodItems.Where（谓词）；

您是否尝试过：

List<string> types = new List<string>();

if (criteria.SearchFreshFoods) { types.Add("Fresh Foods"); }
if (criteria.SearchFrozenFoods) { types.Add("Frozen Foods"); }
if (criteria.SearchBeverages) { types.Add("Beverages"); }
if (criteria.SearchDeliCounter) { types.Add("Deli Counter"); }

return _DB.FoodItems.Where(x => x.FoodTitle == SearchString &&
                                types.Contains(x.Type));

列表类型=新列表（）；
if（criteria.SearchFreshFoods）{types.Add（“新鲜食品”）；}
if（criteria.SearchFrozenFoods）{types.Add（“冷冻食品”）；}
if（criteria.SearchBeverages）{types.Add（“Beverages”）；}
if（criteria.SearchDeliCounter）{types.Add（“Deli计数器”）；}
返回_DB.FoodItems.Where（x=>x.FoodTitle==SearchString&&
包含（x.Type））；

这意味着只有一个SQL查询，这很方便

您当然可以重构FoodSearchCriteria类型，使其更易于构建列表，不过……

您是否尝试过：

List<string> types = new List<string>();

if (criteria.SearchFreshFoods) { types.Add("Fresh Foods"); }
if (criteria.SearchFrozenFoods) { types.Add("Frozen Foods"); }
if (criteria.SearchBeverages) { types.Add("Beverages"); }
if (criteria.SearchDeliCounter) { types.Add("Deli Counter"); }

return _DB.FoodItems.Where(x => x.FoodTitle == SearchString &&
                                types.Contains(x.Type));

列表类型=新列表（）；
if（criteria.SearchFreshFoods）{types.Add（“新鲜食品”）；}
if（criteria.SearchFrozenFoods）{types.Add（“冷冻食品”）；}
if（criteria.SearchBeverages）{types.Add（“Beverages”）；}
if（criteria.SearchDeliCounter）{types.Add（“Deli计数器”）；}
返回_DB.FoodItems.Where（x=>x.FoodTitle==SearchString&&
包含（x.Type））；

这意味着只有一个SQL查询，这很方便

---

您当然可以重构FoodSearchCriteria类型，以使构建列表更容易…

我没有时间回顾，但这可能是一个未经测试的解决方案

class SearchItem
{
   string Name {get; set;}
   bool IsSelected {get; set;}
}

class FoodSearchCriteria
{
   String searchText {get; set;}
   IList<SearchItem> SearchItems{ get; }
}

public IList<FoodItem> FindFoodItems(FoodSearchCriteria criteria)
// in reality, this is a fuzzy search not an exact match
var matches = _DB.FoodItems.Where(x => x.FoodTitle == criteria.SearchText && 
                                      criteria.SearchItems.Where(si => si.IsSelected).Contains(i => i.Name == x.Type));

return mathces;
}

类搜索项
{
字符串名称{get；set；}
布尔被选为{get；set；}
}
食品类搜索标准
{
字符串搜索文本{get；set；}
IList SearchItems{get；}
}
公共IList FindFoodItems（食品搜索标准）
//实际上，这是一种模糊搜索，而不是精确匹配
var matches=_DB.FoodItems.Where（x=>x.FoodTitle==criteria.SearchText&&
其中（si=>si.IsSelected）.包含（i=>i.Name==x.Type））；
返回数学；
}

我没有时间回顾，但这可能是一个未经测试的解决方案

class SearchItem
{
   string Name {get; set;}
   bool IsSelected {get; set;}
}

class FoodSearchCriteria
{
   String searchText {get; set;}
   IList<SearchItem> SearchItems{ get; }
}

public IList<FoodItem> FindFoodItems(FoodSearchCriteria criteria)
// in reality, this is a fuzzy search not an exact match
var matches = _DB.FoodItems.Where(x => x.FoodTitle == criteria.SearchText && 
                                      criteria.SearchItems.Where(si => si.IsSelected).Contains(i => i.Name == x.Type));

return mathces;
}

类搜索项
{
字符串名称{get；set；}
布尔被选为{get；set；}
}
食品类搜索标准
{
字符串搜索文本{get；set；}
IList SearchItems{get；}
}
公共IList FindFoodItems（食品搜索标准）
//实际上，这是一种模糊搜索，而不是精确匹配
var matches=_DB.FoodItems.Where（x=>x.FoodTitle==criteria.SearchText&&
其中（si=>si.IsSelected）.包含（i=>i.Name==x.Type））；
返回数学；
}

看起来不灵活。pb==谓词？看起来不完整。pb==谓词？请随意详细说明您心目中的重构：）现在还不确定。。。但至少，将构建列表的代码放到该类中是有意义的。请随意详细说明您想要的重构：）不确定。。。但至少将构建列表的代码放入该类中是有意义的。