C# 在对所选字符串进行筛选后，是否可以将列表强制转换为类？

我有一个名为PlantAndPath（list1）的类的列表，其中包含一组PlantAndPath类型的对象，带有Plantname和特定植物的路径

然后我有另一个字符串列表（list2），它只包含一组PlantName

我需要比较这些列表中的PlantName，并获得一个PlantAndPath列表，该列表只存在于列表1中

所以我使用.Except（）方法过滤掉我不想要的。问题是，当我过滤Plantnames时，我会得到一个字符串列表，并丢失路径。我要一份车前小路的名单

        List<PlantnameAndPath> list1 = new List<PlantnameAndPath>
        {
            new PlantnameAndPath {Plantname = "Plantname1", Path = "Path1"},
            new PlantnameAndPath {Plantname = "Plantname2", Path = "Path2"},
            new PlantnameAndPath {Plantname = "Plantname3", Path = "Path3"},
            new PlantnameAndPath {Plantname = "Plantname4", Path = "Path4"}
        };

        List<string> list2 = new List<string>
        {
            "Plantname1",
            "Plantname2"
        };

        List<string> onlyInList1 = list1.Select(s => s.Plantname).Except(list2).ToList();

        List<string> whatIGet = new List<string>
        {
            "Plantname3",
            "Plantname4"
        };

        List<PlantnameAndPath> listOfWhatIWant = new List<PlantnameAndPath>
        {
            new PlantnameAndPath {Plantname = "Plantname3", Path = "Path3"},
            new PlantnameAndPath {Plantname = "Plantname4", Path = "Path4"},
        };

List list1=新列表
{
新的PlantnameAndPath{Plantname=“Plantname1”，Path=“Path1”}，
新的PlantnameAndPath{Plantname=“Plantname2”，Path=“Path2”}，
新的PlantnameAndPath{Plantname=“Plantname3”，Path=“Path3”}，
新的PlantnameAndPath{Plantname=“Plantname4”，Path=“Path4”}
};
列表2=新列表
{
“植物名称1”，
“植物名2”
};
仅列出列表1=list1.Select（s=>s.Plantname）.Except（list2.ToList（）；
List whatIGet=新列表
{
“植物名3”，
“植物名4”
};
List listOfWhatIWant=新列表
{
新的PlantnameAndPath{Plantname=“Plantname3”，Path=“Path3”}，
新的PlantnameAndPath{Plantname=“Plantname4”，Path=“Path4”}，
};

您可以执行以下操作：

List<PlantnameAndPath> onlyInList1 = list1.Where(s => !list2.Contains(s.Plantname)).ToList();

//使用注释中建议的@vyrp哈希集
HashSet-badPlantnames=新的HashSet（列表2）；
List ONLYNILIST1=list1.Where（s=>！badPlantnames.Contains（s.Plantname））.ToList（）；

正如你所看到的，我有时会选择那些符合条件的，有时选择那些不符合条件的。有了这些不同的方法，你应该能够组合在一起，这对你的使用来说是足够快的。您可以轻松地混合使用这些方法（例如，在HashSet方法中将

Where（）.ToList（）

替换为

FindAll（）

），以尝试获得更好的性能

---

如果您有结果/新闻，请告诉我：）

您使用的是select，它将

列表

转换为

列表

。这就是为什么你只知道植物名的原因。当我有时间时，我会添加一个答案来解决这个问题。list1.where（x=>！list2.contains（x.Plantname））.tolist（）；正如约利流所说，选择是错误的方法。您应该使用

.Where（s=>！list2.Contains（s.Plantname））

问题是这两个列表可能都包含150000个对象，根据我的经验，.Except（）方法比您过滤对象的方式快得多。使用.Except（）方法是没有办法的吗？@Brewsli-从

list2

中创建一个

HashSet

，然后通过Sebastian的简单注释，您将获得

Except

的速度。问题是这两个列表可能包含150000个对象，根据我的经验，.Except（）方法比您使用的过滤方式快得多。是否无法使用.Except（）方法执行此操作？据我所知并非如此。当然，如果您使用返回植物名称列表的代码，然后使用

Where

确定植物名称是否在所述列表中，则可以使用

除了
。这当然没有任何意义，因为您仍然有
Contains
和
Where
，所以不，我想说的是，只有
Except
方法无法做到这一点。而使用
Except
的另一种方法是使用新实例进行比较。再一次，真的很糟糕，毫无意义。所以不，我想不出一个办法。现在我试着用列表1中的110000和列表2中的150000。你的建议花了14分钟。使用.Except（）方法需要3分钟，然后我使用PlandnameAndPath:list result=onlyInList1.Select（plantname=>list1.FirstOrDefault（s=>s.plantname==plantname））.ToList（）获得了我的列表；对于性能问题，您可以创建一个集合：
var set=newhashset（list2），并使用该集合执行检查：
list1.Where（s=>！set.Contains（s.Plantname））
。让我知道需要多长时间。
// essentially making one list smaller by filtering first with except
List<string> wantedPlantNames = list1.Select(s => s.Plantname).Except(list2).ToList();
List<PlantnameAndPath> onlyInList1 = list1.Where(s => wantedPlantNames.Contains(s.Plantname)).ToList();

// use findAll function from list (no need to call .ToList which can be slow)
List<PlantnameAndPath> onlyInList1 = list1.FindAll(s => !list2.Contains(s.Plantname));

// use removeAll function from list. list1 will then only contain those you want.
list1.RemoveAll(s => list2.Contains(s.Plantname));

// using a hashset as @vyrp suggested in the comments
HashSet<string> badPlantnames = new HashSet<string>(list2);
List<PlantnameAndPath> onlyInList1 = list1.Where(s => !badPlantnames.Contains(s.Plantname)).ToList();