Linq SqlMethods.Comme échoue

Je suis en suivant les conseils ici, en essayant de tirer parti de la déclaration que le sql ne pas créées jusqu'à ce que l'agent recenseur est déclenché. Cependant j'obtiens l'erreur suivante sur le code ci-dessous. Je suis en utilisant Linq2Entities, pas linq2sql. Est-il un moyen de le faire dans Linq2entities?

Méthode Booléenne Comme(Système D'.Chaîne, Système.String)' ne peut pas être utilisé sur le client; c'est seulement pour la traduction en SQL.

            query = db.MyTables.Where(x => astringvar.Contains(x.Field1));

            if (!String.IsNullOrEmpty(typeFilter))
            {
                if (typeFilter.Contains('*'))
                {
                    typeFilter = typeFilter.Replace('*', '%');
                    query = query.Where(x=> SqlMethods.Like(x.Type, typeFilter));
                }
                else
                {
                    query  = query.Where(x => x.Type == typeFilter);
                }
            }

Notes: db est une entité de la cartographie à un serveur sql server.

OriginalL'auteur Russell Steen | 2010-04-06

.net linq-to-entities

Je ne sais pas comment vous pouvez faire Entity Framework utiliser le "réel" COMME opérateur, mais une solution possible serait d'exprimer une expression en termes de StartsWith, Contains et EndsWith

Par exemple :

LIKE 'a%' => StartsWith("a")
LIKE '%a' => EndsWith("a")
LIKE '%a%' => Contains("a")
LIKE 'a%b' => StartsWith("a") && EndsWith("b")
LIKE 'a%b%' => StartsWith("a") && Contains("b")

Et ainsi de suite...

Noter qu'il n'est pas exactement équivalent à l'utilisation de LIKE en SQL : par exemple LIKE '%abc%bcd%' entraînerait Contains("abc") && Contains("bcd"). Cela pourrait correspondre à "abcd", même si l'original COMME condition ne serait pas. Mais pour la plupart des cas, il devrait être assez bon.

Voici un exemple de mise en œuvre, à l'aide de PredicateBuilder et LinqKit pour construire des expressions basées sur un motif LIKE :

public static class ExpressionHelper
{
    public static Expression<Func<T, bool>> StringLike<T>(Expression<Func<T, string>> selector, string pattern)
    {
        var predicate = PredicateBuilder.True<T>();
        var parts = pattern.Split('%');
        if (parts.Length == 1) //not '%' sign
        {
            predicate = predicate.And(s => selector.Compile()(s) == pattern);
        }
        else
        {
            for (int i = 0; i < parts.Length; i++)
            {
                string p = parts[i];
                if (p.Length > 0)
                {
                    if (i == 0)
                    {
                        predicate = predicate.And(s => selector.Compile()(s).StartsWith(p));
                    }
                    else if (i == parts.Length - 1)
                    {
                        predicate = predicate.And(s => selector.Compile()(s).EndsWith(p));
                    }
                    else
                    {
                        predicate = predicate.And(s => selector.Compile()(s).Contains(p));
                    }
                }
            }
        }
        return predicate;
    }
}

Et voici comment vous pouvez l'utiliser :

var expr = ExpressionHelper.StringLike<YourClass>(x => x.Type, typeFilter);
query = query.AsExpandable().Where(expr.Compile());

Je l'ai juste essayé avec un simple modèle EF, et il semble bien fonctionner 🙂

malheureusement, j'ai besoin réel "COMME", mais c'est une solution intéressante.
Approche intéressante, bien que LIKE '%a%b%' => StartsWith("a") && Contains("b") est pas vrai, comme vous en avez un pour cent de trop au début. LIKE 'a%b%' est mieux.

OriginalL'auteur Thomas Levesque

4

Vous pourriez faire ESQL et faire quelque chose comme ci-dessous..
```
     db.MyTables.Where("it.Type like '" + typeFilter + "'").ToList();
```
Ce ne compile pas sur la mienne (même en ajoutant le manque +). Je suis dans vs2008, .net 3.5 sp1
Passons sur le fait, il doit aller spécifiquement directement à la table, pas un plus tard ienumerable. Merci.
Maintenant, il se fait "FieldName" ne peut pas être résolu dans le champ d'application actuel ou le contexte.
Code postal de l'échantillon et je peux vous aider, mais il fonctionne.

OriginalL'auteur Nix
4

La SqlMethods de la classe est destiné à être utilisé avec LINQ-to-SQL. Lorsque vous utilisez des méthodes d'elle (la documentation publique vous dit de ne pas le faire, ce n'est pas pour la consommation publique), le IQueryable fournisseur LINQ-to-Entités ne sais pas quoi faire ou comment le traduire.

Si vous aviez un caractère générique au début ou à la fin du filtre, vous pouvez utiliser StartsWith ou EndsWith méthodes sur la String classe, et LINQ-to-Entités de soutien.

Toutefois, dans ce cas, vous disposez d'un nombre variable de caractères génériques, de sorte que vous aurez à tomber à la ESQL niveau et de construire une requête à partir de la que, comme indiqué dans Nix réponse.

OriginalL'auteur casperOne

Vous pouvez utiliser un de réel, comme dans le Lien à des Entités

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:le temps d'Exécution/edmx:ConceptualModels/Schéma

Souviens aussi de l'espace de noms dans le <schema namespace="" /> attribut

Puis ajouter une extension de la classe au-dessus de l'espace de noms:

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 la carte de l'EDMX fonction.

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

OriginalL'auteur brechtvhb

Vous devez vous connecter pour publier un commentaire.