C# 使用LINQ或Lambda从列表中删除实例？

现在，我要将所有数据作为缓存（对象）中的列表获取，接下来要做的是从列表中删除一些实例

通常，我会这样做：

List<T> list;
List<T2> toBeRemovedItems;
// populate two lists
foreach(T2 item in toBeRemovedItems)
{
    list.Remove(delegate(T one) { 
        // build a condition based on item
        // return true or false
    });
}

列表；
列出要删除的项目；
//填充两个列表
foreach（toBeRemovedItems中的T2项）
{
删除（委托人（一）{
//基于项目构建条件
//返回真或假
});
}

更具体地说，我实际上构建或填充了一个动态类（不是正式定义的类）的toBeRemvoedItems列表。例如，T类类似于MyClass，用于删除的代码如下：

class MyClass<C> {
    public string Value1 { get; set; }
    public int Value2 { get; set; }
    public C ObjectC { get; set; }
}
....
List<MyClass<C>> list;
// populate list
// populate toBeRemovedItems. Here is an example of hard-coded codes:
var toBeRemovedLItems = new[] {
    new { Value1="a", Value2 = 1},
    new { Value2="x", Value2 = 10},
    ...
};
// toBeRemovedItems may be the result of Select from a collection
foreach(var item in toBeRemovedLItems)
{
    list.Remove(delegate(MyClass one) {
        return one.Value1 = item.Value1 && one.Value2 < item.Value2;
    });
}

class-MyClass{
公共字符串值1{get；set；}
公共int值2{get；set；}
公共C对象C{get；set；}
}
....
名单；
//填充列表
//填充toBeRemovedItems。以下是硬编码代码的示例：
var toBeRemovedLItems=new[]{
新的{Value1=“a”，Value2=1}，
新的{Value2=“x”，Value2=10}，
...
};
//toBeRemovedItems可能是从集合中选择的结果
foreach（ToBeRemovedItems中的var项目）
{
列表。删除（委托（MyClass 1）{
返回one.Value1=item.Value1&&one.Value2

我试图在MSDN的

IEnumerable

接口中搜索

Remove（）

方法，但在那里找不到

Remove（）

的方法（有道理，

IEnumerable

仅用于枚举）。在List类中，有几个重载的

Remove（…）

方法。我不确定是否有其他方法可以使用LINQ或Lambda表达式从列表中删除项

---

顺便说一句，我考虑了一种对列表进行查询的方法，以获得一个子集或一个新的带有Where条件的

IEnumerable

列表，类似于从列表中移动项目。但是，我更喜欢从缓存列表中删除项目，在某些情况下，我无法将类中的列表属性重置为新列表（例如私有集）。

您可以使用方法RemoveAll：

MyClass one; //initialize MyClass
list.RemoveAll(item => one.Value1 == item.Value1 && one.Value2 < item.Value2);

MyClass-one//初始化MyClass
list.RemoveAll（item=>one.Value1==item.Value1&&one.Value2

foreach（toBeRemovedLItems中的变量项）{
list.RemoveAll（one=>one.Value1==item.Value1&&one.Value2

---

又来不及了。哦，好吧。

您可以使用LINQ的Where方法来过滤掉不应该在列表中的值。结果是删除了元素的

IEnumerable

var res = list.Where(item => !(one.Value1 == item.Value1 && one.Value2 < item.Value2));

var res=list.Where（item=>！（one.Value1==item.Value1&&one.Value2

---

这将不会更新原始的

列表

实例，而是创建一个新的

IEnumerable

，其中删除了值

我同意Jared关于过滤掉某些项目的建议，但看起来在

Value1

上加入

join

是一种更有效的方法：

var res = list.Where(item => !(one.Value1 == item.Value1 && one.Value2 < item.Value2));

var res = from item1 in list
          join item2 in toBeRemovedList
            on item1.Value1 equals item2.Value1
          where item1.Value2 >= item2.Value2
          select item1;

var removeDict = toBeRemovedList.ToDictionary(i => i.Value1, i => i.Value2);
list.RemoveAll(item => {
    int itemToRemoveValue2;
    if(removeDict.TryGetValue(item.Value1, out itemToRemoveValue2))
        return item.Value2 < itemToRemoveValue2;
    return false;
});

更新：显然我在阅读理解方面失败-新方法：

var res = from item1 in list
          join item2 in toBeRemovedList
            on item1.Value1 equals item2.Value1
          where item1.Value2 >= item2.Value2
          select item1;

var removeDict = toBeRemovedList.ToDictionary(i => i.Value1, i => i.Value2);
list.RemoveAll(item => {
    int itemToRemoveValue2;
    if(removeDict.TryGetValue(item.Value1, out itemToRemoveValue2))
        return item.Value2 < itemToRemoveValue2;
    return false;
});

var removeDict=toBeRemovedList.ToDictionary（i=>i.Value1，i=>i.Value2）；
list.RemoveAll（项=>{
int itemToRemoveValue2；
if（移除ICT.TryGetValue（item.Value1，out itemToRemoveValue2））
返回item.Value2

---

当然，如果你要删除的列表可以从一本字典开始，那就更好了。最终，我们只是想让我们在

Value1

上的匹配更有效。

如果我答对了问题，从两个列表中生成一个唯一的集合

为此，您可以使用以下命令

清单1； 清单2

List list3=list1。除了（list2）

---

列表3将包含唯一的项。

对于非列表的集合（无法公开

RemoveAll

），您仍然可以使用一行代码删除项

要替换内联，只需生成要删除的项的列表，然后运行它并执行删除代码

var dictionary = new Dictionary<string, string>(){{"foo", "0"}, {"boo", "1"}, {"goo", "1"}};
dictionary
    .Where(where_item =>
        ((where_item.Key == "foo") && (where_item.Value == "0"))
        || ((where_item.Key == "boo") && (where_item.Value == "1"))
    )
    .ToList()
    .ForEach(remove_item => {
        dictionary.Remove(remove_item.Key);
    });

var dictionary=newdictionary（）{{“foo”，“0”}，{“boo”，“1”}，{“goo”，“1”}；
词典
.Where（Where_item=>
（（其中item.Key==“foo”）&&（其中item.Value==“0”））
||（（其中item.Key==“boo”）&&（其中item.Value==“1”））
)
托利斯先生（）
.ForEach（删除\u项=>{
dictionary.Remove（删除项.Key）；
});

要在副本中替换，只需生成一个过滤的枚举并返回一个新副本

var dictionary0 = new Dictionary<string, string>(){{"foo", "0"}, {"boo", "1"}, {"goo", "1"}};
var dictionary1 = dictionary0
    .Where(where_item =>
        ((where_item.Key == "foo") && (where_item.Value == "0"))
        || ((where_item.Key == "boo") && (where_item.Value == "1"))
    )
    .ToDictionary(each_item => each_item.Key, each_item => each_item.Value);

var dictionary0=newdictionary（）{{“foo”，“0”}，{“boo”，“1”}，{“goo”，“1”}；
变量字典1=字典0
.Where（Where_item=>
（（其中item.Key==“foo”）&&（其中item.Value==“0”））
||（（其中item.Key==“boo”）&&（其中item.Value==“1”））
)
.ToDictionary（每个_项=>每个_项.Key，每个_项=>每个_项.Value）；

也许你想做这样的事

List<T> firstList;
List<T2> toBeRemovedItems;
List<T> finalList;

foreach(T item in firstList)
{
    toBeRemovedItems = CheckIfWeRemoveThisOne(item.Number, item.Id);
    if (toBeRemovedItems == null && toBeRemovedItems.Count() == 0)
        finalList.Add(item);
}

List-firstList；
列出要删除的项目；
列出财务报表；
foreach（第一个列表中的T项）
{
toBeRemovedItems=CheckIfWereMovetThisOne（item.Number，item.Id）；
if（toBeRemovedItems==null&&toBeRemovedItems.Count（）==0）
最后添加（项目）；
}

---

这就是我如何设法解决在

列表

和

列表

之间消除重复项的问题。我使用

CheckIfWeRemoveThisOne

函数检查

item.Number

是否属于其他项目，使用ID作为定义特征。如果它发现了另一个项目（重复项），而不是尝试将其从原始列表中删除（我从原始列表中获取了

列表

，并且首先在我的函数中获得了

列表

，因此无论如何，我怀疑我如何才能做到这一点），我刚刚创建了一个新列表——如果结果正常，则将结果添加到列表中。

我认为这实际上是一种列表方法，而不是扩展方法。我对代码的理解是，每次删除一项。但我还是要像Rchard Hein的建议一样循环每一个