C# `或“介于”之间。其中“使用Linq或实体”

我有一个使用linq从

单词
表中搜索的函数。我想
.split（“”）
输入单词并搜索每个单词。但是我想要
或
在我的条件之间，而不是
和
。请参阅生成的SQL代码

public static List<Word> GetWords(string word_Fa, string word_En)
{
    var db = Global.GetEntitiy();

    var query = from item in db.Words
                select item;

    foreach (var item in word_Fa.Split(' '))
    {
        query = query.Where(a => a.Word_Fa.Contains(item));
    }

    foreach (var item in word_En.Split(' '))
    {
        query = query.Where(a => a.Word_En.Contains(item));
    }

    return query.ToList();
}

您想在
query
中的每个项目中检查
word\u-Fa
，并在
word\u-Fa.Split（“”）
中检查每个项目。因此，在该字符串上连接它们，它将为您提供
query
中的所有项目，这些项目也位于
word\u Fa.Split（“”）
：

您想在
query
中的每个项目中检查
word\u-Fa
，并在
word\u-Fa.Split（“”）
中检查每个项目。因此，在该字符串上连接它们，它将为您提供
query
中的所有项目，这些项目也位于
word\u Fa.Split（“”）
：

您想在
query
中的每个项目中检查
word\u-Fa
，并在
word\u-Fa.Split（“”）
中检查每个项目。因此，在该字符串上连接它们，它将为您提供
query
中的所有项目，这些项目也位于
word\u Fa.Split（“”）
：

您想在
query
中的每个项目中检查
word\u-Fa
，并在
word\u-Fa.Split（“”）
中检查每个项目。因此，在该字符串上连接它们，它将为您提供
query
中的所有项目，这些项目也位于
word\u Fa.Split（“”）
：

你可以考虑使用谓词生成器，如Hadi Hassan在评论中所说的。
通过使用它，您的代码将如下所示：
var predicate = PredicateBuilder.False<Words>();

var query = from item in Words
            select item;

var FaWords = "A B C".Split(' ');
var EnWords = "D E F".Split(' ');

foreach (string item in FaWords)
{
    predicate = predicate.Or(p => p.Word_Fa.Contains(item));
}

foreach (string item in EnWords)
{
    predicate = predicate.Or(p => p.Word_En.Contains(item));
}

return query.Where(predicate).toList();

顺便说一下，如果出现以下错误：LINQ to实体中不支持LINQ表达式节点类型“Invoke”

您应该将nuget包添加到项目中，并将返回行更改为：

return query.AsExpandable().Where(predicate).toList();

<好运> 
 你可以考虑使用谓词生成器，如Hadi Hassan在评论中所说的。
通过使用它，您的代码将如下所示：

var predicate = PredicateBuilder.False<Words>();

var query = from item in Words
            select item;

var FaWords = "A B C".Split(' ');
var EnWords = "D E F".Split(' ');

foreach (string item in FaWords)
{
    predicate = predicate.Or(p => p.Word_Fa.Contains(item));
}

foreach (string item in EnWords)
{
    predicate = predicate.Or(p => p.Word_En.Contains(item));
}

return query.Where(predicate).toList();

顺便说一下，如果出现以下错误：LINQ to实体中不支持LINQ表达式节点类型“Invoke”

您应该将nuget包添加到项目中，并将返回行更改为：

return query.AsExpandable().Where(predicate).toList();

<好运> 
 你可以考虑使用谓词生成器，如Hadi Hassan在评论中所说的。
通过使用它，您的代码将如下所示：

var predicate = PredicateBuilder.False<Words>();

var query = from item in Words
            select item;

var FaWords = "A B C".Split(' ');
var EnWords = "D E F".Split(' ');

foreach (string item in FaWords)
{
    predicate = predicate.Or(p => p.Word_Fa.Contains(item));
}

foreach (string item in EnWords)
{
    predicate = predicate.Or(p => p.Word_En.Contains(item));
}

return query.Where(predicate).toList();

顺便说一下，如果出现以下错误：LINQ to实体中不支持LINQ表达式节点类型“Invoke”

您应该将nuget包添加到项目中，并将返回行更改为：

return query.AsExpandable().Where(predicate).toList();

<好运> 
 你可以考虑使用谓词生成器，如Hadi Hassan在评论中所说的。
通过使用它，您的代码将如下所示：

var predicate = PredicateBuilder.False<Words>();

var query = from item in Words
            select item;

var FaWords = "A B C".Split(' ');
var EnWords = "D E F".Split(' ');

foreach (string item in FaWords)
{
    predicate = predicate.Or(p => p.Word_Fa.Contains(item));
}

foreach (string item in EnWords)
{
    predicate = predicate.Or(p => p.Word_En.Contains(item));
}

return query.Where(predicate).toList();

顺便说一下，如果出现以下错误：LINQ to实体中不支持LINQ表达式节点类型“Invoke”

您应该将nuget包添加到项目中，并将返回行更改为：

return query.AsExpandable().Where(predicate).toList();

祝你好运
除非我错过了什么，否则我认为这应该对你有用：

public static List<Word> GetWords(string word_Fa, string word_En)
{
    var db = Global.GetEntitiy();
    return db.Words
                .Where(w => w.Word_Fa.Intersect(word_Fa.Split(' ')).Any() ||
                            w.Word_En.Intersect(word_En.Split(' ')).Any())
                .ToList();
}

公共静态列表GetWords（字符串单词\u Fa，字符串单词\u En）
{
var db=Global.GetEntitiy（）；
返回db.Words
其中（w=>w.Word\u Fa.Intersect（Word\u Fa.Split（“”））.Any（）||
w、 单词相交（单词分割（“”））.Any（）
.ToList（）；
}
除非我遗漏了什么，否则我认为这应该适合您：

public static List<Word> GetWords(string word_Fa, string word_En)
{
    var db = Global.GetEntitiy();
    return db.Words
                .Where(w => w.Word_Fa.Intersect(word_Fa.Split(' ')).Any() ||
                            w.Word_En.Intersect(word_En.Split(' ')).Any())
                .ToList();
}

公共静态列表GetWords（字符串单词\u Fa，字符串单词\u En）
{
var db=Global.GetEntitiy（）；
返回db.Words
其中（w=>w.Word\u Fa.Intersect（Word\u Fa.Split（“”））.Any（）||
w、 单词相交（单词分割（“”））.Any（）
.ToList（）；
}
除非我遗漏了什么，否则我认为这应该适合您：

public static List<Word> GetWords(string word_Fa, string word_En)
{
    var db = Global.GetEntitiy();
    return db.Words
                .Where(w => w.Word_Fa.Intersect(word_Fa.Split(' ')).Any() ||
                            w.Word_En.Intersect(word_En.Split(' ')).Any())
                .ToList();
}

公共静态列表GetWords（字符串单词\u Fa，字符串单词\u En）
{
var db=Global.GetEntitiy（）；
返回db.Words
其中（w=>w.Word\u Fa.Intersect（Word\u Fa.Split（“”））.Any（）||
w、 单词相交（单词分割（“”））.Any（）
.ToList（）；
}
除非我遗漏了什么，否则我认为这应该适合您：

public static List<Word> GetWords(string word_Fa, string word_En)
{
    var db = Global.GetEntitiy();
    return db.Words
                .Where(w => w.Word_Fa.Intersect(word_Fa.Split(' ')).Any() ||
                            w.Word_En.Intersect(word_En.Split(' ')).Any())
                .ToList();
}

公共静态列表GetWords（字符串单词\u Fa，字符串单词\u En）
{
var db=Global.GetEntitiy（）；
返回db.Words
其中（w=>w.Word\u Fa.Intersect（Word\u Fa.Split（“”））.Any（）||
w、 单词相交（单词分割（“”））.Any（）
.ToList（）；
}
不使用LinqKit的解决方案：

扩展类与PredicateBuilder非常相似，但它可与linq to entities和linq to sql一起使用：

public static class PredicateHelper
{
    public static Expression<Func<T, bool>> True<T>() { return f => true; }
    public static Expression<Func<T, bool>> False<T>() { return f => false; }

    public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1,
                                                        Expression<Func<T, bool>> expr2)
    {
        if (expr1 == null)
        {
            throw new ArgumentNullException("expr1");
        }
        if (expr2 == null)
        {
            throw new ArgumentNullException("expr2");
        }
        var visitor = new ParameterUpdateVisitor(expr2.Parameters.First(), expr1.Parameters.First());
        expr2 = visitor.Visit(expr2) as Expression<Func<T, bool>>;
        return Expression.Lambda<Func<T, bool>>
              (Expression.OrElse(expr1.Body, expr2.Body), expr1.Parameters);
    }

    public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,
                                                         Expression<Func<T, bool>> expr2)
    {
        if (expr1==null)
        {
            throw new ArgumentNullException("expr1");
        }
        if (expr2 == null)
        {
            throw new ArgumentNullException("expr2");
        }
        var visitor = new ParameterUpdateVisitor(expr2.Parameters.First(), expr1.Parameters.First());
        expr2 = visitor.Visit(expr2) as Expression<Func<T, bool>>;
        return Expression.Lambda<Func<T, bool>>
              (Expression.AndAlso(expr1.Body, expr2.Body), expr1.Parameters);
    }

    class ParameterUpdateVisitor : ExpressionVisitor
    {
        private readonly ParameterExpression _oldParameter;
        private readonly ParameterExpression _newParameter;

        public ParameterUpdateVisitor(ParameterExpression oldParameter, ParameterExpression newParameter)
        {
            _oldParameter = oldParameter;
            _newParameter = newParameter;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (ReferenceEquals(node, _oldParameter))
                return _newParameter;

            return base.VisitParameter(node);
        }
    }
}

公共静态类谓词帮助器
{
公共静态表达式True（）{return f=>True；}
公共静态表达式False（）{return f=>False；}
公共静态表达式或（此表达式expr1，
表达式expr2）
{
if（expr1==null）
{
抛出新的ArgumentNullException（“expr1”）；
}
if（expr2==null）
{
抛出新的ArgumentNullException（“expr2”）；
}
var visitor=new参数updatevisitor（expr2.Parameters.First（），expr1.Parameters.First（））；
expr2=visitor.Visit（expr2）作为表达式；
返回表达式.Lambda
（Expression.OrElse（expr1.Body，expr2.Body），expr1.Parameters）；
}
公共静态表达式和（此表达式expr1，
表达式expr2）
{
if（expr1==null）
{
抛出新的ArgumentNullException（“expr1”）；
}
if（expr2==null）
{
抛出新的ArgumentNullException（“expr2”）；
}
var visitor=new参数updatevisitor（expr2.Parameters.First（），expr1.Parameters.First（））；
expr2=visitor.Visit（expr2）作为表达式；
返回表达式.Lambda
（Expression.AndAlso（expr1.Body，expr2.Body），expr1.Parameters）；
}
类参数UpdateVisitor:ExpressionVisitor
{
普里夫