LINQ में LIKE ऑपरेटर

Question 1

एसक्यूएल के LIKEऑपरेटर के समान C # LINQ अभिव्यक्ति में तार की तुलना करने का कोई तरीका है ?

मान लीजिए कि मेरे पास एक स्ट्रिंग सूची है। इस सूची में मैं एक स्ट्रिंग खोजना चाहता हूं। SQL में, मैं लिख सकता था:

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

उपरोक्त के बजाय, क्वेरी एक लाइन सिंटैक्स चाहती है।

using System.Text.RegularExpressions;
…

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

मेरे ऊपर LINQ सिंटैक्स काम नहीं करता है। मैंने क्या गलत किया है?

Question 2

आमतौर पर आप String.StartsWith/ EndsWith/ का उपयोग करते हैं Contains। उदाहरण के लिए:

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

मुझे नहीं पता कि वहाँ LINQ के माध्यम से SQL के लिए उचित नियमित अभिव्यक्ति करने का एक तरीका है। (ध्यान दें कि यह वास्तव में इस बात पर निर्भर करता है कि आप किस प्रदाता का उपयोग कर रहे हैं - यह LINQ में ऑब्जेक्ट्स के लिए ठीक होगा; यह बात है कि क्या प्रदाता कॉल को अपने मूल क्वेरी प्रारूप, जैसे SQL में परिवर्तित कर सकता है।)

EDIT: जैसा कि BitKFu कहता है, Singleका उपयोग तब किया जाना चाहिए जब आप बिल्कुल एक परिणाम की उम्मीद करते हैं - जब यह एक त्रुटि है कि ऐसा न हो। के विकल्प SingleOrDefault, FirstOrDefaultया Firstके आधार पर इस्तेमाल किया जाना चाहिए वास्तव में क्या उम्मीद है।

Question 3

Regex? नहीं। लेकिन उस क्वेरी के लिए आप बस उपयोग कर सकते हैं:

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

यदि आप वास्तव में SQL चाहते हैं LIKE, तो आप SQL Server में System.Data.Linq.SqlClient.SqlMethods.Like(...)LINQ-to-SQL मैप्स का उपयोग कर सकते हैं LIKE।

Question 4

खैर ... कभी-कभी यह उपयोग करने के लिए असुविधाजनक हो सकता है Contains, StartsWithया EndsWithविशेष रूप से जब मूल्य निर्धारित करने के लिए खोज निर्धारित किया जाता है LIKEजैसे कि 'मान%' को डेवलपर से StartsWithअभिव्यक्ति में फ़ंक्शन का उपयोग करने की आवश्यकता होती है । इसलिए मैंने 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;
    }
}

Question 5

जैसा कि जॉन स्कीट और मार्क ग्रेवेल ने पहले ही उल्लेख किया है, आप एक शर्त को सरल रूप से ले सकते हैं। लेकिन आपके प्रश्न की तरह, सिंगल () स्टेटमेंट लेना बहुत खतरनाक है, क्योंकि इसका मतलब है कि आपको केवल 1 परिणाम मिलेगा। अधिक परिणामों के मामले में, आपको एक अच्छा अपवाद प्राप्त होगा :)

इसलिए मैं Single () के बजाय FirstOrDefault () का उपयोग करना पसंद करूंगा:

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

Question 6

मूल 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 में)।

Question 7

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

यह SQL के "LIKE" की तरह काम करता है ...

Question 8

इस के रूप में एक सरल

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

परिणाम -> एनिक, यानिक

Question 9

आप एक विधेय के साथ एकल विधि कह सकते हैं:

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

Question 10

आदर्श रूप से आपको उपयोग करना चाहिए StartWithया EndWith।

यहाँ एक उदाहरण है:

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

return lstPerson;

Question 11

   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;

Question 12

बस स्ट्रिंग ऑब्जेक्ट एक्सटेंशन विधियों में जोड़ें।

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;

Question 13

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

Question 14

@adobrzyc का यह शानदार कस्टम LIKEफंक्शन था - मैं सिर्फ इसका IEnumerableसंस्करण साझा करना चाहता था ।

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("%");
        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).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;
    }
}