String.IsNullOrWhiteSpace in LINQ Expression

Ho il codice seguente:

return this.ObjectContext.BranchCostDetails.Where(
    b => b.TarrifId == tariffId && b.Diameter == diameter
        || (b.TarrifId==tariffId && !string.IsNullOrWhiteSpace(b.Diameter))
        || (!b.TarrifId.HasValue) && b.Diameter==diameter);

E ottengo questo errore quando provo ad eseguire il codice:

LINQ to Entities non riconosce il metodo "Boolean IsNullOrWhiteSpace (System.String)" e questo metodo non può essere tradotto in un'espressione di archivio. "

Come posso risolvere questo problema e scrivere codice meglio di così?

È necessario sostituire

!string.IsNullOrWhiteSpace(b.Diameter)

con

!(b.Diameter == null || b.Diameter.Trim() == string.Empty)

Per Linq to Entities questo viene tradotto in:

DECLARE @p0 VarChar(1000) = ''
...
WHERE NOT (([t0].[Diameter] IS NULL) OR (LTRIM(RTRIM([t0].[Diameter])) = @p0))

e per Linq a SQL quasi ma non è lo stesso

DECLARE @p0 NVarChar(1000) = ''
...
WHERE NOT (LTRIM(RTRIM([t0].[TypeName])) = @p0)

In questo caso è importante distinguere tra IQueryable<T>e IEnumerable<T>. In breve, IQueryable<T>viene elaborato da un provider LINQ per fornire una query ottimizzata. Durante questa trasformazione non sono supportate tutte le istruzioni C #, in quanto non è possibile tradurle in una query specifica back-end (ad esempio SQL) o perché l'implementatore non ha previsto la necessità dell'istruzione.

Al contrario, IEnumerable<T>viene eseguito contro gli oggetti concreti e, pertanto, non verrà trasformato. Quindi, è abbastanza comune che i costrutti, che sono utilizzabili IEnumerable<T>, non possano essere utilizzati con IQueryable<T>e anche che IQueryables<T>supportati da diversi provider LINQ non supportano lo stesso insieme di funzioni.

Tuttavia, esistono alcune soluzioni alternative (come la risposta di Phil ) che modificano la query. Inoltre, come approccio più generale è possibile tornare a un IEnumerable<T>prima di continuare con la specifica della query. Questo, tuttavia, potrebbe avere un impatto sulle prestazioni, specialmente quando lo si utilizza su restrizioni (ad es. Dove clausole). Al contrario, quando si ha a che fare con le trasformazioni, l'hit di prestazioni è molto più piccolo, a volte anche inesistente, a seconda della query.

Quindi il codice sopra potrebbe anche essere riscritto in questo modo:

return this.ObjectContext.BranchCostDetails
    .AsEnumerable()
    .Where(
        b => b.TarrifId == tariffId && b.Diameter == diameter
        || (b.TarrifId==tariffId && !string.IsNullOrWhiteSpace(b.Diameter))
        ||(!b.TarrifId.HasValue) && b.Diameter==diameter
    );

NOTA: questo codice avrà un impatto sulle prestazioni superiore rispetto alla risposta di Phil . Tuttavia, mostra il principio.

Utilizzare un visitatore di espressioni per rilevare riferimenti a string.IsNullOrWhiteSpace e suddividerli in un'espressione più semplice (x == null || x.Trim() == string.Empty).

Di seguito è riportato un visitatore esteso e un metodo di estensione per utilizzarlo. Non richiede alcuna configurazione speciale da usare, basta chiamare WhereEx invece di Where.

public class QueryVisitor: ExpressionVisitor
{
    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        if (node.Method.IsStatic && node.Method.Name == "IsNullOrWhiteSpace" && node.Method.DeclaringType.IsAssignableFrom(typeof(string)))
        {
            //!(b.Diameter == null || b.Diameter.Trim() == string.Empty)
            var arg = node.Arguments[0];
            var argTrim = Expression.Call(arg, typeof (string).GetMethod("Trim", Type.EmptyTypes));

            var exp = Expression.MakeBinary(ExpressionType.Or,
                    Expression.MakeBinary(ExpressionType.Equal, arg, Expression.Constant(null, arg.Type)),
                    Expression.MakeBinary(ExpressionType.Equal, argTrim, Expression.Constant(string.Empty, arg.Type))
                );

            return exp;
        }

        return base.VisitMethodCall(node);
    }
}

public static class EfQueryableExtensions
{
    public static IQueryable<T> WhereEx<T>(this IQueryable<T> queryable, Expression<Func<T, bool>> where)
    {
        var visitor = new QueryVisitor();
        return queryable.Where(visitor.VisitAndConvert(where, "WhereEx"));
    }
}

Quindi, se lo esegui myqueryable.WhereEx(c=> !c.Name.IsNullOrWhiteSpace()), verrà convertito in !(c.Name == null || x.Trim() == "")prima di essere passato a qualunque cosa (linq in sql / entity) e convertito in sql.

Puoi anche usarlo per controllare gli spazi bianchi:

b.Diameter!=null && !String.IsNullOrEmpty(b.Diameter.Trim())

!String.IsNullOrEmpty(b.Diameter.Trim()) 

genererà un'eccezione se lo b.Diameterè null.
Se desideri comunque utilizzare la tua dichiarazione, è meglio utilizzare questo controllo

!String.IsNullOrWhiteSpace(b.Diameter), IsNullOrWhiteSpace = IsNullOrEmpty + WhiteSpace