web-dev-qa-db-ja.com

LINQのLIKE演算子

SQLのLIKE演算子に似たC＃LINQ式の文字列を比較する方法はありますか？

文字列リストがあるとします。このリストで、文字列を検索します。 SQLでは、次のように書くことができます。

SELECT * FROM DischargePort WHERE PortName LIKE '%BALTIMORE%'

上記の代わりに、クエリにはlinq構文が必要です。

using System.Text.RegularExpressions;
…

var regex = new Regex(sDischargePort, RegexOptions.IgnoreCase);
var sPortCode = Database.DischargePorts
                .Where(p => regex.IsMatch(p.PortName))
                .Single().PortCode;

上記のLINQ構文は機能しません。何が間違っていますか？

c#linqsql-like
82
shamim

通常、String.StartsWith/EndsWith/Containsを使用します。例えば：

var portCode = Database.DischargePorts
                       .Where(p => p.PortName.Contains("BALTIMORE"))
                       .Single()
                       .PortCode;

しかし、LINQ to SQLを介して適切な正規表現を実行する方法があるかどうかはわかりません。 （実際に使用しているプロバイダーに依存することに注意してください-LINQ to Objectsでは問題ありません;プロバイダーが呼び出しをネイティブクエリ形式（SQLなど）に変換できるかどうかの問題です。）

編集：BitKFuが言うように、Singleはあなたが期待するときに使用する必要があります正確に1結果-それはそうではないためのエラーの場合。 SingleOrDefault、FirstOrDefault、またはFirstのオプションは、exactlyに応じて使用する必要があります。

130
Jon Skeet

正規表現？番号。しかし、そのクエリに対してだけを使用できます：

 string filter = "BALTIMORE";
 (blah) .Where(row => row.PortName.Contains(filter)) (blah)

reallySQL LIKEが必要な場合は、 System.Data.Linq.SqlClient.SqlMethods.Like(...)を使用できます。 。これは、LINQ-to-SQLがSQL ServerのLIKEにマップします。

30
Marc Gravell

まあ...時々、Contains、StartsWith、EndsWith、LIKEを使用するのは不快かもしれません。式でStartsWith関数を使用するために開発者から 'value％'が必要です。そこで、IQueryableオブジェクトの拡張機能を作成することにしました。

使用法

// numbers: 11-000-00, 00-111-00, 00-000-11

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

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

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

コード

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("%");
        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 && 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;
    }
}
10
adobrzyc

Jon SkeetとMarc Gravellがすでに述べたように、contains条件を簡単に取得できます。しかし、likeクエリの場合、Single（）ステートメントを取得することは非常に危険です。これは、結果が1つしか見つからないことを意味するためです。より多くの結果の場合、あなたはニースの例外を受け取ります:)

したがって、Single（）ではなくFirstOrDefault（）を使用することをお勧めします。

var first = Database.DischargePorts.FirstOrDefault(p => p.PortName.Contains("BALTIMORE"));
var portcode = first != null ? first.PortCode : string.Empty;
8
BitKFu

ネイティブLINQでは、Contains/StartsWith/EndsWithまたはRegExpの組み合わせを使用できます。

LINQ2SQLでは、メソッドSqlMethods.Like()を使用します

    from i in db.myTable
    where SqlMethods.Like(i.field, "tra%ata")
    select i

この機能を使用するには、アセンブリ：System.Data.Linq（System.Data.Linq.dll内）を追加します。

7
Marat Batalandabad

このようにシンプル

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

結果->アニック、ヤニック

3
Yannick Turbang

述語を使用して単一のメソッドを呼び出すことができます。

var portCode = Database.DischargePorts
                   .Single(p => p.PortName.Contains("BALTIMORE"))
                   .PortCode;
2
Zebi

理想的には、StartWithまたはEndWithを使用する必要があります。

以下に例を示します。

DataContext  dc = new DCGeneral();
List<Person> lstPerson= dc.GetTable<Person>().StartWith(c=> c.strNombre).ToList();

return lstPerson;
2
Eduardo Romero Marin
  .Where(e => e.Value.StartsWith("BALTIMORE"))

これはSQLの「いいね」のように機能します...

2
user1930698
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();
0
Eber Camacho

SQL LIKE演算子を模倣するソリューションを見つけました。私がここに書いた答えを参照してください https://stackoverflow.com/a/46592475/118607

0
Hugo
   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;
0
NoBrend s

文字列オブジェクト拡張メソッドに追加するだけです。

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;
    }
}

使用法：

use namespase that contains this class;

var sPortCode = Database.DischargePorts
            .Where(p => p.PortName.Contains(new string [] {"BALTIMORE"},  StringComparison.CurrentCultureIgnoreCase) )
            .Single().PortCode;
0
NoBrend s