4

Creating Func<IQueryable<T>, IOrderedQueryable<T>>拡張メソッドで並べ替えのジェネリック Func を作成したい:

public static Func<IQueryable<T>, IOrderedQueryable<T>> GetOrderByFunc<T>(this KeyValuePair<string, SortingType> keyValuePair)
{
    //I expect the following result
    //Func<IQueryable<T>, IOrderedQueryable<T>> orderby = q => q.OrderByDescending(c => c.Name);

    //keyValuePair.Key is name of property in type of T that I should sort T by it
    switch (keyValuePair.Value)
    {
        case SortingType.Ascending:
            // Creating Ascending Sorting Func
            break;

        case SortingType.Descending:
            // Creating Descending Sorting Func
            break;

        default :
            break;
    }
}

どのようにすればよいか教えていただけますか？

編集：

この並べ替えにも、T のナビゲーション プロパティの数が含まれます。
例えば：

// keyValuePair.Key equals "User.Count"
// User is a navigation property of T
Func<IQueryable<T>, IOrderedQueryable<T>> orderby = q => q.OrderByDescending(c => c.User.Count);

編集：

以下のように変更GetSelectorしましたが、 で例外が発生しましたbodyExpression。

public static Expression GetSelector<T>(string propertyName)
{
    ParameterExpression parameter = Expression.Parameter(typeof(T));
    if (propertyName.Contains("."))
    {
        propertyName = propertyName.Substring(0, propertyName.IndexOf("."));
        Type navigationPropertyCollectionType = typeof(T).GetProperty(propertyName).PropertyType;

        if (navigationPropertyCollectionType.GetGenericTypeDefinition() == typeof(ICollection<>))
        {                        
            Expression countParameter = Expression.Parameter(navigationPropertyCollectionType, "c");
            MemberExpression countExpression = Expression.Property(countParameter, "Count");
//Exception: Instance property 'Users(ICollection`1)' is not defined for type 'System.Int32'
            var bodyExpression = Expression.Property(countExpression, propertyName, countParameter);
            return Expression.Lambda(bodyExpression, parameter);
        }
    }
    MemberExpression bodyMemberExpression = Expression.Property(parameter, typeof(T).GetProperty(propertyName));
    return Expression.Lambda(bodyMemberExpression, parameter);
}
4

2 に答える 2

4

したがって、最初に必要なのは、プロパティ名が指定されたときにそのプロパティ値を選択するセレクター式を取得できるメソッドです。ゼロから式を作成する必要があります。

public static Tuple<Expression, Type> GetSelector<T>(IEnumerable<string> propertyNames)
{
    var parameter = Expression.Parameter(typeof(T));
    Expression body = parameter;

    foreach (var property in propertyNames)
    {
        body = Expression.Property(body,
            body.Type.GetProperty(property));
    }

    return Tuple.Create(Expression.Lambda(body, parameter) as Expression
        , body.Type);
}

これにより一連のプロパティが生成されるため、メソッドは最終的なプロパティの型も返すことに注意してください。これは、呼び出し元の観点からアクセスするのが特に簡単な情報ではないためです。

Selector を呼び出すときにプロパティの戻り値の型がわからないため、このメソッドの戻り値の型をExpression. にキャストすることはできませんExpression<Func<T, Something>>。を返すようにすることもできますExpression<Func<T, object>>。これは、参照型を選択するすべてのプロパティで機能しますが、値の型をボックス化できないため、これらの場合は実行時例外がスローされます。

さて、その式の正確な型がわからないため、OrderByまたはOrderByDescending直接呼び出すことはできません。MakeGenericMethodリフレクションを使用してそのプロパティの検査に基づいて適切な型を使用して作成できるように、リフレクションと使用を通じてこれらのメソッドを取得する必要があります。

public static Func<IQueryable<T>, IOrderedQueryable<T>> GetOrderByFunc<T>(
    this Tuple<IEnumerable<string>, SortingType> sortCriteria)
{
    var selector = GetSelector<T>(sortCriteria.Item1);
    Type[] argumentTypes = new[] { typeof(T), selector.Item2 };

    var orderByMethod = typeof(Queryable).GetMethods()
        .First(method => method.Name == "OrderBy"
            && method.GetParameters().Count() == 2)
            .MakeGenericMethod(argumentTypes);
    var orderByDescMethod = typeof(Queryable).GetMethods()
        .First(method => method.Name == "OrderByDescending"
            && method.GetParameters().Count() == 2)
            .MakeGenericMethod(argumentTypes);

    if (sortCriteria.Item2 == SortingType.Descending)
        return query => (IOrderedQueryable<T>)
            orderByDescMethod.Invoke(null, new object[] { query, selector.Item1 });
    else
        return query => (IOrderedQueryable<T>)
            orderByMethod.Invoke(null, new object[] { query, selector.Item1 });
}
于 2013-10-16T21:02:52.283 に答える
1

式を使用する必要があります

    public static Func<IQueryable<T>, IOrderedQueryable<T>> GetOrderByFunc<T>(this KeyValuePair<string, SortingType> keyValuePair)
    {

        Func<IQueryable<T>, IOrderedQueryable<T>> result;

        var p1 = Expression.Parameter(typeof (T), "p1");
        var prop = Expression.PropertyOrField(p1, keyValuePair.Key);
        var lambada = Expression.Lambda<Func<T, object>>(prop, new ParameterExpression[] {p1});

        //keyValuePair.Key is name of property in type of T that I should sort T by it
        switch (keyValuePair.Value)
        {
            case SortingType.Ascending:
                result = source => source.OrderBy(lambada);
                break;

            case SortingType.Descending:
                result = source => source.OrderByDescending(lambada);
                break;

            default:
                throw new NotImplementedException();
                break;
        }

        return result;
    }
于 2013-10-16T20:42:16.747 に答える