C# 基于参数筛选对象列表

假设我有一份官员名单和一份人员名单。我想根据一些标准筛选这两个列表

所以我写了这个方法：

class Officer
{
    Person person;
}

class Person
{
    string name;
} 

公共列表过滤器名称（列表）
{
//一些滤波逻辑
}

我对这两个列表使用的方法如下：

public List<Person> filterName(List<Person> list)
{
   // some filter logic
}

main（）
{
...
List officers=Initialize（）；
List validNames=filterNames（officers.Select（o=>o.person.name）.ToList（））
foreach（高级职员中的var高级职员）
{
如果（！validNames.Contains（officer.Person.name））
军官。免职（军官）；
}
//最后，我这里有一组有效的官员
列出人员=初始化（）；
var filteredPersons=filterNames（persons.Select（o=>o.name.ToList（））
}

是否有一种使用泛型的好方法可以避免main方法（）中的以下代码

List validNames=filterNames（officers.Select（o=>o.fullName.ToList（））
foreach（高级职员中的var高级职员）
{
如果（！validNames.Contains（高级职员姓名））
军官。免职（军官）；
}

---

并以某种方式使用泛型更新军官名单。

基于最近编辑的新答案：

 List<string> validNames = filterNames(officers.Select(o=>o.fullName).ToList())
 foreach (var officer in officers)
 {
      if (!validNames.Contains(officer.name))
             officers.remove(officer);
 }

---

基于最近编辑的新答案：

 List<string> validNames = filterNames(officers.Select(o=>o.fullName).ToList())
 foreach (var officer in officers)
 {
      if (!validNames.Contains(officer.name))
             officers.remove(officer);
 }

---

好的，让我们假设您有一些复杂的

FilterNames

函数，它对列表进行操作，您的目标是根据一些

Person

标准进行筛选。我会像这样重写过滤器：

static void Main(string[] args)
{
    var officers = new List<Officer>
    {
        new Officer { Name = "Officer Foo" },
        new Officer { Name = "Officer Bar" }
    };

    var workers = new List<Worker>
    {
        new Worker { Name = "Worker Foo" },
        new Worker { Name = "Worker Bar" }
    };

    var people = workers.Cast<IPerson>().Concat(officers);
    var filteredPeople = Program.Filter(people, "Foo");

    Console.ReadKey(true);
}

static IEnumerable<IPerson> Filter(IEnumerable<IPerson> people, string keyword)
{
    return people.Where(p => p.Name.Contains(keyword));
}

interface IPerson
{
    string Name { get; set; }
}

class Officer : IPerson
{
    public string Name { get; set; }
}

class Worker : IPerson
{
    public string Name { get; set; }
}

现在，您可以在Linq语句中使用它：

public bool FilterPerson(Person p)
{
    //Some complicated logic
    //Returns true if person should be kept
    //Returns false if the person should be rejected
}

无需从列表中删除项目。您仍然可以使用过渡对象，它只需要额外的步骤：

var officers = Initialize().Where(o => FilterPerson(o.Person)).ToList();

var=Initialize（）//返回列表
var filteredOfficers=officers.Where（o=>FilterPerson（o.Person））.ToList（）；

好的，让我们假设您有一些复杂的

过滤器名称

函数，它对列表进行操作，您的目标是根据一些

人员

标准进行过滤。我会像这样重写过滤器：

static void Main(string[] args)
{
    var officers = new List<Officer>
    {
        new Officer { Name = "Officer Foo" },
        new Officer { Name = "Officer Bar" }
    };

    var workers = new List<Worker>
    {
        new Worker { Name = "Worker Foo" },
        new Worker { Name = "Worker Bar" }
    };

    var people = workers.Cast<IPerson>().Concat(officers);
    var filteredPeople = Program.Filter(people, "Foo");

    Console.ReadKey(true);
}

static IEnumerable<IPerson> Filter(IEnumerable<IPerson> people, string keyword)
{
    return people.Where(p => p.Name.Contains(keyword));
}

interface IPerson
{
    string Name { get; set; }
}

class Officer : IPerson
{
    public string Name { get; set; }
}

class Worker : IPerson
{
    public string Name { get; set; }
}

现在，您可以在Linq语句中使用它：

public bool FilterPerson(Person p)
{
    //Some complicated logic
    //Returns true if person should be kept
    //Returns false if the person should be rejected
}

无需从列表中删除项目。您仍然可以使用过渡对象，它只需要额外的步骤：

var officers = Initialize().Where(o => FilterPerson(o.Person)).ToList();

var=Initialize（）//返回列表
var filteredOfficers=officers.Where（o=>FilterPerson（o.Person））.ToList（）；

你没有问题，你在问什么？对不起，我在写问题之前按了回车键。如果不清楚，请告诉我。我想我不确定您要找的是什么，您可以使用类似于

public List filter（IEnumerable，Func filter）{…}

的方法来创建一个通用的“过滤器”，但此时您最好在LINQ语句中这样做，比如

persons.Where（o=>o.Length<10）.ToList（）

…foreach（var人员中的人员）{if（！validNames.Contains（officer.fullName.name））人员移除（人员）；}foreach（var人员中的人员）{if（！validNames.Contains（person.name））人员移除（人员）；}我可以在泛型方法中使用这两个for循环吗？就像@RonBeyer说的：你只是在寻找可枚举的。Where？-我可以看出这在语义上略有不同，但实际上，如果你没有关键的性能问题，你可以使用Where和ToList创建一个新的列表，而不是从原始列表中删除。你没有这里有一个问题，你在问什么？很抱歉，我在写问题之前按了enter键。如果不清楚，请告诉我。我想我不确定你在找什么，你可以使用

public List filter（IEnumerable，Func filter）{…}之类的方法来创建一个通用的“过滤器”

但是在这一点上，您最好在LINQ语句中这样做，比如

persons.Where（o=>o.Length<10.ToList（）

…foreach（var-officer-in-officers）{if（！validNames.Contains（officer.fullName.name））officers.remove（officers）；}foreach（var-person-in-persons）{如果（！validNames.Contains（person.name））persons.remove（person）；}我可以在泛型方法中使用这两个for循环吗？就像@RonBeyer说的：你只是在寻找可枚举的。Where？-我可以看出这在语义上略有不同，但实际上，如果你没有关键的性能问题，你可以使用Where和ToList创建一个新的列表，而不是从原始的。Persons和Off中删除Icer没有亲戚关系-他们只是碰巧有一个普通的名字域。欣赏思想人物和官员没有亲戚关系-他们只是碰巧有一个普通的名字域。欣赏思想思想完美！这太棒了！谢谢@ron你有学习泛型/linq语句的建议吗？有一些建议吗t教程，var filteredOfficers=officers.Where（o=>FilterPerson（o.Person））.ToList（）；不正确。需要一份人员名单，但通过一份one@Raj

FilterPerson

在我的示例中，只需要一个人，而不是一个列表。太棒了！这太棒了！谢谢@ron你有学习泛型/linq语句的建议吗？有一些不错的教程，var filteredOfficers=officers。其中（o=>FilterPerson（o.person））.ToList（）；不正确。需要一份人员名单，但通过一份one@Raj

FilterPerson

在我的示例中，只取一个人，而不是列表。