Comme opérateur dans Entity Framework?

Nous essayons d'implémenter l'opérateur "LIKE" dans Entity Framework pour nos entités avec des champs de chaîne, mais il ne semble pas être pris en charge. Quelqu'un d'autre a-t-il essayé de faire quelque chose comme ça?

Cet article de blog résume le problème que nous rencontrons. Nous pourrions utiliser contient, mais cela ne correspond qu'au cas le plus trivial de LIKE. Combiner contient, commence par, se termine par et indexof nous y conduit, mais nécessite une traduction entre les caractères génériques standard et le code Linq en entités.

Ceci est un ancien article maintenant, mais pour quiconque cherche la réponse, ce lien devrait aider. Accédez à cette réponse si vous utilisez déjà EF 6.2.x. À cette réponse si vous utilisez EF Core 2.x

Version courte:

Méthode SqlFunctions.PatIndex - renvoie la position de départ de la première occurrence d'un modèle dans une expression spécifiée, ou des zéros si le modèle n'est pas trouvé, sur tous les types de données texte et caractère valides

Espace de noms: System.Data.Objects.SqlClient Assembly: System.Data.Entity (dans System.Data.Entity.dll)

Une petite explication apparaît également dans ce fil de discussion .

Je ne sais vraiment rien sur EF, mais dans LINQ to SQL, vous exprimez généralement une clause LIKE en utilisant String.

where entity.Name.Contains("xyz")

Se traduit par

WHERE Name LIKE '%xyz%'

(Utilisez StartsWithet EndsWithpour un autre comportement.)

Je ne suis pas tout à fait sûr que cela soit utile, car je ne comprends pas ce que vous voulez dire quand vous dites que vous essayez d' implémenter LIKE. Si j'ai complètement mal compris, faites-le moi savoir et je supprimerai cette réponse :)

J'ai eu le même problème.

Pour l'instant, j'ai opté pour le filtrage Wildcard / Regex côté client basé sur http://www.codeproject.com/Articles/11556/Converting-Wildcards-to-Regexes?msg=1423024#xx1423024xx - c'est simple et fonctionne comme attendu.

J'ai trouvé une autre discussion sur ce sujet: http://forums.asp.net/t/1654093.aspx/2/10
Cet article semble prometteur si vous utilisez Entity Framework> = 4.0:

Utilisez SqlFunctions.PatIndex:

http://msdn.microsoft.com/en-us/library/system.data.objects.sqlclient.sqlfunctions.patindex.aspx

Comme ça:

var q = EFContext.Products.Where(x =>
SqlFunctions.PatIndex("%CD%BLUE%", x.ProductName) > 0);

Remarque: cette solution est réservée à SQL-Server, car elle utilise la fonction PATINDEX non standard.

Mise à jour: dans EF 6.2, il existe un opérateur similaire

Where(obj => DbFunctions.Like(obj.Column , "%expression%")

Un LIKEopérateur est ajouté dans Entity Framework Core 2.0:

var query = from e in _context.Employees
                    where EF.Functions.Like(e.Title, "%developer%")
                    select e;

Comparé à ... where e.Title.Contains("developer") ...cela, il est vraiment traduit SQL LIKEplutôt que CHARINDEXnous ne voyons la Containsméthode.

Il est spécifiquement mentionné dans la documentation dans le cadre d'Entity SQL. Recevez-vous un message d'erreur?

// LIKE and ESCAPE
// If an AdventureWorksEntities.Product contained a Name 
// with the value 'Down_Tube', the following query would find that 
// value.
Select value P.Name FROM AdventureWorksEntities.Product 
    as P where P.Name LIKE 'DownA_%' ESCAPE 'A'

// LIKE
Select value P.Name FROM AdventureWorksEntities.Product 
    as P where P.Name like 'BB%'

http://msdn.microsoft.com/en-us/library/bb399359.aspx

si vous utilisez MS Sql, j'ai écrit 2 méthodes d'extension pour prendre en charge le caractère% pour la recherche générique. (LinqKit est requis)

public static class ExpressionExtension
{
    public static Expression<Func<T, bool>> Like<T>(Expression<Func<T, string>> expr, string likeValue)
    {
        var paramExpr = expr.Parameters.First();
        var memExpr = expr.Body;

        if (likeValue == null || likeValue.Contains('%') != true)
        {
            Expression<Func<string>> valExpr = () => likeValue;
            var eqExpr = Expression.Equal(memExpr, valExpr.Body);
            return Expression.Lambda<Func<T, bool>>(eqExpr, paramExpr);
        }

        if (likeValue.Replace("%", string.Empty).Length == 0)
        {
            return PredicateBuilder.True<T>();
        }

        likeValue = Regex.Replace(likeValue, "%+", "%");

        if (likeValue.Length > 2 && likeValue.Substring(1, likeValue.Length - 2).Contains('%'))
        {
            likeValue = likeValue.Replace("[", "[[]").Replace("_", "[_]");
            Expression<Func<string>> valExpr = () => likeValue;
            var patExpr = Expression.Call(typeof(SqlFunctions).GetMethod("PatIndex",
                new[] { typeof(string), typeof(string) }), valExpr.Body, memExpr);
            var neExpr = Expression.NotEqual(patExpr, Expression.Convert(Expression.Constant(0), typeof(int?)));
            return Expression.Lambda<Func<T, bool>>(neExpr, paramExpr);
        }

        if (likeValue.StartsWith("%"))
        {
            if (likeValue.EndsWith("%") == true)
            {
                likeValue = likeValue.Substring(1, likeValue.Length - 2);
                Expression<Func<string>> valExpr = () => likeValue;
                var containsExpr = Expression.Call(memExpr, typeof(String).GetMethod("Contains",
                    new[] { typeof(string) }), valExpr.Body);
                return Expression.Lambda<Func<T, bool>>(containsExpr, paramExpr);
            }
            else
            {
                likeValue = likeValue.Substring(1);
                Expression<Func<string>> valExpr = () => likeValue;
                var endsExpr = Expression.Call(memExpr, typeof(String).GetMethod("EndsWith",
                    new[] { typeof(string) }), valExpr.Body);
                return Expression.Lambda<Func<T, bool>>(endsExpr, paramExpr);
            }
        }
        else
        {
            likeValue = likeValue.Remove(likeValue.Length - 1);
            Expression<Func<string>> valExpr = () => likeValue;
            var startsExpr = Expression.Call(memExpr, typeof(String).GetMethod("StartsWith",
                new[] { typeof(string) }), valExpr.Body);
            return Expression.Lambda<Func<T, bool>>(startsExpr, paramExpr);
        }
    }

    public static Expression<Func<T, bool>> AndLike<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, string>> expr, string likeValue)
    {
        var andPredicate = Like(expr, likeValue);
        if (andPredicate != null)
        {
            predicate = predicate.And(andPredicate.Expand());
        }
        return predicate;
    }

    public static Expression<Func<T, bool>> OrLike<T>(this Expression<Func<T, bool>> predicate, Expression<Func<T, string>> expr, string likeValue)
    {
        var orPredicate = Like(expr, likeValue);
        if (orPredicate != null)
        {
            predicate = predicate.Or(orPredicate.Expand());
        }
        return predicate;
    }
}

usage

var orPredicate = PredicateBuilder.False<People>();
orPredicate = orPredicate.OrLike(per => per.Name, "He%llo%");
orPredicate = orPredicate.OrLike(per => per.Name, "%Hi%");

var predicate = PredicateBuilder.True<People>();
predicate = predicate.And(orPredicate.Expand());
predicate = predicate.AndLike(per => per.Status, "%Active");

var list = dbContext.Set<People>().Where(predicate.Expand()).ToList();    

dans ef6 et cela devrait se traduire par

....
from People per
where (
    patindex(@p__linq__0, per.Name) <> 0
    or per.Name like @p__linq__1 escape '~'
) and per.Status like @p__linq__2 escape '~'

', @ p__linq__0 ='% He% llo% ', @ p__linq__1 ='% Salut% ', @ p__linq_2 ='% Active '

Pour EfCore, voici un exemple pour construire une expression LIKE

protected override Expression<Func<YourEntiry, bool>> BuildLikeExpression(string searchText)
    {
        var likeSearch = $"%{searchText}%";

        return t => EF.Functions.Like(t.Code, likeSearch)
                    || EF.Functions.Like(t.FirstName, likeSearch)
                    || EF.Functions.Like(t.LastName, likeSearch);
    }

//Calling method

var query = dbContext.Set<YourEntity>().Where(BuildLikeExpression("Text"));

Vous pouvez utiliser un réel comme dans Link to Entities assez facilement

Ajouter

    <Function Name="String_Like" ReturnType="Edm.Boolean">
      <Parameter Name="searchingIn" Type="Edm.String" />
      <Parameter Name="lookingFor" Type="Edm.String" />
      <DefiningExpression>
        searchingIn LIKE lookingFor
      </DefiningExpression>
    </Function>

à votre EDMX dans cette balise:

edmx: Edmx / edmx: Runtime / edmx: ConceptualModels / Schema

Souvenez-vous également de l'espace de noms dans l' <schema namespace="" />attribut

Ajoutez ensuite une classe d'extension dans l'espace de noms ci-dessus:

public static class Extensions
{
    [EdmFunction("DocTrails3.Net.Database.Models", "String_Like")]
    public static Boolean Like(this String searchingIn, String lookingFor)
    {
        throw new Exception("Not implemented");
    }
}

Cette méthode d'extension sera désormais mappée à la fonction EDMX.

Plus d'infos ici: http://jendaperl.blogspot.be/2011/02/like-in-linq-to-entities.html