C# 有没有可能；“中断”；LINQ到对象查询？

我试图构造一个linq查询，将规则应用于从两个输入集a和B派生的域中的布尔函数列表

但是，我希望在找到匹配项时“中断”，因此对于a的每个元素，我最多只能得到一个结果

我希望这对那些经验丰富的功能人员来说是有意义的——我的感觉是，我走的是一条与那个世界上的事情是一致的道路，但我不确定我是否真的走上了正确的道路

下面是代码，希望能清楚地知道我在做什么：

List<int> a = new List<int>();
a.Add(1);
a.Add(2);
List<int> b = new List<int>();
b.Add(1);
b.Add(2); 
Func<int, int, string> map = (i, j) => i + "->" + j;
var rules = new List<Func<int,int,Tuple<bool, Func<int, int, string>>>>(); 
rules.Add((i, j) => new Tuple<bool, Func<int,int,string>>(i == j, (ii, jj) => map(ii, jj)));                                  
rules.Add((i, j) => new Tuple<bool, Func<int,int,string>>(i+j == 2, (ii,jj) => map(ii,jj)));                            
var q = from ai in a
        from bi in b
        from rule in rules
        let tuple = rule(ai, bi)
        where tuple.Item1 == true
        select tuple.Item2(ai, bi);  

预期结果：

1->1

2->2

---

我希望发生的是，当第一个规则与1->1匹配时，我可以排除第二个1->1。这似乎允许我有按顺序应用的主规则和回退规则，但不会产生额外的映射。

听起来像是您在寻找的

MSDN中的示例：

        string[] fruits = { "apple", "banana", "mango", "orange", 
                              "passionfruit", "grape" };

        IEnumerable<string> query =
            fruits.TakeWhile(fruit => String.Compare("orange", fruit, true) != 0);

        foreach (string fruit in query)
        {
            Console.WriteLine(fruit);
        }

        /*
         This code produces the following output:

         apple
         banana
         mango
        */

string[]水果={“苹果”、“香蕉”、“芒果”、“橙子”，
“西番莲”、“葡萄”}；
IEnumerable查询=
水果.TakeWhile（水果=>String.Compare（“橙色”，水果，真）！=0）；
foreach（查询中的字符串）
{
控制台。书写线（水果）；
}
/*
此代码生成以下输出：
苹果
香蕉
芒果
*/

听起来你在找

MSDN中的示例：

        string[] fruits = { "apple", "banana", "mango", "orange", 
                              "passionfruit", "grape" };

        IEnumerable<string> query =
            fruits.TakeWhile(fruit => String.Compare("orange", fruit, true) != 0);

        foreach (string fruit in query)
        {
            Console.WriteLine(fruit);
        }

        /*
         This code produces the following output:

         apple
         banana
         mango
        */

string[]水果={“苹果”、“香蕉”、“芒果”、“橙子”，
“西番莲”、“葡萄”}；
IEnumerable查询=
水果.TakeWhile（水果=>String.Compare（“橙色”，水果，真）！=0）；
foreach（查询中的字符串）
{
控制台。书写线（水果）；
}
/*
此代码生成以下输出：
苹果
香蕉
芒果
*/

这就是distinct发挥作用的地方。由于每个规则都由其规则表示唯一标识，因此您只需在输出上执行distinct，这意味着：

        var q = from ai in a
                from bi in b
                from rule in rules
                let tuple = rule(ai, bi)
                where tuple.Item1 == true
                select tuple.Item2(ai, bi);

        q = q.Distinct().ToArray();

将导致：

1->1 

2->2 

而不是

1->1   

1->1   

2->2   

---

这就是distinct发挥作用的地方。由于每个规则都由其规则表示唯一标识，因此您可以简单地对输出执行distinct，这意味着：

        var q = from ai in a
                from bi in b
                from rule in rules
                let tuple = rule(ai, bi)
                where tuple.Item1 == true
                select tuple.Item2(ai, bi);

        q = q.Distinct().ToArray();

将导致：

1->1 

2->2 

而不是

1->1   

1->1   

2->2   

---

谢谢，很酷。因为某种原因，我从来不知道TakeWhile。谢谢，很酷。因为某种原因，我从来不知道TakeWhile。