LIKE-Operator in LINQ

Gibt es eine Möglichkeit, Zeichenfolgen in einem C # LINQ-Ausdruck zu vergleichen, der dem SQL- LIKEOperator ähnelt ?

Angenommen, ich habe eine Zeichenfolgenliste. Auf dieser Liste möchte ich eine Zeichenfolge suchen. In SQL könnte ich schreiben:

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

Anstelle der oben genannten Abfrage möchte eine Linq-Syntax.

using System.Text.RegularExpressions;
…

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

Meine obige LINQ-Syntax funktioniert nicht. Was habe ich falsch gemacht?

Normalerweise verwenden Sie String.StartsWith/ EndsWith/ Contains. Beispielsweise:

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

Ich weiß nicht, ob es eine Möglichkeit gibt, korrekte reguläre Ausdrücke über LINQ to SQL zu erstellen. (Beachten Sie, dass es wirklich davon abhängt, welchen Anbieter Sie verwenden. In LINQ to Objects ist dies in Ordnung. Es kommt darauf an, ob der Anbieter den Aufruf in sein natives Abfrageformat konvertieren kann, z. B. SQL.)

BEARBEITEN: Wie BitKFu sagt, Singlesollte verwendet werden, wenn Sie genau ein Ergebnis erwarten - wenn es ein Fehler ist, dass dies nicht der Fall ist. Optionen SingleOrDefault, FirstOrDefaultoder Firstsollten je nach verwendet werden , genau , was erwartet wird .

Regex? Nein. Aber für diese Abfrage können Sie einfach verwenden:

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

Wenn Sie wirklich SQL möchten LIKE, können Sie das verwenden System.Data.Linq.SqlClient.SqlMethods.Like(...), dem LINQ-to-SQL LIKEin SQL Server zugeordnet ist.

Nun ... manchmal kann es unangenehm sein, die Funktion zu verwenden Contains, StartsWithoder EndsWithinsbesondere, wenn der LIKESuchwert die Aussage bestimmt, z. B. die vom Entwickler übergebene 'Wert%', um die StartsWithFunktion im Ausdruck zu verwenden. Also habe ich beschlossen, eine Erweiterung für IQueryableObjekte zu schreiben .

Verwendung

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

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

Wie Jon Skeet und Marc Gravell bereits erwähnt haben, können Sie einfach eine Contain-Bedingung annehmen. Bei einer ähnlichen Abfrage ist es jedoch sehr gefährlich, eine Single () - Anweisung zu verwenden, da dies bedeutet, dass Sie nur 1 Ergebnis finden. Bei weiteren Ergebnissen erhalten Sie eine nette Ausnahme :)

Daher würde ich lieber FirstOrDefault () anstelle von Single () verwenden:

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

In nativem LINQ können Sie eine Kombination aus Contains/StartsWith/EndsWithoder RegExp verwenden.

Verwenden Sie in LINQ2SQL die Methode SqlMethods.Like()

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

Fügen Sie Assembly: System.Data.Linq (in System.Data.Linq.dll) hinzu, um diese Funktion zu verwenden.

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

Dies funktioniert wie "LIKE" von SQL ...

So einfach ist das

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

Ergebnis -> Annick, Yannick

Sie können die einzelne Methode mit einem Prädikat aufrufen:

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

Idealerweise sollten Sie StartWithoder verwenden EndWith.

Hier ist ein Beispiel:

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;

Fügen Sie einfach Methoden zur Erweiterung von Zeichenfolgenobjekten hinzu.

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

Verwendung:

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