如何使用泛型和字符串進行表達式樹“連接”具有內部和外部表達式

Question

為什么我需要它：

我正在處理的程序有一個通用的查詢構造函數，它使用 expression.trees 動態查詢數據庫的所有表。 通過簡單的選擇和幾百或幾千個數據，它工作正常。 當用戶需要相關的表數據時，它使用延遲加載和映射來實現所需的內容，但是如果（以及何時）數據將達到數以千計，它將無法使用。 我正在嘗試刪除延遲加載並在表達式樹中預先加入，使其成為一次旅行。

我需要這個，因為用戶可以在數據庫中動態搜索，並且很難維護每個表的特定查詢，因為它有很多表需要手動維護，並且客戶端要求 tweeks 很多。

問題：

要執行以下查詢，

IQueryable<A> As = db.A
                     .Join(
                           db.B,
                           _a => _a.bID,
                           _b => _b.ID,
                           (_a, _b) => new { a = _a, b = _b })
                     .Where(s => s.b.Name == "xpto")
                     .Select(s => s.a);

接收到的 A 具有泛型類型，而接收到的 B 具有字符串。

使用@NetMage 出色的答案（這只是一部分。完整答案在鏈接或下面）：

private static Type TypeGenArg(this Expression e, int n) => e.Type.GetGenericArguments()[n];

  public static MethodCallExpression Join(this Expression outer, 
                                                    Expression inner, 
                                                    LambdaExpression outerKeyFne, 
                                                    LambdaExpression innerKeyFne, 
                                                    LambdaExpression resultFne) 
                                                    =>
                                                            Expression.Call(
                                                                TQueryable, 
                                                                "Join", 
                                                                new[] { outer.TypeGenArg(0), 
                                                                        inner.TypeGenArg(0), 
                                                                        outerKeyFne.ReturnType, 
                                                                        resultFne.ReturnType }, 
                                                                outer, 
                                                                inner, 
                                                                outerKeyFne, 
                                                                innerKeyFne, 
                                                                resultFne);

在執行 MethodCallExpression 'join' 的以下調用中：

var join = db.A.AsConst().Join(db.B.AsConst(), aKeyFne, bKeyFne, resultFne);

db.A 和 db.B 似乎應該是已知的，但它們不是，因為客戶端決定瀏覽哪個表，而 'B' 是該選擇的結果。

在這個類的上下文中； A 是泛型類型 T，B 是字符串“B”。 因此，當我在“加入”或稍后收到它們時，我試圖能夠調用前一個語句的每個轉換都會引發不同類型的錯誤。 最好的嘗試是當我這樣做時：

        //GetType of Generic Type A
        AType = typeof(A);

        //GetType from string 'B'
        string BModelstr = "B";

        string areaM = "project.Models." + BModelstr;
        Assembly currentAssem = Assembly.GetExecutingAssembly();

        string assemblStr = currentAssem.ToString();


        string complete = areaM + "," + assemblStr;

        Type BType = Type.GetType(complete);

        //And then calling:

        var join1 = (db.Set(AType)).AsConst().Join((db.Set(BType)).AsConst(), aKeyFne, bKeyFne, resultFne);

它引發了一個錯誤

private static Type TypeGenArg(this Expression e, int n) => e.Type.GetGenericArguments()[n];

說它不是通用的。

問題：

• 我怎樣才能將通用類型 T 用作 db.A，並將字符串 'B' 用作 db.B，以便在 expression.call() 'join' 中被接受並獲取它們的類型？
• 修改連接？
• 發送不同的參數，如join<A>和字符串？

我試圖為這個問題實現的相關@NetMage 代碼（完整的向上鏈接）：

var aParm = typeof(A).Param("_a");
var aKeyFne = aParm.Lambda(aParm.Dot("bID"));

var bParm = typeof(B).Param("_b");
var bKeyFne = bParm.Lambda(bParm.Dot("ID"));
var anonType = (new { a = default(A), b = default(B) }).GetType();
var resultFne = (aParm, bParm).Lambda(anonType.New(aParm, bParm));
var join = db.A.AsConst().Join(db.B.AsConst(), aKeyFne, bKeyFne, resultFne);

.....

使用：

public static class ValueTupleExt {
    private static T[] makeArray<T>(params T[] itemArray) => itemArray;
    public static T[] ToArray<T>(this (T, T) tuple) => makeArray(tuple.Item1, tuple.Item2);    
}

public static class ExpressionExt {
    private static Type TQueryable = typeof(Queryable);

    private static Type TypeGenArg(this Expression e, int n) => e.Type.GetGenericArguments()[n];

    public static MethodCallExpression Join(this Expression outer, Expression inner, LambdaExpression outerKeyFne, LambdaExpression innerKeyFne, LambdaExpression resultFne) =>
            Expression.Call(TQueryable, "Join", new[] { outer.TypeGenArg(0), inner.TypeGenArg(0), outerKeyFne.ReturnType, resultFne.ReturnType }, outer, inner, outerKeyFne, innerKeyFne, resultFne);

    public static MethodCallExpression Select(this Expression src, LambdaExpression resultFne) => Expression.Call(TQueryable, "Select", new[] { src.TypeGenArg(0), resultFne.ReturnType }, src, resultFne);

    public static MethodCallExpression Where(this Expression src, LambdaExpression predFne) => Expression.Call(TQueryable, "Where", new[] { src.TypeGenArg(0) }, src, predFne);

    public static ConstantExpression AsConst<T>(this T obj) => Expression.Constant(obj, typeof(T));

    public static MemberExpression Dot(this Expression obj, string propNames) =>
        (MemberExpression)propNames.Split('.').Aggregate(obj, (ans, propName) => Expression.PropertyOrField(ans, propName));

    public static LambdaExpression Lambda(this ParameterExpression p1, Expression body) => Expression.Lambda(body, p1);
    public static LambdaExpression Lambda(this (ParameterExpression, ParameterExpression) parms, Expression body) => Expression.Lambda(body, parms.ToArray());

    public static NewExpression New(this Type t, params Expression[] vals) => Expression.New(t.GetConstructors()[0], vals, t.GetProperties());

    public static BinaryExpression opEq(this Expression left, Expression right) => Expression.Equal(left, right);

    public static ParameterExpression Param(this Type t, string pName) => Expression.Parameter(t, pName);
}

幫助將是真正的apreciated。

謝謝你！