Toán tử LIKE trong LINQ

Có cách nào để so sánh các chuỗi trong biểu thức C # LINQ tương tự như LIKEtoán tử SQL không?

Giả sử tôi có một danh sách chuỗi. Trong danh sách này, tôi muốn tìm kiếm một chuỗi. Trong SQL, tôi có thể viết:

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

Thay vì ở trên, truy vấn muốn có cú pháp linq.

using System.Text.RegularExpressions;
…

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

Cú pháp LINQ ở trên của tôi không hoạt động. Tôi có gì sai?

Thông thường bạn sử dụng String.StartsWith/ EndsWith/ Contains. Ví dụ:

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

Tuy nhiên, tôi không biết liệu có cách nào để thực hiện các biểu thức chính quy thích hợp thông qua LINQ to SQL hay không. (Lưu ý rằng nó thực sự phụ thuộc vào nhà cung cấp bạn đang sử dụng - nó sẽ ổn trong LINQ thành Đối tượng; vấn đề là liệu nhà cung cấp có thể chuyển đổi cuộc gọi thành định dạng truy vấn gốc của nó, ví dụ: SQL.)

CHỈNH SỬA: Như BitKFu đã nói, Singlenên được sử dụng khi bạn mong đợi chính xác một kết quả - khi đó không phải là lỗi. Tùy chọn SingleOrDefault, FirstOrDefaulthoặc Firstnên được sử dụng tùy thuộc vào chính xác những gì được mong đợi.

Regex? Không. Nhưng đối với truy vấn đó, bạn chỉ có thể sử dụng:

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

Nếu bạn thực sự muốn SQL LIKE, bạn có thể sử dụng System.Data.Linq.SqlClient.SqlMethods.Like(...)LINQ-to-SQL ánh xạ tới LIKEtrong SQL Server.

Chà ... đôi khi có thể không thoải mái khi sử dụng Contains, StartsWithhoặc EndsWithđặc biệt là khi tìm kiếm giá trị xác định trạng thái, LIKEví dụ như 'giá trị%' đã chuyển yêu cầu từ nhà phát triển để sử dụng StartsWithhàm trong biểu thức. Vì vậy, tôi quyết định viết phần mở rộng cho IQueryablecác đối tượng.

Sử dụng

// 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

Mã

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

Như Jon Skeet và Marc Gravell đã đề cập, bạn có thể đơn giản lấy điều kiện chứa. Nhưng trong trường hợp truy vấn like của bạn, sẽ rất nguy hiểm nếu sử dụng câu lệnh Single (), vì điều đó ngụ ý rằng bạn chỉ tìm thấy 1 kết quả. Trong trường hợp có nhiều kết quả hơn, bạn sẽ nhận được một ngoại lệ tuyệt vời :)

Vì vậy, tôi muốn sử dụng FirstOrDefault () thay vì Single ():

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

Trong LINQ gốc, bạn có thể sử dụng kết hợp của Contains/StartsWith/EndsWithhoặc RegExp.

Trong LINQ2SQL sử dụng phương pháp SqlMethods.Like()

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

thêm Assembly: System.Data.Linq (trong System.Data.Linq.dll) để sử dụng tính năng này.

  .Where(e => e.Value.StartsWith("BALTIMORE"))

Điều này hoạt động giống như "LIKE" của SQL ...

Đơn giản như thế này

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

Kết quả -> Annick, Yannick

Bạn có thể gọi phương thức đơn với một vị từ:

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

Tốt nhất bạn nên sử dụng StartWithhoặc EndWith.

Đây là một ví dụ:

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

return lstPerson;

   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;

Chỉ cần thêm vào các phương thức mở rộng đối tượng chuỗi.

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

sử dụng:

use namespase that contains this class;

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

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();