blocks|key|744623|text|您可以使用谓词调用单个方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|744624|var+portCode+=+Database.DischargePorts
+++++++++++++++++++.Single(p+=>+p.PortName.Contains("BALTIMORE"))
+++++++++++++++++++.PortCode;|code-block|syntax|javascript|744625|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can call the single method with a predicate:

<pre><code>var portCode = Database.DischargePorts
 .Single(p =&gt; p.PortName.Contains("BALTIMORE"))
 .PortCode;
</code></pre>

blocks|key|960649|text|正如Jon+Skeet和Marc+Gravell已经提到的，您可以简单地接受一个包含条件。但是在您的like查询中，使用单个()语句是非常危险的，因为这意味着您只能找到1个结果。如果有更多的结果，您将收到一个很好的异常:)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|960650|所以我更喜欢使用FirstOrDefault()而不是Single()：|960651|var+first+=+Database.DischargePorts.FirstOrDefault(p+=>+p.PortName.Contains("BALTIMORE"));
var+portcode+=+first+!=+null+?+first.PortCode+:+string.Empty;|code-block|syntax|javascript|960652|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

As Jon Skeet and Marc Gravell already mentioned, you can simple take a contains condition. But in case of your like query, it's very dangerous to take a Single() statement, because that implies that you only find 1 result. In case of more results, you'll receive a nice exception :)

So I would prefer using FirstOrDefault() instead of Single():

<pre><code>var first = Database.DischargePorts.FirstOrDefault(p =&gt; p.PortName.Contains("BALTIMORE"));
var portcode = first != null ? first.PortCode : string.Empty;
</code></pre>

blocks|key|744748|text|++.Where(e+=>+e.Value.StartsWith("BALTIMORE"))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|744749|这就像SQL的"+like“一样……|unstyled|744750|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code> .Where(e =&gt; e.Value.StartsWith("BALTIMORE"))
</code></pre>

This works like "LIKE" of SQL...

blocks|key|960743|text|像这样一个简单的例子|type|unstyled|depth|inlineStyleRanges|entityRanges|data|960744|string[]+users+=+new+string[]+{"Paul","Steve","Annick","Yannick"};++++
var+result+=+from+u+in+users+where+u.Contains("nn")+select+u;|code-block|syntax|javascript|960745|结果->安尼克，扬尼克|960746|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

A simple as this

<pre><code>string[] users = new string[] {"Paul","Steve","Annick","Yannick"}; 
var result = from u in users where u.Contains("nn") select u;
</code></pre>

Result -> Annick,Yannick

blocks|key|960792|text|好吧..。有时使用Contains，StartsWith或EndsWith可能会很不舒服，特别是当搜索值确定LIKE语句时，例如，传递的'+value+%25‘要求开发人员在表达式中使用StartsWith函数。所以我决定为IQueryable对象编写扩展。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|960793|用法|960794|//+numbers:+11-000-00,+00-111-00,+00-000-11

var+data1+=+parts.Like(p+=>+p.Number,+"%2511%25");
//+result:+11-000-00,+00-111-00,+00-000-11

var+data2+=+parts.Like(p+=>+p.Number,+"11%25");
//+result:+11-000-00

var+data3+=+parts.Like(p+=>+p.Number,+"%2511");
//+result:+00-000-11|code-block|syntax|javascript|960795|代码|960796|public+static+class+LinqEx
{
++++private+static+readonly+MethodInfo+ContainsMethod+=+typeof(string).GetMethod("Contains");
++++private+static+readonly+MethodInfo+StartsWithMethod+=+typeof(string).GetMethod("StartsWith",+new[]+{+typeof(string)+});
++++private+static+readonly+MethodInfo+EndsWithMethod+=+typeof(string).GetMethod("EndsWith",+new[]+{+typeof(string)+});

++++public+static+Expression<Func<TSource,+bool>>+LikeExpression<TSource,+TMember>(Expression<Func<TSource,+TMember>>+property,+string+value)
++++{
++++++++var+param+=+Expression.Parameter(typeof(TSource),+"t");
++++++++var+propertyInfo+=+GetPropertyInfo(property);
++++++++var+member+=+Expression.Property(param,+propertyInfo.Name);

++++++++var+startWith+=+value.StartsWith("%25");
++++++++var+endsWith+=+value.EndsWith("%25");

++++++++if+(startWith)
++++++++++++value+=+value.Remove(0,+1);

++++++++if+(endsWith)
++++++++++++value+=+value.Remove(value.Length+-+1,+1);

++++++++var+constant+=+Expression.Constant(value);
++++++++Expression+exp;

++++++++if+(endsWith+&&+startWith)
++++++++{
++++++++++++exp+=+Expression.Call(member,+ContainsMethod,+constant);
++++++++}
++++++++else+if+(startWith)+
++++++++{
++++++++++++exp+=+Expression.Call(member,+EndsWithMethod,+constant);
++++++++}
++++++++else+if+(endsWith)
++++++++{
++++++++++++exp+=+Expression.Call(member,+StartsWithMethod,+constant);
++++++++}
++++++++else
++++++++{
++++++++++++exp+=+Expression.Equal(member,+constant);
++++++++}

++++++++return+Expression.Lambda<Func<TSource,+bool>>(exp,+param);
++++}

++++public+static+IQueryable<TSource>+Like<TSource,+TMember>(this+IQueryable<TSource>+source,+Expression<Func<TSource,+TMember>>+parameter,+string+value)
++++{
++++++++return+source.Where(LikeExpression(parameter,+value));
++++}

++++private+static+PropertyInfo+GetPropertyInfo(Expression+expression)
++++{
++++++++var+lambda+=+expression+as+LambdaExpression;
++++++++if+(lambda+==+null)
++++++++++++throw+new+ArgumentNullException("expression");

++++++++MemberExpression+memberExpr+=+null;

++++++++switch+(lambda.Body.NodeType)
++++++++{
++++++++++++case+ExpressionType.Convert:
++++++++++++++++memberExpr+=+((UnaryExpression)lambda.Body).Operand+as+MemberExpression;
++++++++++++++++break;
++++++++++++case+ExpressionType.MemberAccess:
++++++++++++++++memberExpr+=+lambda.Body+as+MemberExpression;
++++++++++++++++break;
++++++++}

++++++++if+(memberExpr+==+null)
++++++++++++throw+new+InvalidOperationException("Specified+expression+is+invalid.+Unable+to+determine+property+info+from+expression.");


++++++++var+output+=+memberExpr.Member+as+PropertyInfo;

++++++++if+(output+==+null)
++++++++++++throw+new+InvalidOperationException("Specified+expression+is+invalid.+Unable+to+determine+property+info+from+expression.");

++++++++return+output;
++++}
}|960797|entityMap^0|9|8|I|A|T|8|1I|4|2J|A|32|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|15|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|16|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|R|$]]

Well... sometimes it may be uncomfortable to use <code>Contains</code>, <code>StartsWith</code> or <code>EndsWith</code> especially when searching value determine <code>LIKE</code> statment e.g. passed 'value%' require from developer to use <code>StartsWith</code> function in expression. So I decided to write extension for <code>IQueryable</code> objects.

Usage

<pre><code>// numbers: 11-000-00, 00-111-00, 00-000-11

var data1 = parts.Like(p =&gt; p.Number, "%11%");
// result: 11-000-00, 00-111-00, 00-000-11

var data2 = parts.Like(p =&gt; p.Number, "11%");
// result: 11-000-00

var data3 = parts.Like(p =&gt; p.Number, "%11");
// result: 00-000-11
</code></pre>

Code

<pre><code>public static class LinqEx
{
 private static readonly MethodInfo ContainsMethod = typeof(string).GetMethod("Contains");
 private static readonly MethodInfo StartsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
 private static readonly MethodInfo EndsWithMethod = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });

 public static Expression&lt;Func&lt;TSource, bool&gt;&gt; LikeExpression&lt;TSource, TMember&gt;(Expression&lt;Func&lt;TSource, TMember&gt;&gt; property, string value)
 {
 var param = Expression.Parameter(typeof(TSource), "t");
 var propertyInfo = GetPropertyInfo(property);
 var member = Expression.Property(param, propertyInfo.Name);

 var startWith = value.StartsWith("%");
 var endsWith = value.EndsWith("%");

 if (startWith)
 value = value.Remove(0, 1);

 if (endsWith)
 value = value.Remove(value.Length - 1, 1);

 var constant = Expression.Constant(value);
 Expression exp;

 if (endsWith &amp;&amp; startWith)
 {
 exp = Expression.Call(member, ContainsMethod, constant);
 }
 else if (startWith) 
 {
 exp = Expression.Call(member, EndsWithMethod, constant);
 }
 else if (endsWith)
 {
 exp = Expression.Call(member, StartsWithMethod, constant);
 }
 else
 {
 exp = Expression.Equal(member, constant);
 }

 return Expression.Lambda&lt;Func&lt;TSource, bool&gt;&gt;(exp, param);
 }

 public static IQueryable&lt;TSource&gt; Like&lt;TSource, TMember&gt;(this IQueryable&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, TMember&gt;&gt; parameter, string value)
 {
 return source.Where(LikeExpression(parameter, value));
 }

 private static PropertyInfo GetPropertyInfo(Expression expression)
 {
 var lambda = expression as LambdaExpression;
 if (lambda == null)
 throw new ArgumentNullException("expression");

 MemberExpression memberExpr = null;

 switch (lambda.Body.NodeType)
 {
 case ExpressionType.Convert:
 memberExpr = ((UnaryExpression)lambda.Body).Operand as MemberExpression;
 break;
 case ExpressionType.MemberAccess:
 memberExpr = lambda.Body as MemberExpression;
 break;
 }

 if (memberExpr == null)
 throw new InvalidOperationException("Specified expression is invalid. Unable to determine property info from expression.");


 var output = memberExpr.Member as PropertyInfo;

 if (output == null)
 throw new InvalidOperationException("Specified expression is invalid. Unable to determine property info from expression.");

 return output;
 }
}
</code></pre>

blocks|key|744877|text|+++public+static+class+StringEx
++++{
++++++++public+static+bool+Contains(this+String+str,+string[]+Arr,+StringComparison+comp)
++++++++{
++++++++++++if+(Arr+!=+null)
++++++++++++{
++++++++++++++++foreach+(string+s+in+Arr)
++++++++++++++++{
++++++++++++++++++++if+(str.IndexOf(s,+comp)>=0)
++++++++++++++++++++{+return+true;+}
++++++++++++++++}
++++++++++++}

++++++++++++return+false;
++++++++}

++++++++public+static+bool+Contains(this+String+str,string[]+Arr)
++++++++{
++++++++++++if+(Arr+!=+null)
++++++++++++{
++++++++++++++++foreach+(string+s+in+Arr)
++++++++++++++++{
++++++++++++++++++++if+(str.Contains(s))
++++++++++++++++++++{+return+true;+}
++++++++++++++++}
++++++++++++}

++++++++++++return+false;
++++++++}
++++}


var+portCode+=+Database.DischargePorts
+++++++++++++++++++.Single(p+=>+p.PortName.Contains(+new+string[]+{"BALTIMORE"},++StringComparison.CurrentCultureIgnoreCase)+))
+++++++++++++++++++.PortCode;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|744878|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> public static class StringEx
 {
 public static bool Contains(this String str, string[] Arr, StringComparison comp)
 {
 if (Arr != null)
 {
 foreach (string s in Arr)
 {
 if (str.IndexOf(s, comp)&gt;=0)
 { return true; }
 }
 }

 return false;
 }

 public static bool Contains(this String str,string[] Arr)
 {
 if (Arr != null)
 {
 foreach (string s in Arr)
 {
 if (str.Contains(s))
 { return true; }
 }
 }

 return false;
 }
 }


var portCode = Database.DischargePorts
 .Single(p =&gt; p.PortName.Contains( new string[] {"BALTIMORE"}, StringComparison.CurrentCultureIgnoreCase) ))
 .PortCode;
</code></pre>

blocks|key|960846|text|只需添加到字符串对象扩展方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|960847|public+static+class+StringEx
{
++++public+static+bool+Contains(this+String+str,+string[]+Arr,+StringComparison+comp)
++++{
++++++++if+(Arr+!=+null)
++++++++{
++++++++++++foreach+(string+s+in+Arr)
++++++++++++{
++++++++++++++++if+(str.IndexOf(s,+comp)>=0)
++++++++++++++++{+return+true;+}
++++++++++++}
++++++++}

++++++++return+false;
++++}

++++public+static+bool+Contains(this+String+str,string[]+Arr)
++++{
++++++++if+(Arr+!=+null)
++++++++{
++++++++++++foreach+(string+s+in+Arr)
++++++++++++{
++++++++++++++++if+(str.Contains(s))
++++++++++++++++{+return+true;+}
++++++++++++}
++++++++}

++++++++return+false;
++++}
}|code-block|syntax|javascript|960848|用法：|960849|use+namespase+that+contains+this+class;

var+sPortCode+=+Database.DischargePorts
++++++++++++.Where(p+=>+p.PortName.Contains(new+string+[]+{"BALTIMORE"},++StringComparison.CurrentCultureIgnoreCase)+)
++++++++++++.Single().PortCode;|960850|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just add to string object extention methods. 

<pre><code>public static class StringEx
{
 public static bool Contains(this String str, string[] Arr, StringComparison comp)
 {
 if (Arr != null)
 {
 foreach (string s in Arr)
 {
 if (str.IndexOf(s, comp)&gt;=0)
 { return true; }
 }
 }

 return false;
 }

 public static bool Contains(this String str,string[] Arr)
 {
 if (Arr != null)
 {
 foreach (string s in Arr)
 {
 if (str.Contains(s))
 { return true; }
 }
 }

 return false;
 }
}
</code></pre>

usage: 

<pre><code>use namespase that contains this class;

var sPortCode = Database.DischargePorts
 .Where(p =&gt; p.PortName.Contains(new string [] {"BALTIMORE"}, StringComparison.CurrentCultureIgnoreCase) )
 .Single().PortCode;
</code></pre>

blocks|key|960879|text|在原生LINQ中，您可以组合使用Contains/StartsWith/EndsWith或RegExp。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|960880|在LINQ2SQL中使用方法SqlMethods.Like()|960881|++++from+i+in+db.myTable
++++where+SqlMethods.Like(i.field,+"tra%25ata")
++++select+i|code-block|syntax|javascript|960882|添加Assembly:+System.Data.Linq+(在System.Data.Linq.dll中)以使用此功能。|960883|entityMap^0|G|S|0|E|H|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

In native LINQ you may use combination of <code>Contains/StartsWith/EndsWith</code> or RegExp.

In LINQ2SQL use method <code>SqlMethods.Like()</code>

<pre><code> from i in db.myTable
 where SqlMethods.Like(i.field, "tra%ata")
 select i
</code></pre>

add Assembly: System.Data.Linq (in System.Data.Linq.dll) to use this feature.

blocks|key|744962|text|理想情况下，您应该使用StartWith或EndWith。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|744963|下面是一个示例：|744964|DataContext++dc+=+new+DCGeneral();
List<Person>+lstPerson=+dc.GetTable<Person>().StartWith(c=>+c.strNombre).ToList();

return+lstPerson;|code-block|syntax|javascript|744965|entityMap^0|B|9|L|7|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Ideally you should use <code>StartWith</code> or <code>EndWith</code>.

Here is an example:

<pre><code>DataContext dc = new DCGeneral();
List&lt;Person&gt; lstPerson= dc.GetTable&lt;Person&gt;().StartWith(c=&gt; c.strNombre).ToList();

return lstPerson;
</code></pre>

blocks|key|960911|text|List<Categories>+categoriess;
++++++++private+void+Buscar()
++++++++{
++++++++++++try
++++++++++++{
++++++++++++++++categoriess+=+Contexto.Categories.ToList();
++++++++++++++++categoriess+=+categoriess.Where(n+=>+n.CategoryID+>=+Convert.ToInt32(txtCatID.Text)+&&+n.CategoryID+<=+Convert.ToInt32(txtCatID1.Text)+&&+(n.CategoryName.Contains(txtCatName.Text))+).ToList();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|960912|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>List&lt;Categories&gt; categoriess;
 private void Buscar()
 {
 try
 {
 categoriess = Contexto.Categories.ToList();
 categoriess = categoriess.Where(n =&gt; n.CategoryID &gt;= Convert.ToInt32(txtCatID.Text) &amp;&amp; n.CategoryID &lt;= Convert.ToInt32(txtCatID1.Text) &amp;&amp; (n.CategoryName.Contains(txtCatName.Text)) ).ToList();
</code></pre>

blocks|key|745016|text|@adobrzyc有这个很棒的自定义LIKE函数--我只是想分享它的IEnumerable版本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|745017|public+static+class+LinqEx
{
++++private+static+readonly+MethodInfo+ContainsMethod+=+typeof(string).GetMethod("Contains");
++++private+static+readonly+MethodInfo+StartsWithMethod+=+typeof(string).GetMethod("StartsWith",+new[]+{+typeof(string)+});
++++private+static+readonly+MethodInfo+EndsWithMethod+=+typeof(string).GetMethod("EndsWith",+new[]+{+typeof(string)+});

++++private+static+Func<TSource,+bool>+LikeExpression<TSource,+TMember>(Expression<Func<TSource,+TMember>>+property,+string+value)
++++{
++++++++var+param+=+Expression.Parameter(typeof(TSource),+"t");
++++++++var+propertyInfo+=+GetPropertyInfo(property);
++++++++var+member+=+Expression.Property(param,+propertyInfo.Name);

++++++++var+startWith+=+value.StartsWith("%25");
++++++++var+endsWith+=+value.EndsWith("%25");

++++++++if+(startWith)
++++++++++++value+=+value.Remove(0,+1);

++++++++if+(endsWith)
++++++++++++value+=+value.Remove(value.Length+-+1,+1);

++++++++var+constant+=+Expression.Constant(value);
++++++++Expression+exp;

++++++++if+(endsWith+&&+startWith)
++++++++{
++++++++++++exp+=+Expression.Call(member,+ContainsMethod,+constant);
++++++++}
++++++++else+if+(startWith)
++++++++{
++++++++++++exp+=+Expression.Call(member,+EndsWithMethod,+constant);
++++++++}
++++++++else+if+(endsWith)
++++++++{
++++++++++++exp+=+Expression.Call(member,+StartsWithMethod,+constant);
++++++++}
++++++++else
++++++++{
++++++++++++exp+=+Expression.Equal(member,+constant);
++++++++}

++++++++return+Expression.Lambda<Func<TSource,+bool>>(exp,+param).Compile();
++++}

++++public+static+IEnumerable<TSource>+Like<TSource,+TMember>(this+IEnumerable<TSource>+source,+Expression<Func<TSource,+TMember>>+parameter,+string+value)
++++{
++++++++return+source.Where(LikeExpression(parameter,+value));
++++}


++++private+static+PropertyInfo+GetPropertyInfo(Expression+expression)
++++{
++++++++var+lambda+=+expression+as+LambdaExpression;
++++++++if+(lambda+==+null)
++++++++++++throw+new+ArgumentNullException("expression");

++++++++MemberExpression+memberExpr+=+null;

++++++++switch+(lambda.Body.NodeType)
++++++++{
++++++++++++case+ExpressionType.Convert:
++++++++++++++++memberExpr+=+((UnaryExpression)lambda.Body).Operand+as+MemberExpression;
++++++++++++++++break;
++++++++++++case+ExpressionType.MemberAccess:
++++++++++++++++memberExpr+=+lambda.Body+as+MemberExpression;
++++++++++++++++break;
++++++++}

++++++++if+(memberExpr+==+null)
++++++++++++throw+new+InvalidOperationException("Specified+expression+is+invalid.+Unable+to+determine+property+info+from+expression.");


++++++++var+output+=+memberExpr.Member+as+PropertyInfo;

++++++++if+(output+==+null)
++++++++++++throw+new+InvalidOperationException("Specified+expression+is+invalid.+Unable+to+determine+property+info+from+expression.");

++++++++return+output;
++++}
}|code-block|syntax|javascript|745018|entityMap^0|I|4|Y|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

@adobrzyc had this great custom <code>LIKE</code> function - I just wanted to share the <code>IEnumerable</code> version of it.
<pre><code>public static class LinqEx
{
 private static readonly MethodInfo ContainsMethod = typeof(string).GetMethod(&quot;Contains&quot;);
 private static readonly MethodInfo StartsWithMethod = typeof(string).GetMethod(&quot;StartsWith&quot;, new[] { typeof(string) });
 private static readonly MethodInfo EndsWithMethod = typeof(string).GetMethod(&quot;EndsWith&quot;, new[] { typeof(string) });

 private static Func&lt;TSource, bool&gt; LikeExpression&lt;TSource, TMember&gt;(Expression&lt;Func&lt;TSource, TMember&gt;&gt; property, string value)
 {
 var param = Expression.Parameter(typeof(TSource), &quot;t&quot;);
 var propertyInfo = GetPropertyInfo(property);
 var member = Expression.Property(param, propertyInfo.Name);

 var startWith = value.StartsWith(&quot;%&quot;);
 var endsWith = value.EndsWith(&quot;%&quot;);

 if (startWith)
 value = value.Remove(0, 1);

 if (endsWith)
 value = value.Remove(value.Length - 1, 1);

 var constant = Expression.Constant(value);
 Expression exp;

 if (endsWith &amp;&amp; startWith)
 {
 exp = Expression.Call(member, ContainsMethod, constant);
 }
 else if (startWith)
 {
 exp = Expression.Call(member, EndsWithMethod, constant);
 }
 else if (endsWith)
 {
 exp = Expression.Call(member, StartsWithMethod, constant);
 }
 else
 {
 exp = Expression.Equal(member, constant);
 }

 return Expression.Lambda&lt;Func&lt;TSource, bool&gt;&gt;(exp, param).Compile();
 }

 public static IEnumerable&lt;TSource&gt; Like&lt;TSource, TMember&gt;(this IEnumerable&lt;TSource&gt; source, Expression&lt;Func&lt;TSource, TMember&gt;&gt; parameter, string value)
 {
 return source.Where(LikeExpression(parameter, value));
 }


 private static PropertyInfo GetPropertyInfo(Expression expression)
 {
 var lambda = expression as LambdaExpression;
 if (lambda == null)
 throw new ArgumentNullException(&quot;expression&quot;);

 MemberExpression memberExpr = null;

 switch (lambda.Body.NodeType)
 {
 case ExpressionType.Convert:
 memberExpr = ((UnaryExpression)lambda.Body).Operand as MemberExpression;
 break;
 case ExpressionType.MemberAccess:
 memberExpr = lambda.Body as MemberExpression;
 break;
 }

 if (memberExpr == null)
 throw new InvalidOperationException(&quot;Specified expression is invalid. Unable to determine property info from expression.&quot;);


 var output = memberExpr.Member as PropertyInfo;

 if (output == null)
 throw new InvalidOperationException(&quot;Specified expression is invalid. Unable to determine property info from expression.&quot;);

 return output;
 }
}
</code></pre>

blocks|key|961037|text|如扩展Linq+/+SQL|type|unstyled|depth|inlineStyleRanges|entityRanges|data|961038|LikeExtension类|961039|在.NET+5中测试|961040|+public+static+class+LikeExtension+{

++++private+static+string+ColumnDataBase<TEntity,+TKey>(IModel+model,+Expression<Func<TEntity,+TKey>>+predicate)+where+TEntity+:+class+{

++++++++ITable+table+=+model
++++++++++++.GetRelationalModel()
++++++++++++.Tables
++++++++++++.First(f+=>+f
++++++++++++++++.EntityTypeMappings
++++++++++++++++.First()
++++++++++++++++.EntityType+==+model
++++++++++++++++.FindEntityType(predicate
++++++++++++++++++++.Parameters
++++++++++++++++++++.First()
++++++++++++++++.Type
++++++++++++));

++++++++string+column+=+(predicate.Body+as+MemberExpression).Member.Name;
++++++++string+columnDataBase+=+table.Columns.First(f+=>+f.PropertyMappings.Count(f2+=>+f2.Property.Name+==+column)+>+0).Name;

++++++++return+columnDataBase;

++++}

++++public+static+IQueryable<TEntity>+Like<TEntity,+TKey>(this+DbContext+context,+Expression<Func<TEntity,+TKey>>+predicate,+string+text)+where+TEntity+:+class+{

++++++++string+columnDataBase+=+ColumnDataBase(context.Model,+predicate);
++++++++return+context.Set<TEntity>().FromSqlRaw(context.Set<TEntity>().ToQueryString()+%2B+"+WHERE+["+%2B+columnDataBase+%2B+"]+LIKE+{0}",+text);

++++}

++++public+static+async+Task<IEnumerable<TEntity>>+LikeAsync<TEntity,+TKey>(this+DbContext+context,+Expression<Func<TEntity,+TKey>>+predicate,+string+text,+CancellationToken+cancellationToken)+where+TEntity+:+class+{

++++++++string+columnDataBase+=+ColumnDataBase(context.Model,+predicate);
++++++++return+await+context.Set<TEntity>().FromSqlRaw(context.Set<TEntity>().ToQueryString()+%2B+"+WHERE+["+%2B+columnDataBase+%2B+"]+LIKE+{0}",+text).ToListAsync(cancellationToken);

++++}

++++public+static+async+Task<IEnumerable<TEntity>>+LikeAsync<TEntity,+TKey>(this+IQueryable<TEntity>+query,+Expression<Func<TEntity,+TKey>>+predicate,+string+text,+CancellationToken+cancellationToken)+where+TEntity+:+class+{

++++++++DbSet<TEntity>+entities+=+query+as+DbSet<TEntity>;
++++++++string+columnDataBase+=+ColumnDataBase(entities.EntityType.Model,+predicate);
++++++++return+await+entities.FromSqlRaw(query.ToQueryString()+%2B+"+WHERE+["+%2B+columnDataBase+%2B+"]+LIKE+{0}",+text).ToListAsync(cancellationToken);

++++}

++++public+static+IQueryable<TEntity>+Like<TEntity,+TKey>(this+IQueryable<TEntity>+query,+Expression<Func<TEntity,+TKey>>+predicate,+string+text)+where+TEntity+:+class+{

++++++++DbSet<TEntity>+entities+=+query+as+DbSet<TEntity>;
++++++++string+columnDataBase+=+ColumnDataBase(entities.EntityType.Model,+predicate);
++++++++return+entities.FromSqlRaw(query.ToQueryString()+%2B+"+WHERE+["+%2B+columnDataBase+%2B+"]+LIKE+{0}",+text);

++++}

}|code-block|syntax|javascript|961041|存储库|961042|++++public+async+Task<IEnumerable<TEntity>>+LikeAsync<TKey>(Expression<Func<TEntity,+TKey>>+predicate,+string+text,+CancellationToken+cancellationToken)+{

++++++++return+await+context.LikeAsync(predicate,+text,+cancellationToken);

++++}

++++public+IQueryable<TEntity>+Like<TKey>(Expression<Func<TEntity,+TKey>>+predicate,+string+text)+{

++++++++return+context.Like(predicate,+text);

++++}|961043|使用|961044|+IQueryable<CountryEntity>+result+=+countryRepository
+++++.Like(k+=>+k.Name,+"%25Bra[sz]il%25")+/*Use+Sync*/
+++++.Where(w+=>+w.DateRegister+<+DateTime.Now)+/*Example*/
+++++.Take(10);+/*Example*/|961045|或|961046|+IEnumerable<CountryEntity>+result+=+await+countryRepository
+++++.LikeAsync(k+=>+k.Name,+"%25Bra[sz]il%25",+cancellationToken);+/*Use+Async*/|961047|961048|+IQueryable<CountryEntity>+result+=+context.Countries
+++++.Like(k+=>+k.Name,+"%25Bra[sz]il%25")
+++++.Where(w+=>+w.Name+!=+null);+/*Example*/|961049|961050|+List<CountryEntity>+result2+=+await+context.Countries
+++++.Like(k+=>+k.Name,+"%25Bra[sz]il%25")
+++++.Where(w+=>+w.Name+!=+null)+/*Example*/
+++++.ToListAsync();+/*Use+Async*/|961051|961052|+IEnumerable<CountryEntity>+result3+=+await+context.Countries
+++++.Where(w+=>+w.Name+!=+null)
+++++.LikeAsync(k+=>+k.Name,+"%25Bra[sz]il%25",+cancellationToken);+/*Use+Async*/|961053|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|19|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1A|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1B|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1C|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1D|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1E|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|1F|8|@]|9|@]|A|$]]|$1|U|3|V|5|H|7|1G|8|@]|9|@]|A|$I|J]]|$1|W|3|T|5|6|7|1H|8|@]|9|@]|A|$]]|$1|X|3|Y|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|Z|3|T|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1K|8|@]|9|@]|A|$I|J]]|$1|12|3|T|5|6|7|1L|8|@]|9|@]|A|$]]|$1|13|3|14|5|H|7|1M|8|@]|9|@]|A|$I|J]]|$1|15|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|16|$]]

<h1>Like Extension Linq / SQL</h1>
<h2>LikeExtension Class</h2>
Tested in .NET 5
<pre><code> public static class LikeExtension {

 private static string ColumnDataBase&lt;TEntity, TKey&gt;(IModel model, Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate) where TEntity : class {

 ITable table = model
 .GetRelationalModel()
 .Tables
 .First(f =&gt; f
 .EntityTypeMappings
 .First()
 .EntityType == model
 .FindEntityType(predicate
 .Parameters
 .First()
 .Type
 ));

 string column = (predicate.Body as MemberExpression).Member.Name;
 string columnDataBase = table.Columns.First(f =&gt; f.PropertyMappings.Count(f2 =&gt; f2.Property.Name == column) &gt; 0).Name;

 return columnDataBase;

 }

 public static IQueryable&lt;TEntity&gt; Like&lt;TEntity, TKey&gt;(this DbContext context, Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate, string text) where TEntity : class {

 string columnDataBase = ColumnDataBase(context.Model, predicate);
 return context.Set&lt;TEntity&gt;().FromSqlRaw(context.Set&lt;TEntity&gt;().ToQueryString() + &quot; WHERE [&quot; + columnDataBase + &quot;] LIKE {0}&quot;, text);

 }

 public static async Task&lt;IEnumerable&lt;TEntity&gt;&gt; LikeAsync&lt;TEntity, TKey&gt;(this DbContext context, Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate, string text, CancellationToken cancellationToken) where TEntity : class {

 string columnDataBase = ColumnDataBase(context.Model, predicate);
 return await context.Set&lt;TEntity&gt;().FromSqlRaw(context.Set&lt;TEntity&gt;().ToQueryString() + &quot; WHERE [&quot; + columnDataBase + &quot;] LIKE {0}&quot;, text).ToListAsync(cancellationToken);

 }

 public static async Task&lt;IEnumerable&lt;TEntity&gt;&gt; LikeAsync&lt;TEntity, TKey&gt;(this IQueryable&lt;TEntity&gt; query, Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate, string text, CancellationToken cancellationToken) where TEntity : class {

 DbSet&lt;TEntity&gt; entities = query as DbSet&lt;TEntity&gt;;
 string columnDataBase = ColumnDataBase(entities.EntityType.Model, predicate);
 return await entities.FromSqlRaw(query.ToQueryString() + &quot; WHERE [&quot; + columnDataBase + &quot;] LIKE {0}&quot;, text).ToListAsync(cancellationToken);

 }

 public static IQueryable&lt;TEntity&gt; Like&lt;TEntity, TKey&gt;(this IQueryable&lt;TEntity&gt; query, Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate, string text) where TEntity : class {

 DbSet&lt;TEntity&gt; entities = query as DbSet&lt;TEntity&gt;;
 string columnDataBase = ColumnDataBase(entities.EntityType.Model, predicate);
 return entities.FromSqlRaw(query.ToQueryString() + &quot; WHERE [&quot; + columnDataBase + &quot;] LIKE {0}&quot;, text);

 }

}
</code></pre>
<h2>Repository</h2>
<pre><code> public async Task&lt;IEnumerable&lt;TEntity&gt;&gt; LikeAsync&lt;TKey&gt;(Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate, string text, CancellationToken cancellationToken) {

 return await context.LikeAsync(predicate, text, cancellationToken);

 }

 public IQueryable&lt;TEntity&gt; Like&lt;TKey&gt;(Expression&lt;Func&lt;TEntity, TKey&gt;&gt; predicate, string text) {

 return context.Like(predicate, text);

 }
</code></pre>
<h2>Use</h2>
<pre><code> IQueryable&lt;CountryEntity&gt; result = countryRepository
 .Like(k =&gt; k.Name, &quot;%Bra[sz]il%&quot;) /*Use Sync*/
 .Where(w =&gt; w.DateRegister &lt; DateTime.Now) /*Example*/
 .Take(10); /*Example*/
</code></pre>
Or
<pre><code> IEnumerable&lt;CountryEntity&gt; result = await countryRepository
 .LikeAsync(k =&gt; k.Name, &quot;%Bra[sz]il%&quot;, cancellationToken); /*Use Async*/
</code></pre>
Or
<pre><code> IQueryable&lt;CountryEntity&gt; result = context.Countries
 .Like(k =&gt; k.Name, &quot;%Bra[sz]il%&quot;)
 .Where(w =&gt; w.Name != null); /*Example*/
</code></pre>
Or
<pre><code> List&lt;CountryEntity&gt; result2 = await context.Countries
 .Like(k =&gt; k.Name, &quot;%Bra[sz]il%&quot;)
 .Where(w =&gt; w.Name != null) /*Example*/
 .ToListAsync(); /*Use Async*/
</code></pre>
Or
<pre><code> IEnumerable&lt;CountryEntity&gt; result3 = await context.Countries
 .Where(w =&gt; w.Name != null)
 .LikeAsync(k =&gt; k.Name, &quot;%Bra[sz]il%&quot;, cancellationToken); /*Use Async*/
</code></pre>

blocks|key|961082|text|您还可以使用在.net5中测试过的EF函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|961083|public+async+Task<IEnumerable<District>>+SearchDistrict(string+query,+int+stateId)
++++++++{
++++++++++++return+await+_dbContext
++++++++++++++++.Districts
++++++++++++++++.Include(s+=>+s.State)
++++++++++++++++.Where(s+=>+s.StateId+==+stateId+&&+EF.Functions.Like(s.Name,+"$%25{query}%25"))
++++++++++++++++.AsNoTracking()
++++++++++++++++.ToListAsync();
++++++++}|code-block|syntax|javascript|961084|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also use the EF function tested in .net5
<pre><code>public async Task&lt;IEnumerable&lt;District&gt;&gt; SearchDistrict(string query, int stateId)
 {
 return await _dbContext
 .Districts
 .Include(s =&gt; s.State)
 .Where(s =&gt; s.StateId == stateId &amp;&amp; EF.Functions.Like(s.Name, &quot;$%{query}%&quot;))
 .AsNoTracking()
 .ToListAsync();
 }
</code></pre>

Is there any way to compare strings in a C# LINQ expression similar to SQL's <code>LIKE</code> operator?

Suppose I have a string list. On this list I want to search a string. In SQL, I could write:

<pre><code>SELECT * FROM DischargePort WHERE PortName LIKE '%BALTIMORE%'
</code></pre>

Instead of the above, query want a linq syntax.

<pre><code>using System.Text.RegularExpressions;
…

var regex = new Regex(sDischargePort, RegexOptions.IgnoreCase);
var sPortCode = Database.DischargePorts
 .Where(p =&gt; regex.IsMatch(p.PortName))
 .Single().PortCode;
</code></pre>

My above LINQ syntax does not work. What have I got wrong?

LIKE operator in LINQ

有没有办法比较SQL表达式中的字符串，类似于C#的LIKE运算符？假设我有一个字符串列表。在这个列表中，我想搜索一个字符串。在SQL中，我可以这样写：SELECT * FROM DischargePort WHERE PortName LIKE '%BALTIMORE%'与以上不同，查询需要一种linq语法。using...

问LINQ中的LIKE运算符
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问LINQ中的LIKE运算符EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问LINQ中的LIKE运算符
EN