Question

Possible Duplicate:
'Contains()' workaround using Linq to Entities?

Using LINQ in C#, I have the following problem;

I need to select rows from a big table, using 3 conditions:
– “schooljaar” needs to be a value, set before,
– “p_bamatype” needs to be a value NOT in a list defined in settings (this is a StringCollection)
– “p_stdgeb” needs to be a value NOT in a list defined in settings (this is also a StringCollection)

I have this code:

var set = (db.SA_Opleiding.Where(opleiding => opleiding.schooljaar == schooljaar
                                 &&
                                 !Properties.Settings.Default.Admin_Studiegebieden_Exclude.Cast
                                                           <string>().ToList().Contains(
                                                               opleiding.p_stdgeb.ToString())
                                 &&
                                 !Properties.Settings.Default.Admin_Studietypes_Exclude.Cast
                                                           <string>().ToList().Contains(
                                                               opleiding.p_bamatype.ToString()))
                          .Select(opleiding => new OpleidingModel()
                                    {
                                        Id = opleiding.p_opleiding,
                                        LanNames =
                                            new Dictionary
                                            <string, string>()
                                                {
                                                    {
                                                        "NL",
                                                        opleiding.
                                                        opleidingNL
                                                        },
                                                    {
                                                        "FR",
                                                        opleiding.
                                                        opleidingFR
                                                        },
                                                    {
                                                        "EN",
                                                        opleiding.
                                                        opleidingEN
                                                        }
                                                }
                                    }))
                         .ToList<OpleidingModel>();

        return set;

However, LINQ fails converting the Contains method. I read about others having the same issue, but I can’t seem to find a decent solution for this. Is there really any solution for the problem described? So what I exactly need is a NOT IN (collection of strings) LINQ equivalent.

Answer 1

If one of the various duplicate answers doesn’t help, here is a link to one that might. It references an extension to Linq-to-entities:

public static class QueryExtensions
{
    public static IQueryable<TEntity> WhereIn<TEntity, TValue>
    (
        this ObjectQuery<TEntity> query,
        Expression<Func<TEntity, TValue>> selector,
        IEnumerable<TValue> collection
    )
    {
        ParameterExpression p = selector.Parameters.Single();

        //if there are no elements to the WHERE clause,
        //we want no matches:
        if (!collection.Any()) return query.Where(x=>false);

        if (collection.Count() > 3000) //could move this value to config
            throw new ArgumentException("Collection too large - execution will cause stack overflow", "collection");

        IEnumerable<Expression> equals = collection.Select(value =>
           (Expression)Expression.Equal(selector.Body,
                Expression.Constant(value, typeof(TValue))));

        Expression body = equals.Aggregate((accumulate, equal) =>
            Expression.Or(accumulate, equal));

        return query.Where(Expression.Lambda<Func<TEntity, bool>>(body, p));
    }
}

There are several others like it available.

EDIT

I’ve provided context for the code above, and here is possible usage:

db.SA_Opleiding.WhereIn(v => v.SomeCollection);

I haven’t ever used this specific extension method, but they’re all basically based on the same principle.