Die groß / Kleinschreibung bei string-vergleichen im LINQ-Ausdruck

Ich versuche zu schreiben ein ExpressionVisitor zu wickeln um meine LINQ-zu-Objekt-Ausdrücke automatisch in Ihre string-Vergleiche mit groß-und Kleinschreibung, so wie Sie in LINQ-to-entities.

EDIT: ich möchte auf jeden Fall verwenden Sie eine ExpressionVisitor anstatt einfach anwenden einige benutzerdefinierte Erweiterung oder etwas zum Ausdruck, wenn es erzeugt wird, für einen wichtigen Grund: Der Ausdruck wird weitergeleitet, um meine ExpressionVisitor erzeugt wird, durch den ASP.Net Web-API ODATA-Schicht, so dass ich keine Kontrolle darüber, wie es generiert wird (d.h. ich kann nicht Kleinbuchstaben der Zeichenkette des gesuchten mit Ausnahme von in dieser ExpressionVisitor).

Unterstützen LINQ to Entities. Nicht nur die Erweiterung.

Hier ist, was ich habe, so weit. Es sieht für einen Aufruf von "Enthält" auf einen string um und ruft dann ToLower auf jedes Mitglied Zugang in den Ausdruck.

Aber es funktioniert nicht. Wenn ich die Ausdrücke anzuzeigen, nach meinen änderungen, sieht es korrekt zu mir, so bin ich nicht sicher, was ich tun könnte falsch.

public class CaseInsensitiveExpressionVisitor : ExpressionVisitor
{

    protected override Expression VisitMember(MemberExpression node)
    {
        if (insideContains)
        {
            if (node.Type == typeof (String))
            {
                var methodInfo = typeof (String).GetMethod("ToLower", new Type[] {});
                var expression = Expression.Call(node, methodInfo);
                return expression;
            }
        }
        return base.VisitMember(node);
    }

    private Boolean insideContains = false;
    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        if (node.Method.Name == "Contains")
        {
            if (insideContains) throw new NotSupportedException();
            insideContains = true;
            var result = base.VisitMethodCall(node);
            insideContains = false;
            return result;
        }
        return base.VisitMethodCall(node);
    }

Wenn ich einen Haltepunkt auf der "return Ausdruck" Zeile in der VisitMember Methode und dann die "ToString" auf die "Knoten" und "Ausdruck" - Variablen, die Pause wird zweimal getroffen, und hier ist, was die beiden Werte sind:

Erste Treffer:

node.ToString()
"$it.LastName"
expression.ToString()
"$it.LastName.ToLower()"

Zweiten Treffer:

node.ToString()
"value(System.Web.Http.OData.Query.Expressions.LinqParameterContainer+TypedLinqParameterContainer`1[System.String]).TypedProperty"
expression.ToString()
"value(System.Web.Http.OData.Query.Expressions.LinqParameterContainer+TypedLinqParameterContainer`1[System.String]).TypedProperty.ToLower()"

Ich weiß nicht genug über Ausdrücke, um herauszufinden, was ich falsch mache an dieser Stelle. Irgendwelche Ideen?

string.Equals(string1, string2, StringComparison.InvariantCultureIgnoreCase)?
Vermeiden ToLower für string-Vergleich, wie es mit größerer Wahrscheinlichkeit zu einem Fehler führen (Türkei Test). Verwenden Sie entweder groß-oder vorzugsweise, wie Corak vorgeschlagen, String.Entspricht.
Diese funktioniert nicht in meinem Fall. Erstens, ich haben keine Kontrolle über den Ausdruck, da es automatisch durch die ASP.Net Web-API. Zweitens möchte ich etwas, das ich kann generisch verwenden, um wickeln Sie eine LINQ-Anweisung und die Arbeit mit LINQ-to-entities und LINQ-to-objects.
Ja, ich lese über die Türkei Testen. Ich bin nicht besorgt mit, dass an diesem Punkt. Aber ich werde versuchen, mit Großbuchstaben, anstelle, sobald ich diese zu arbeiten.
Vertrauen, du machst das gut, Hast du am Ende schreiben gesamte ODATA --> LINQ --> SQL manuell, keine ODATA-V4-framework hat nicht geholfen? stackoverflow.com/q/47055350/1431250

InformationsquelleAutor Josh Mouch | 2013-07-02

c#expression-trees expressionvisitor lambda linq

Machte ich eine Beispiel-app mit dem code und es scheint arbeiten:

    public class Test
{
    public string Name;
}
public class CaseInsensitiveExpressionVisitor : ExpressionVisitor
{

    protected override Expression VisitMember(MemberExpression node)
    {
        if (insideContains)
        {
            if (node.Type == typeof (String))
            {
                var methodInfo = typeof (String).GetMethod("ToLower", new Type[] {});
                var expression = Expression.Call(node, methodInfo);
                return expression;
            }
        }
        return base.VisitMember(node);
    }

    private Boolean insideContains = false;

    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        if (node.Method.Name == "Contains")
        {
            if (insideContains) throw new NotSupportedException();
            insideContains = true;
            var result = base.VisitMethodCall(node);
            insideContains = false;
            return result;
        }
        return base.VisitMethodCall(node);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Expression <Func<Test, bool>> expr = (t) => t.Name.Contains("a");
        var  expr1 = (Expression<Func<Test, bool>>) new CaseInsensitiveExpressionVisitor().Visit(expr);
        var test = new[] {new Test {Name = "A"}};
        var length = test.Where(expr1.Compile()).ToArray().Length;
        Debug.Assert(length == 1);
        Debug.Assert(test.Where(expr.Compile()).ToArray().Length == 0);

    }
}

Hmm.... könnte es damit etwas zu tun haben mit der wirklich langen-Ausdruck übergeben wird in enthält (notiert am Ende meiner Frage): "value(System.Web.Http.OData.Query.Expressions.LinqParameterContainer+TypedLinqParameterContainer`1[System.String]).TypedProperty". Ich weiß nicht, was es ist, aber ich mich trotzdem bewerben ToLower, um es, da es ein String-Typ.
Oder könnte es etwas mit der Tatsache zu tun, dass LINQ to Entities ist die Ausführung der Ausdruck? Wenn ich versuche zu kompilieren/aufrufen der Ausdruck direkt, erhalte ich eine Fehlermeldung über "Diese Methode unterstützt die INQ to Entities-Infrastruktur und ist nicht dazu vorgesehen, direkt aus dem code).
Sorry, ich bin nicht vertraut mit OData.
Sie sagten, Sie wollen linq2Objects haben gleiche Verhalten. Also gehe ich davon aus, dass Sie gemacht hatten Abfrage-Objekt. Wenn der Fehler "Diese Methode unterstützt die.." erscheint in der Regel bedeutet dies, dass Sie verloren Kontext mit der db. zum Beispiel invoke-expression nach Kontext entsorgt.
Tatsächlich, Sie haben Recht. Mein code funktioniert! Das problem war, dass die IQueryable umgewandelt wurde, um ein IList-und dann wieder ein IQueryable, bevor Sie wieder vergangen von der OData Bekommen. Die ersten IQueryable hatte meine ExpressionVisitor angewendet, aber nicht die zweite. Kennzeichnung Euch die Antwort, da Sie mir denken.
Kann ich bitte Eure Hilfe pls. stackoverflow.com/q/47055350/1431250

InformationsquelleAutor Ben

0

können Sie erstellen eine extesion Methode wie diese:
```
public static class Extensions
{
    public static bool InsensitiveEqual(this string val1, string val2)
    {
        return val1.Equals(val2, StringComparison.OrdinalIgnoreCase);
    }
}
```
Und dann kann man rufen wie diese:
```
string teste = "teste";
string teste2 = "TESTE";

bool NOTREAL = teste.Equals(teste2); //FALSE
bool REAL = teste.InsensitiveEqual(teste2); //true
```
- Danke, aber das wird nicht funktionieren. Ich will ein ExpressionVisitor so kann ich wickle meine LINQ-Anweisung, so dass ich es verwenden können, sowohl in LINQ-to-objects und LINQ-to-Entities. Eine benutzerdefinierte Erweiterung InsensitiveEqual() funktioniert nicht in LINQ-to-Entities.
- Zusätzlich, ich haben keine Kontrolle über die Schöpfung des Ausdrucks, da die ASP.Net Web-API Odata-Schicht wird die Erzeugung des Ausdrucks.
InformationsquelleAutor renefc3

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.