Как создать выражение System.Linq.Expressions.Expression для Like?

Я создал фильтруемый BindingList из этого источника. Он отлично работает:

list.Filter("Customer == 'Name'");

делает то, что нужно. Внутренности работают как парсер, который преобразует выражение == или != в System.Linq.Expressions.Expression. В этом случае == становится System.Linq.Expressions.Expression.Equal.

К сожалению, System.Linq.Expressions.Expression не содержит подобный оператор, и я не знаю, как это решить.

Начальный код выглядит следующим образом:

private static Dictionary<String, Func<Expression, Expression, Expression>> 
    binaryOpFactory = new Dictionary<String, Func<Expression, Expression, Expression>>();

static Init() {
    binaryOpFactory.Add("==", Expression.Equal);
    binaryOpFactory.Add(">", Expression.GreaterThan);
    binaryOpFactory.Add("<", Expression.LessThan);
    binaryOpFactory.Add(">=", Expression.GreaterThanOrEqual);
    binaryOpFactory.Add("<=", Expression.LessThanOrEqual);
    binaryOpFactory.Add("!=", Expression.NotEqual);
    binaryOpFactory.Add("&&", Expression.And);
    binaryOpFactory.Add("||", Expression.Or);
}

Затем я создал выражение, которое будет делать то, что я хочу:

private static System.Linq.Expressions.Expression<Func<String, String, bool>>
    Like_Lambda = (item, search) => item.ToLower().Contains(search.ToLower());

private static Func<String, String, bool> Like = Like_Lambda.Compile();

например.

Console.WriteLine(like("McDonalds", "donAld")); // true
Console.WriteLine(like("McDonalds", "King"));   // false

Но binaryOpFactory требует этого:

Func<Expression, Expression, Expression>

Предопределенные выражения выглядят точно так:

System.Linq.Expressions.Expression.Or;

Может ли кто-нибудь сказать мне, как преобразовать мое выражение?

ОТВЕТЫ

Ответ 1

Что-то вроде:

static IEnumerable<T> WhereLike<T>(
        this IEnumerable<T> data,
        string propertyOrFieldName,
        string value)
{
    var param = Expression.Parameter(typeof(T), "x");
    var body = Expression.Call(
        typeof(Program).GetMethod("Like",
            BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public),
            Expression.PropertyOrField(param, propertyOrFieldName),
            Expression.Constant(value, typeof(string)));
    var lambda = Expression.Lambda<Func<T, bool>>(body, param);
    return data.Where(lambda.Compile());
}
static bool Like(string a, string b) {
    return a.Contains(b); // just for illustration
}

В терминах Func<Expression,Expression,Expression>:

static Expression Like(Expression lhs, Expression rhs)
{
    return Expression.Call(
        typeof(Program).GetMethod("Like",
            BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)
            ,lhs,rhs);
}

Ответ 2

Я создал 2 метода расширения WhereFilter() для IEnumerable и IQueryable. Таким образом, вы можете использовать этот фильтр также, например, Entity Framework и фильтрация, выполняемая на сервере.

Я использовал фильтр на основе * (не?), поэтому я мог использовать подстилающие методы Linq StartsWith(), EndsWith() и Contains(). Поддерживаемые форматы: A *, * A, * A *, A * B

Использование:

var filtered = list.WhereFilter(i => i.Name, "a*", "First Name");

Здесь основы этого класса:

/// <summary>
/// Extension Methods for Filtering on IQueryable and IEnumerable
/// </summary>
internal static class WhereFilterExtensions
{
    /// <summary>
    /// Filters a sequence of values based on a filter with asterix characters: A*, *A, *A*, A*B
    /// </summary>
    /// <param name="source"></param>
    /// <param name="selector">Field to use for filtering. (E.g: item => item.Name)</param>
    /// <param name="filter">Filter: A*, *A, *A*, A*B</param>
    /// <param name="fieldName">Optional description of filter field used in error messages</param>
    /// <returns>Filtered source</returns>
    public static IEnumerable<T> WhereFilter<T>(this IEnumerable<T> source, Func<T, string> selector, string filter, string fieldName)
    {

        if (filter == null)
            return source;

        if (selector == null)
            return source;

        int astrixCount = filter.Count(c => c.Equals('*'));
        if (astrixCount > 2)
            throw new ApplicationException(string.Format("Invalid filter used{0}. '*' can maximum occur 2 times.", fieldName == null ? "" : " for '" + fieldName + "'"));

        if (filter.Contains("?"))
            throw new ApplicationException(string.Format("Invalid filter used{0}. '?' is not supported, only '*' is supported.", fieldName == null ? "" : " for '" + fieldName + "'"));


        // *XX*
        if (astrixCount == 2 && filter.Length > 2 && filter.StartsWith("*") && filter.EndsWith("*"))
        {
            filter = filter.Replace("*", "");
            return source.Where(item => selector.Invoke(item).Contains(filter));
        }

        // *XX
        if (astrixCount == 1 && filter.Length > 1 && filter.StartsWith("*"))
        {
            filter = filter.Replace("*", "");
            return source.Where(item => selector.Invoke(item).EndsWith(filter));
        }

        // XX*
        if (astrixCount == 1 && filter.Length > 1 && filter.EndsWith("*"))
        {
            filter = filter.Replace("*", "");
            return source.Where(item => selector.Invoke(item).StartsWith(filter));
        }

        // X*X
        if (astrixCount == 1 && filter.Length > 2 && !filter.StartsWith("*") && !filter.EndsWith("*"))
        {
            string startsWith = filter.Substring(0, filter.IndexOf('*'));
            string endsWith = filter.Substring(filter.IndexOf('*') + 1);

            return source.Where(item => selector.Invoke(item).StartsWith(startsWith) && selector.Invoke(item).EndsWith(endsWith));
        }

        // XX
        if (astrixCount == 0 && filter.Length > 0)
        {
            return source.Where(item => selector.Invoke(item).Equals(filter));
        }

        // *
        if (astrixCount == 1 && filter.Length == 1)
            return source;

        // Invalid Filter
        if (astrixCount > 0)            
            throw new ApplicationException(string.Format("Invalid filter used{0}.", fieldName == null ? "" : " for '" + fieldName + "'"));

        // Empty string: all results
        return source;


    }

    /// <summary>
    /// Filters a sequence of values based on a filter with asterix characters: A*, *A, *A*, A*B
    /// </summary>
    /// <param name="source"></param>
    /// <param name="selector">Field to use for filtering. (E.g: item => item.Name)        </param>
    /// <param name="filter">Filter: A*, *A, *A*, A*B</param>
    /// <param name="fieldName">Optional description of filter field used in error messages</param>
    /// <returns>Filtered source</returns>
    public static IQueryable<T> WhereFilter<T>(this IQueryable<T> source, Expression<Func<T, string>> selector, string filter, string fieldName)
    {

        if (filter == null)
            return source;

        if (selector == null)
            return source;

        int astrixCount = filter.Count(c => c.Equals('*'));
        if (astrixCount > 2)
            throw new ApplicationException(string.Format("Invalid filter used{0}. '*' can maximum occur 2 times.", fieldName==null?"":" for '" + fieldName + "'"));

        if (filter.Contains("?"))            
            throw new ApplicationException(string.Format("Invalid filter used{0}. '?' is not supported, only '*' is supported.", fieldName == null ? "" : " for '" + fieldName + "'"));

        // *XX*
        if (astrixCount == 2 && filter.Length > 2 && filter.StartsWith("*") &&         filter.EndsWith("*"))
        {
            filter = filter.Replace("*", "");
            return source.Where(
                Expression.Lambda<Func<T, bool>>(
                    Expression.Call(selector.Body, "Contains", null,  Expression.Constant(filter)),
                    selector.Parameters[0]
                )
            );
        }

        // *XX
        if (astrixCount == 1 && filter.Length > 1 && filter.StartsWith("*"))
        {
            filter = filter.Replace("*", "");
            return source.Where(
                Expression.Lambda<Func<T, bool>>(
                    Expression.Call(selector.Body, "EndsWith", null, Expression.Constant(filter)),
                    selector.Parameters[0]
                )
            );
        }

        // XX*
        if (astrixCount == 1 && filter.Length > 1 && filter.EndsWith("*"))
        {
            filter = filter.Replace("*", "");
            return source.Where(
                Expression.Lambda<Func<T, bool>>(
                    Expression.Call(selector.Body, "StartsWith", null,         Expression.Constant(filter)),
                    selector.Parameters[0]
                )
            );
        }

        // X*X
        if (astrixCount == 1 && filter.Length > 2 && !filter.StartsWith("*") && !filter.EndsWith("*"))
        {
            string startsWith = filter.Substring(0, filter.IndexOf('*'));
            string endsWith = filter.Substring(filter.IndexOf('*') + 1);

            return source.Where(
                Expression.Lambda<Func<T, bool>>(
                    Expression.Call(selector.Body, "StartsWith", null,         Expression.Constant(startsWith)),
                    selector.Parameters[0]
                )
            ).Where(
                Expression.Lambda<Func<T, bool>>(
                    Expression.Call(selector.Body, "EndsWith", null,         Expression.Constant(endsWith)),
                    selector.Parameters[0]
                )
            );
        }

        // XX
        if (astrixCount == 0 && filter.Length > 0)
        {
            return source.Where(
                Expression.Lambda<Func<T, bool>>(
                    Expression.Equal(selector.Body, Expression.Constant(filter)),
                    selector.Parameters[0]
                )
            );
        }

        // *
        if (astrixCount == 1 && filter.Length == 1)
            return source;

        // Invalid Filter
        if (astrixCount > 0)
            throw new ApplicationException(string.Format("Invalid filter used{0}.", fieldName == null ? "" : " for '" + fieldName + "'"));

        // Empty string: all results
        return source;

    }
}