C# 单个筛选例程，用于按同一属性列出两个不同类

本文关键字：同类 两个 属性 例程 筛选 单个 用于 | 更新日期: 2023-09-27 18:26:13

有两个类：

public class A {
    public int IntProp { get; set; }
    public string template { get; set; }
}

public class B {
    public string name { get; set; }
    public string template { get; set; }
}

我要创建的例程将接收List<A>或List<B>，并根据 template 属性应用一些筛选。A中要避免的模板是："b"，"bb"，"bbb"，B中要避免的模板是："a"，"aa"，"aaa"。

所以我做了这样的事情： 

static List<A> filterAsByTemplate(List<A> listOfA, string skipInAList, char separator) {
    foreach (string template in skipInAList.Split(separator)) {
        listOfA.RemoveAll(x => x.template.Equals(template));
    }
    return listOfA;
}
static List<B> filterBsByTemplate(List<B> listOfB, string skipInBList, char separator) {
    foreach (string template in skipInBList.Split(separator)) {
        listOfB.RemoveAll(x => x.template.Equals(template));
    }
    return listOfB;
}

哪里 

string skipInAList = "b;bb;bbb";
string skipInBList = "a;aa;aaa";
char separator = ';';

如何将filterAsByTemplate和filterBsByTemplate结合起来？

C# 单个筛选例程，用于按同一属性列出两个不同类

您可以定义用于筛选的接口，而不是实现使用此接口实现列表的筛选器方法。

public interface IFilterable
{
    string FilterProperty { get; }
}
public class A : IFilterable
{
    //implementation
}
public class B : IFilterable
{
    //Implementation
}
//Declaring Filter as extension method is possible aswell:
//static IEnumerable<T> Filter(this IEnumerable<T> source, string criteria) 
static IEnumerable<T> Filter(IEnumerable<T> source, string criteria) 
       where T : IFilterable
{
    foreach(var item in source)
    {
       if(item.FilterProperty.Contains(criteria)) yield return item;
    }
}

你可以做这样的事情：

定义基类：

public abstract class BaseTypeOfAB
{
    public abstract string template {get;set;}
}

A和B都继承自BaseTypeOfAB.喜欢这个：

public class A : BaseTypeOfAB {
    public int IntProp { get; set; }
    public override string template { get; set; }
}

public class B : BaseTypeOfAB {
    public string name { get; set; }
    public override string template { get; set; }
}

编写一个接受列表和跳过的泛型函数。使用 like 查看这些值是否不包含在跳过中。喜欢这个：

static List<TClass> filterByTemplate<TClass>(List<TClass> ls,string skipInList,char seperator) where TClass: BaseTypeOfAB
{
    return ls.Where (w =>!skipInList.Split(seperator).Contains(w.template)).ToList();
}

如果通过"组合"，您的意思是使用单个方法统治它们，则必须具有一个通用类型来使用 template 属性A和B，并且该方法的参数将List<BaseTypeOfAB>。

像这样：

public abstract class BaseTypeOfAB
{
    public string template { get; set; }
}
public class A : BaseTypeOfAB
{
    public int IntProp { get; set; }
}
public class B : BaseTypeOfAB
{
    public string name { get; set; }
}
static List<T> filterByTemplate<T>(List<T> list, string skipInList, char separator) where T : BaseTypeOfAB
{
    foreach (string template in skipInList.Split(separator))
        list.RemoveAll(x => x.template.Equals(template));
    return list;
}

或者，如果您不想更改类的结构，则可以改为传递泛型委托：

static List<T> filterByTemplate<T, TProp>(List<T> list, Func<T, TProp> predicate, string skipInList, char separator)
{
    foreach (string template in skipInList.Split(separator)) {
        list.RemoveAll(x => predicate(x).Equals(template));
    return list;
}
// Usage:
var listOfAs = new List<A>();
var listOfBs = new List<B>();
filterByTemplate(listOfAs, x => x.template, "a;aa;aaa", ';');
filterByTemplate(listOfBs, x => x.template, "b;bb;bbb", ';');
相关文章：