如何使用LINQ执行动态联接

Question

我有两个收藏。 每个集合都包含特定类型的实例。 我需要使用每个集合中实例的属性之一来加入这两个集合。 问题是，我将只在运行时才知道要用于连接的属性。 那么，如何编写用于动态Join的LINQ查询？ 这是带有静态连接的LINQ查询的代码。 在下面的示例代码中，您将注意到我正在使用MyTran.MyAmountUSD = YourTran.YourAmountUSD加入两个集合。 但是在实际情况下，我将知道仅在运行时将哪个属性用于连接。 因此，有时我可能需要加入MyTran.MyAmountGBP = YourTran.YourAmountGBP。

class MyTran
{
    public int Id { get; set; }
    public double MyAmountUSD { get; set; }
    public double MyAmountGBP { get; set; }
}

class YourTran
{
    public int Id { get; set; }
    public double YourAmountUSD { get; set; }
    public double YourAmountGBP { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        List<MyTran> fMyTranList = new List<MyTran>();
        List<YourTran> fYourTranList = new List<YourTran>();

        fMyTranList.Add(new MyTran { Id = 1, MyAmountGBP = 100, MyAmountUSD = 1000 });
        fMyTranList.Add(new MyTran { Id = 2, MyAmountGBP = 101, MyAmountUSD = 2000 });

        fYourTranList.Add(new YourTran { Id = 11, YourAmountGBP=100, YourAmountUSD=1000 });
        fYourTranList.Add(new YourTran { Id = 12, YourAmountGBP = 102, YourAmountUSD = 3000 });

        var query = from fMyTrans in fMyTranList
                    join fYourTrans in fYourTranList
                         on fMyTrans.MyAmountUSD equals fYourTrans.YourAmountUSD
                    select new
                    {
                        MyId = fMyTrans.Id,
                        YourId = fYourTrans.Id,
                        MyAmtUSD = fMyTrans.MyAmountUSD,
                        MyAmtGBP = fMyTrans.MyAmountGBP,
                        YourAmtUSD = fYourTrans.YourAmountUSD,
                        YourAmtGBP = fYourTrans.YourAmountGBP
                    };

        foreach (var fMatch in query)
        {
            Console.WriteLine(fMatch);
        }
    }
}

Answer 1

第一条线索来解决，这是重新写你的加入使用LAMDA语法的Join

var query = fMyTranList.Join(fYourTranList,
               a => a.MyAmountGBP, 
               b => b.YourAmountGBP, 
               (c,d) => new
                    {
                        MyId = c.Id,
                        YourId = d.Id,
                        MyAmtUSD = c.MyAmountUSD,
                        MyAmtGBP = c.MyAmountGBP,
                        YourAmtUSD = d.YourAmountUSD,
                        YourAmtGBP = d.YourAmountGBP
                    });

直播： http ： //rextester.com/OGC85986

应该清楚地表明，要使其动态化，需要传递给您的“通用”联接函数3个函数

1. 一个Func<MyTran,TKey>函数，用于选择LHS的密钥
2. Func<YourTran,TKey>函数，用于选择RHS的密钥
3. 一个Func<MyTran,YourTran,TResult>函数，用于选择结果

因此，从那里您可以使用反射使这一切变得动态：

public static class DynamicJoinExtensions
{
    public static IEnumerable<dynamic> DynamicJoin(this IEnumerable<MyTran> myTran, IEnumerable<YourTran> yourTran, params Tuple<string, string>[] keys)
    {
        var outerKeySelector = CreateFunc<MyTran>(keys.Select(k => k.Item1).ToArray());
        var innerKeySelector = CreateFunc<YourTran>(keys.Select(k => k.Item2).ToArray());

        return myTran.Join(yourTran, outerKeySelector, innerKeySelector, (c, d) => new
        {
            MyId = c.Id,
            YourId = d.Id,
            MyAmtUSD = c.MyAmountUSD,
            MyAmtGBP = c.MyAmountGBP,
            YourAmtUSD = d.YourAmountUSD,
            YourAmtGBP = d.YourAmountGBP
        }, new ObjectArrayComparer());
    }

    private static Func<TObject, object[]> CreateFunc<TObject>(string[] keys)
    {
        var type = typeof(TObject);
        return delegate(TObject o)
        {
            var data = new object[keys.Length];
            for(var i = 0;i<keys.Length;i++)
            {
                var key = type.GetProperty(keys[i]);
                if(key == null)
                    throw new InvalidOperationException("Invalid key: " + keys[i]);
                data[i] = key.GetValue(o);
            }
            return data;
        };
    }

    private class ObjectArrayComparer : IEqualityComparer<object[]>
    {

        public bool Equals(object[] x, object[] y)
        {
            return x.Length == y.Length
                   && Enumerable.SequenceEqual(x, y);
        }

        public int GetHashCode(object[] o)
        {
            var result = o.Aggregate((a, b) => a.GetHashCode() ^ b.GetHashCode());
            return result.GetHashCode();
        }
    }
}

匹配您的示例的用法将是：

var query = fMyTranList.DynamicJoin(fYourTranList, 
               Tuple.Create("MyAmountGBP", "YourAmountGBP"));

但由于键是params您可以根据需要传递尽可能多的params ：

var query = fMyTranList.DynamicJoin(fYourTranList, 
              Tuple.Create("MyAmountGBP", "YourAmountGBP"), 
              Tuple.Create("AnotherMyTranProperty", "AnotherYourTranProperty"));

实时示例： http ： //rextester.com/AAB2452