C# 编写函数，通过其上的属性筛选项目列表&'；c中的s基类型#

假设我们有一些这样定义的类型：

public class BaseClass
{
    public int Value { get; set; }
}

public class SubClassA : BaseClass
{
    public bool SomeBoolValue { get; set; }
}

public class SubClassB : BaseClass
{
    public decimal SomeDecimalValue { get; set; }
}

我们构造了两个子类类型的列表，如下所示

List<SubClassA> subClassAList = new List<SubClassA>
{
    new SubClassA {SomeBoolValue = true, Value = 0},
    new SubClassA {SomeBoolValue = true, Value = 2},
    new SubClassA {SomeBoolValue = false, Value = 1},

};

List<SubClassB> subClassBList = new List<SubClassB>
{
    new SubClassB {SomeDecimalValue = 1.3M, Value = 2},
    new SubClassB {SomeDecimalValue = 3.5M, Value = 1},
    new SubClassB {SomeDecimalValue = 0.2M, Value = 5},
};

List subassassalist=新列表
{
新的子类{SomeBoolValue=true，Value=0}，
新的子类{SomeBoolValue=true，Value=2}，
新的子类{SomeBoolValue=false，Value=1}，
};
列表子类列表=新列表
{
新的子类B{SomeDecimalValue=1.3M，Value=2}，
新的子类B{SomeDecimalValue=3.5M，Value=1}，
新的子类B{SomeDecimalValue=0.2M，Value=5}，
};

有没有一种方法可以实现一个函数，它可以过滤Value属性上的subassalist和subassblist？ 我知道这可以通过如下函数的结果来实现：

    public static IEnumerable<BaseClass> OrderList(IEnumerable<BaseClass> list)
    {
        return list.OrderBy(x => x.Value);
    }

...
...

        orderedAList = OrderList(subClassAList)
            .Cast<SubClassA>() //Don't like requiring a cast. Unsafe.
            .ToList();

公共静态IEnumerable订单列表（IEnumerable列表）
{
return list.OrderBy（x=>x.Value）；
}
...
...
OrderedList=OrderList（子类列表）
.Cast（）//不喜欢要求强制转换。不安全的。
.ToList（）；

---

但是我们需要将结果转换回子类列表中，因为子类列表似乎不太安全。我知道排序操作本身非常简单，可能不需要单独的函数来执行操作，但是如果您尝试执行比排序更复杂的操作，将逻辑包含到单个函数/类/任何东西中，以实现它，而不是复制代码，这将很有帮助。

您可以使用通用方法来实现这一点

public static IEnumerable<T> OrderList<T>(IEnumerable<T> list) where T : BaseClass
{
return list.OrderBy(x => x.Value);
}

公共静态IEnumerable OrderList（IEnumerable list），其中T:BaseClass
{
return list.OrderBy（x=>x.Value）；
}

您应该为这些类添加如下接口：

 public interface IBaseClass
{
  int Value { get; set; }
}

ublic class BaseClass:IBaseClass
{
    public int Value { get; set; }
}

public class SubClassA : BaseClass,IBaseClass
{
    public bool SomeBoolValue { get; set; }
}

public class SubClassB : BaseClass,IBaseClass
{
    public decimal SomeDecimalValue { get; set; }
}

现在您可以很容易地在Value属性上过滤subassalist和subClassBList

public static IEnumerable<IBaseClass> OrderList(IEnumerable<IBaseClass> list)
    {
        return list.OrderBy(x => x.Value);
    }



orderedAList = OrderList(subClassAList)
            .ToList()

公共静态IEnumerable订单列表（IEnumerable列表）
{
return list.OrderBy（x=>x.Value）；
}
OrderedList=OrderList（子类列表）
托利斯先生（）

您可以使用泛型类解决此问题，如下所示：

class LinqUtil<T> where T : BaseClass
{
    static void MyMain()
    {
        List<SubClassA> subClassAList = new List<SubClassA>
        {
            new SubClassA {SomeBoolValue = true, Value = 0},
            new SubClassA {SomeBoolValue = true, Value = 2},
            new SubClassA {SomeBoolValue = false, Value = 1},

        };

        List<SubClassB> subClassBList = new List<SubClassB>
        {
            new SubClassB {SomeDecimalValue = 1.3M, Value = 2},
            new SubClassB {SomeDecimalValue = 3.5M, Value = 1},
            new SubClassB {SomeDecimalValue = 0.2M, Value = 5},
        };

        IList<SubClassA> orderedAList = LinqUtil<SubClassA>.OrderList(subClassAList)
        .ToList();

        IList<SubClassB> orderedBList = LinqUtil<SubClassB>.OrderList(subClassBList)
        .ToList();

    }

    public static IEnumerable<T> OrderList(IEnumerable<T> list) 
    {
        return list.OrderBy(x => x.Value);
    }
}

类LinqUtil，其中T:BaseClass
{
静态void MyMain（）
{
列表子列表列表=新列表
{
新的子类{SomeBoolValue=true，Value=0}，
新的子类{SomeBoolValue=true，Value=2}，
新的子类{SomeBoolValue=false，Value=1}，
};
列表子类列表=新列表
{
新的子类B{SomeDecimalValue=1.3M，Value=2}，
新的子类B{SomeDecimalValue=3.5M，Value=1}，
新的子类B{SomeDecimalValue=0.2M，Value=5}，
};
IList OrderedList=LinqUtil.OrderList（子类列表）
.ToList（）；
IList orderedBList=LinqUtil.OrderList（子类Blist）
.ToList（）；
}
公共静态IEnumerable订单列表（IEnumerable列表）
{
return list.OrderBy（x=>x.Value）；
}
}

为什么不直接调用列表中的

.OrderBy（x=>x.Value）

？如果在

列表上调用它，它将返回
子类a
的可枚举项，除非您将其强制转换为
基
列表，对吗？因为如果您想对a列表和B列表进行排序，您必须编写两次代码
OrderBy（x=>x.Value）
。老实说，如果只是排序，做这件事没什么大不了的，但我正在寻找这个小问题的解决方案，这样我就可以了解如何将其外推到比排序更复杂且需要多个步骤的操作上。这与我提供的示例不相似吗？OrderList函数只会生成IBaseClass的枚举，而不是基类。结果仍然需要转换回子类列表类型，以便作为子类或子类B的列表对其进行操作，但这是安全的转换，直到您使用泛型方法时进行向上转换谢谢，这是我所需要的。我只是将它应用到我正在使用的一个更复杂的过滤函数中，效果很好。