En utilisant PredicateBuilder avec VB.NET

Question

Je l'ai recréée la classe PredicateBuilder dans un projet séparé C # et je suis en train de l'utiliser dans un projet VB.NET mais je continue à obtenir l'erreur suivante:

  

Résolution de surcharge a échoué parce que pas accessible « Ou » accepte ce nombre d'arguments.

quand je l'utilise comme ceci:

Dim predicate = PredicateBuilder.False(Of t_Quote)()
predicate = predicate.Or(Function(q) q.iQuoteType = iQuoteType)

Le projet relivant est référencé, j'utilise la déclaration des importations correctes et tout compile sans erreur.

Toute idée où je vais mal?

Voici la classe PredicateBuilder en C # J'utilise:

  

public static class PredicateBuilder       {           Expression statique publique> True () {   retourner f => true; }           Expression statique publique> Faux () {   retourner f => false; }

    public static Expression<Func<T, bool>> Or<T>(this

     

Expression> Expr1,                                                               Expression> expr2)           {               var invokedExpr = Expression.Invoke (expr2,   expr1.Parameters.Cast ());               retour Expression.Lambda>                      (Expression.OrElse (expr1.Body,   invokedExpr), expr1.Parameters);           }

    public static Expression<Func<T, bool>> And<T>(this

     

Expression> Expr1,                                                               Expression> expr2)           {               var invokedExpr = Expression.Invoke (expr2,   expr1.Parameters.Cast ());               retour Expression.Lambda>                      (Expression.AndAlso (expr1.Body,   invokedExpr), expr1.Parameters);           }       }

Answer 1

Résolu le problème. Ce fut parce que l'option Déduire a été désactivée. Dès que je le régler sur le type correct a été et tout inférer travaillé comme il se doit.

Answer 2

Voici le code qui fonctionne pour moi dans VB.NET, comme je l'ai aussi peaufiné cette classe pour fonctionner en VB.NET ...

Imports System.Linq.Expressions

Public Module PredicateBuilder
    Public Function [True](Of T)() As Expression(Of Func(Of T, Boolean))
        Return Function(f) True
    End Function

    Public Function [False](Of T)() As Expression(Of Func(Of T, Boolean))
        Return Function(f) False
    End Function

    <System.Runtime.CompilerServices.Extension()> _
    Public Function [Or](Of T)(ByVal expr1 As Expression(Of Func(Of T, Boolean)), ByVal expr2 As Expression(Of Func(Of T, Boolean))) As Expression(Of Func(Of T, Boolean))
        Dim invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast(Of Expression)())
        Return Expression.Lambda(Of Func(Of T, Boolean))(Expression.[Or](expr1.Body, invokedExpr), expr1.Parameters)
    End Function

    <System.Runtime.CompilerServices.Extension()> _
    Public Function [And](Of T)(ByVal expr1 As Expression(Of Func(Of T, Boolean)), ByVal expr2 As Expression(Of Func(Of T, Boolean))) As Expression(Of Func(Of T, Boolean))
        Dim invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast(Of Expression)())
        Return Expression.Lambda(Of Func(Of T, Boolean))(Expression.[And](expr1.Body, invokedExpr), expr1.Parameters)
    End Function
End Module

Et voici comment je l'utilise:

Dim pred = PredicateBuilder.True(Of MyClass)()

pred = pred.And(Function(m As MyClass) m.SomeProperty = someValue)
pred = pred.Or(Function(m As MyClass) m.SomeProperty = someValue)

Answer 3

Une chose à garder à l'esprit, mais il ne peut pas résoudre votre problème particulier, est sensibilité à la casse lorsque vous travaillez avec des solutions interlangage.

C # et le CLR lui-même sont sensibles à la casse; VB.NET est pas. Selon la façon dont vous consommez la bibliothèque, une exception peut être levée car le cas ne correspond pas (et ne parvient donc à résoudre un type connu).

Cela peut se produire si vous pensez que vous avez toujours déclaré votre nom d'espace de noms, mais une classe a l'espace de noms déclaré avec un caractère en majuscules. Ceci est très facile à faire dans Visual Basic, mais VB.NET, ils se ressemblent tous comme ils ont compilé en un seul espace de noms cohérent. En ce qui concerne le CLR est préoccupé par le bien, ils sont deux espaces de noms distincts.

J'ai rencontré ce problème avant, et ce fut une très bug insaisissable pour traquer.

Je sais que vous consommez un projet C # de VB.NET, mais gardez un œil sur ce genre de questions.

Answer 4

Il fonctionne pour moi:

Dim predicate = PredicateBuilder.False(Of Integer)()
predicate = predicate.Or(Function(q) q Mod 2 = 0)

(Je n'ai pas votre type de t_Quote)

En outre, il est horrible pratique d'avoir un nom de type comme t_Quote. Cela devrait être appelé Quote; La notation hongroise et underscores sont tous deux mal vus dans les noms C #.