C# 需要Lambda查询和if，具体取决于值

我想Lambda我的代码，但我卡住了

基本上： 如果数组对象包含例如4个成员，它们有自己的年份规格和id。但是，该数组可以包含更多具有相同和不同Id以及年份的成员，但决不能包含相同Id和相同年份的成员

成员数组：

array[0]: Id 1 Year 2010
array[1]: Id 2 Year 2010
array[2]: Id 1 Year 2008
array[3]: Id 1 Year 2009

第一- 我想删除2010年具有特定Id的所有阵列成员，如果他们在阵列中还有另一年相同Id，不同年份。因此，在本例中，我希望删除[0]，但不删除其他成员

第二- 我只想将2010年之后的下一个最新年份保留为Id 1的2009年，这意味着我也想删除[2]。年份以字符串的形式出现，这就是为什么我要将它们转换为整数，以便在下面的代码中进行比较

---

下面是我的for循环代码，我需要Lambda专家的帮助来避免循环：

var x = Member.Length;

for (int i = 0; i < x; i++)
{
    var y = Member[i].id;
    for (int j = i; j < x; j++)
    {
        var z = Member[j].id;
        if (i != j)
        {
            if (y == z)
            {
                if (Member[i].year == "2010") 
                {
                    Member = Member.Where(w => w != Member[i]).ToArray();
                    i--;
                    j--;
                    x--;
                    break;
                }

                var tempI = Convert.ToInt32(Member[i].year);

                var tempJ = Convert.ToInt32(Member[j].year);

                if (tempI > tempJ)
                {
                    Member = Member.Where(w => w != Member[j]).ToArray();
                    i--;
                    j--;
                    x--;
                    break;
                }
            }
        }
    }
}

---

我倾向于避免使用LINQ来更改我正在查询的基础集合。 下面的代码将为每个成员选择最多两个最新条目

var result = new List<MemberClass>();
var groups = Member.OrderBy(m => m.Id).ThenByDescending(m => m.Year).GroupBy(m => m.Id).ToList();
groups.ForEach(c => result.AddRange(c.Take(2)));

使用结果而不是原始数组

---

我不知道性能是否是你的考虑因素。随着收藏的增加，上面的代码可能会变慢。

您的描述和要求不兼容，但这里有一种解释：

公共班级成员 { 公共int Id{get；set；} 公共字符串年份{get；set；} } var items=新列表{ 新成员{Id=1，Year=2010}， 新成员{Id=2，年份=2010}， 新成员{Id=1，Year=2008}， 新成员{Id=1，年份=2009} }.托雷； //按年份分组，然后只保留最高id var firstFiltered=项目 .群比 x=>x.年， x=>x.Id， 年份，ids=>新成员 { Id=Id.Last， 年=年 }; var secondFiltered=firstFiltered //2010年前只保留10年 .Wherex=>String.Comparex.Year，2010==-1 //然后按Id订购，然后按年份订购 .OrderByx=>x.Id .ThenByx=>x.年 //仅保留上一年/最近一年 .群比 x=>x.Id， x=>x.年， id，年份=>新成员 { Id=Id， 年=年 };

---

我同意这个要求没有多大意义，但这就是我的解释

var Member = new[]
           {
               new { id = 1, year = "2010" },

               new { id = 2, year = "2010" } ,

               new { id = 1, year = "2008" } ,

               new { id = 1, year = "2009" }  
           };

           var results = from item in Member.Select(x => new { x.id, Year = Convert.ToInt32(x.year), item = x })
                         group item by item.id into sameItems
                         let order = sameItems.OrderByDescending(x => x.Year)
                         let first = order.ElementAtOrDefault(0)
                         let second = order.ElementAtOrDefault(1)
                         select first.Year == 2010 && second != null ? second.item : first.item;

            foreach (var item in results)
            {
                System.Console.WriteLine($"id:{item.id},year:{item.year}");
            }        

---

下面是我的for循环代码，我需要Lambda专家的帮助来避免这些循环，为什么你认为Linq会做得有所不同甚至更好？通常，它所做的一切都是为了隐藏复杂性，这是一件坏事。你不应该使用你不懂的代码使你的代码过于复杂。相反，为了简单易懂的代码而奋斗。要找到@HimBromBeere，使用你所知道的。如果你所拥有的有用，那么坚持下去，直到你对其他东西感到舒服为止。可能性是好的，其他东西只会清理外观，即代码行数减少，但对简化代码几乎没有任何作用。@gilliduck可能性是好的，其他东西只会清理外观。。。嗯，嗯，是的。这就是你如何使你的代码更容易阅读，特别是对于那些没有真正编写它的人。学习编写干净的代码，无论是LINQ还是本机控制流，都不会太早。@KennethK。短代码！=干净的代码。如果你不知道某一部分的作用，那么冗长和冗长可能是一个巨大的好处。我有一个以前的同事，他喜欢聪明，喜欢写一些难以理解的短代码。我更喜欢冗长冗长的循环，而不是他聪明干净的代码。我只想在2010年后保留下一个最新的一年。你能详细说明一下吗？2009年是2010年之前，你是说最近还是最高？