[英]How to perform Dynamic Join using LINQ
I have two collections. 我有两个收藏。 Each collection contains instances of a specific type. 每个集合都包含特定类型的实例。 I need to join these two collections using one of the properties of the instances from each of the collections. 我需要使用每个集合中实例的属性之一来加入这两个集合。 The issue is that I will come to know which property to use for join only during run time. 问题是,我将只在运行时才知道要用于连接的属性。 So how do I write the LINQ query for a dynamic Join? 那么,如何编写用于动态Join的LINQ查询? Here is the code with LINQ query with static join. 这是带有静态连接的LINQ查询的代码。 In the following sample code you will notice that I am joining two collections using MyTran.MyAmountUSD = YourTran.YourAmountUSD. 在下面的示例代码中,您将注意到我正在使用MyTran.MyAmountUSD = YourTran.YourAmountUSD加入两个集合。 But in real scenario, I will come to know which property to use for join only during run time. 但是在实际情况下,我将知道仅在运行时将哪个属性用于连接。 So sometime I might be required to join on MyTran.MyAmountGBP = YourTran.YourAmountGBP. 因此,有时我可能需要加入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);
}
}
}
The first clue to solving this is to re-write your join using lamda syntax for the Join
第一条线索来解决,这是重新写你的加入使用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
});
Live: http://rextester.com/OGC85986 直播: http : //rextester.com/OGC85986
Which should make it clear that making this dynamic would require passing in to your "generic" join function 3 functions 应该清楚地表明,要使其动态化,需要传递给您的“通用”联接函数3个函数
Func<MyTran,TKey>
function for selecting the key for LHS 一个Func<MyTran,TKey>
函数,用于选择LHS的密钥 Func<YourTran,TKey>
function for selecting the key for RHS Func<YourTran,TKey>
函数,用于选择RHS的密钥 Func<MyTran,YourTran,TResult>
function for selecting the result 一个Func<MyTran,YourTran,TResult>
函数,用于选择结果 So from there you could use reflection to make this all a bit dynamic: 因此,从那里您可以使用反射使这一切变得动态:
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();
}
}
}
Usage to match your example would then be: 匹配您的示例的用法将是:
var query = fMyTranList.DynamicJoin(fYourTranList,
Tuple.Create("MyAmountGBP", "YourAmountGBP"));
but as the keys are params
you can pass as many as you like: 但由于键是params
您可以根据需要传递尽可能多的params
:
var query = fMyTranList.DynamicJoin(fYourTranList,
Tuple.Create("MyAmountGBP", "YourAmountGBP"),
Tuple.Create("AnotherMyTranProperty", "AnotherYourTranProperty"));
Live example: http://rextester.com/AAB2452 实时示例: http : //rextester.com/AAB2452
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.