Question

这个问题是基于早期问题的后续行动： Use a generic method with a list of different type/class

我有以下泛型函数，它查找属性并根据作为参数给出的属性对列表进行排序：

public static void SortList<T>(ref List<T> list, String sortExpression, SortDirection sortDirection) { 
    IList<PropertyInfo> properties = typeof(T).GetProperties();
    foreach(var prop in properties){
        if(prop.Name.Equals(sortExpression)){
            if (sortDirection == SortDirection.Ascending) {
                list.Sort(delegate(T t1, T t2) { return prop.GetValue(t1).ToString().CompareTo(prop.GetValue(t2).ToString()); });
            } else {
                list.Sort(delegate(T t1, T t2) { return prop.GetValue(t2).ToString().CompareTo(prop.GetValue(t1).ToString()); });
            }
            return;
        }
    }
}

搜索类的所有属性，并根据该属性对列表进行排序。但是，如果我有一个类uitlening，如下所示：

public class Uitlening {
    public Int64 id { get; set; }
    public Exemplaar exemplaar { get; set; }
    public Medewerker medewerker { get; set; }
    public String van { get; set; }
    public String tot { get; set; }
}

它包含两个子类，Exemplaar和Medewerker。我的函数只是遍历Uitlening的属性，而不是通过Exemplaar和Medewerker的属性。

如何获得＆＃39;子属性＆＃39;从子类循环遍历它并根据它们排序我的列表？

（我希望保持我的功能通用，不要在其中加入任何与课程相关的条款; I.E。

if(prop.Name.Equals("Exemplaar") )

Answer 1

我尝试了很多东西并创建了以下泛型方法来对子类进行排序：

    public static void SortList<T>(ref List<T> list, String sortExpression, SortDirection sortDirection) {
        PropertyInfo propertyInfo = typeof(T).GetProperty(sortExpression);
        if (propertyInfo != null) {
            if (sortDirection == SortDirection.Ascending) {
                list.Sort(delegate(T t1, T t2) { return propertyInfo.GetValue(t1).ToString().CompareTo(propertyInfo.GetValue(t2).ToString()); });
            } else {
                list.Sort(delegate(T t1, T t2) { return propertyInfo.GetValue(t2).ToString().CompareTo(propertyInfo.GetValue(t1).ToString()); });
            }
            return;
        } else {
            foreach (var props in typeof(T).GetProperties()) {
                PropertyInfo pro = props.PropertyType.GetProperty(sortExpression);
                if (pro != null) {
                    if (pro.Name.Equals(sortExpression)) {
                        if (sortDirection == SortDirection.Ascending) {
                            list.Sort(delegate(T t1, T t2) {
                                return pro.GetValue(props.GetValue(t1)).ToString().CompareTo(pro.GetValue(props.GetValue(t2)).ToString());
                            });
                        } else {
                            list.Sort(delegate(T t1, T t2) {
                                return pro.GetValue(props.GetValue(t2)).ToString().CompareTo(pro.GetValue(props.GetValue(t1)).ToString());
                            });
                        }
                        return;
                    }
                }
            }
        }
    }

它基本上会在找到命中时返回，因此不会使用不必要的时间。首先，它查看第一个类层次结构，然后它将查看第二个层次结构。（当然现在很容易扩展到更进一步的层次结构）我同意答案，因为如果其他人可能对答案感兴趣或任何人有其他反馈意见。

Answer 2

创建一个递归方法，通过对象图查看属性，然后查看属性的属性等。当它命中给定的属性名称时，它会停止递归并返回匹配属性值的ToString（）。

然后进行排序。

你想要实现的目标有潜在的危险：你可能会遇到意想不到的打击，所以尽管你试图制定一个可以解决任何问题的解决方案，但要确保它有效，你需要事先知道这些名字属性一直向下，这意味着它并没有真正做到你想要的。

您可以告诉您的递归方法只能递归参数中提供的某些类型的属性，或者实现给定接口或从给定基类继承的属性。如果您确定不会得到任何误报（仅在名称上），您可以默认为对象。

从泛型函数中的类中的类获取属性

2 个答案: