按可以为空的父对象对 IList<Person> 进行排序

Question

我一直在浏览搜索系统，但没有找到我的问题的答案，虽然这些问题很相似，我什至用其中一些作为开始，但我碰了壁。

我已经检查了这些问题

• Algorithm for sorting a list of objects in c#
• Sorting an IList in C#

我有一个由 nHibernate 带回的名为 Person 的对象，如下所示

 public class Person : IPerson, IComparable<Person>{

    // private properties
    private int _id;
    private string _name;
    private Person _parent;
    private IList<Person> _children;
    private IList<Group> _groups;

    // public properties
    public virtual int id
    {
       get { return _id; }
       set { _id = value; }
    }

    public virtual string name
    {
       get { return _name; }
       set { _name= value; }
    }

    public virtual Person Parent
    {
       get { return _parent; }
       set { _parent = value; }
    }

    public virtual IList<Person> Children
    {
       get { return _children; }
       set { _children = value; }
    }

    public virtual IList<Group> Groups
    {
       get { return _groups; }
       set { _groups = value; }
    }

    // constructor
    public Person() {}

    // this section I added after looking on SO
    public virtual Int32 parentid
    {
       get {
          if (_parent == null)
          {
             return _id;
          } else {
             return _parent.id;
          }
       }
    }

    public virtual Int32 CompareTo(Person obj)
    {
       if (this.id == obj.id)
          return 0;
       return this.parentid.CompareTo(obj.parentid);
    }
 }

然后是我的 Dao 中的一个方法，它返回一个组下数据库中所有 Person 对象的列表。不幸的是，它使它们按输入顺序返回，我想将它们分类为父子关系。

 i.e. (id,name,parent)
 person 1 (1,"Alice",null)
 person 2 (2,"Bob",1)
 person 3 (3,"Charlie",null)
 person 4 (4,"Dejgo",2) // child of a child
 person 5 (5,"Edgar", null)
 person 6 (6,"Florence", 3)

当我按照answer 中提到的那样进行排序时：

 class PeopleBLL : IPeopleBLL {

    // spring properties
    private IGroupsBLL _groupsBLL;
    private IPeopleDao _peopleDao;

    // public properties where spring sets up the links to the other dao and bll methods
    public IGroupsBLL {
        set{_groupsBLL = value;}
    }
    public IPeopleDao {
        set{_peopleDao= value;}
    }

    // constructor
    public PeopleBLL()
    {
    }

    // method we are interested in
    public IList<Person> GetAllInGroup(int groupID){
       //get the group object
       Group groupObject = _groupsBLL.Get(groupID); 
       // get the people in the group
       IList<Person> people = _peopleDao.GetAllInGroup(groupObject);
       // do something here to sort the people
       people.Sort();
       // return the list of people to aspx page
       return people;
    }
 }

我得到格式的列表

    person 2
 person 1
    person 6
 person 3
 person 5
       person 4

但我想要它的格式

 person 1
    person 2
        person 4
 person 3
    person 6
 person 5

有什么想法吗？

编辑：

我没有把剩下的内容放进去，因为我不想被使用的所有额外技术混淆这个问题，但是因为我被问到了。 Spring.Net 用于连接所有对象，我有一个 3 层架构前端（asp.net 页面）、业务层和与数据库通信的 Dao 层。我更新了 GetAllInGroup() 以显示它所做的一切，但这只是我感兴趣的排序。Dao 使用 nHibernate Criteria Query 来获取组下的所有对象，如下所示。

  public IList<Person> getRegistrationsForDonor(Group groupObject) {
      IList<Person> rv = CurrentSession.CreateCriteria(typeof(Person),"p")
                         .CreateCriteria("Groups","g")
                         .Add(Expression.Eq("g.id", groupObject.id))
                         .List<Person>();
      return rv;
  }

所有这一切都是在对象数据源中的 aspx 页面中开始的

 <asp:ObjectDataSource ID="ObjectDataSource1" OnObjectCreating="DataSource_ObjectCreating" runat="server" DataObjectTypeName="Domain.Person"  TypeName="BusinessLayer.PersonBLL" DeleteMethod="delete" SelectMethod="GetAllInGroup" UpdateMethod="update">
    <SelectParameters>
        <asp:ControlParameter ControlID="groupid" Type="Int32" DefaultValue="0" Name="groupID" />
    </SelectParameters>
</asp:ObjectDataSource>

然后由 gridview 使用，所以不幸的是，我需要将 BLL 中的排序 IList 作为单个 IList 返回到 BLL 方法的前端。

编辑 2

抱歉，假设所有父级在顶层都为空，我可以理解该假设的来源，但理论上您可以在组中只有子级，因此没有一个对象的父级为空值。例如以下是一个有效的组。

 person 2 (2,"Bob",1)
 person 4 (4,"Dejgo",2) // child of a child
 person 6 (6,"Florence", 3)

我希望它会返回

 person 2
    person 4
 person 6

编辑 3

很遗憾，所有这些都无法在评论中推测出来，所以我必须在这里回复。

在 17:30 尝试了@jon-senchyna 的回答，我肯定越来越近了，我刚刚在一些实时数据上尝试了这个，它几乎就在那里，但我似乎遇到了孩子在父母面前出现的问题在群里。以下面的示例为例，第 1 组有 48 人，我将突出显示感兴趣的人。

 (789, "person 1", null)
 (822, "Person 34", null)
 (825, "Person 37", 789)
 (3060, "Person 47", 822)
 (3061, "Person 48", 825)

这是它们从数据库中返回的顺序，但是当它们通过排序时，它们是在顺序中的

 Person 48 - id: 3061
 Person 37 - id: 825
 Person 1 - id: 789
 Person 47 - id: 3060
 Person 34 - id: 822

所以孩子们在父母旁边，但顺序相反，我希望他们按顺序排列

 Person 1 - id: 789
 Person 37 - id: 825
 Person 48 - id: 3061
 Person 34 - id: 822
 Person 47 - id: 3060

Answer 1

如果您想通过 CompareTo 执行此操作，您可能需要一些更复杂的逻辑来处理比较父树。以下是一个可能的解决方案：

public virtual Int32 CompareTo(Person person2)
{
    Stack<Person> parents1 = GetParents(this);
    Stack<Person> parents2 = GetParents(person2);
    foreach (Person parent1 in parents1)
    {
        Person parent2 = parents2.Pop();
        // These two persons have the same parent tree:
        // Compare their ids
        if (parent1 == null && parent2 == null)
        {
            return 0;
        }
        // 'this' person's parent tree is contained in person2's:
        // 'this' must be a parent of person2
        else if (parent1 == null)
        {
            return -1;
        }
        // 'this' person's parent tree contains person2's:
        // 'this' must be a child of person2
        else if (parent2 == null)
        {
            return 1;
        }
        // So far, both parent trees are the same size
        // Compare the ids of each parent.
        // If they are the same, go down another level.
        else
        {
            int comparison = parent1.id.CompareTo(parent2.id);
            if (comparison != 0)
            {
                return comparison;
            }
        }
    }
    // We should never get here anymore, but if we do,
    // these are the same Person
    return 0;
}

public static Stack<Person> GetParents(Person p)
{
    Stack<Person> parents = new Stack<Person>();
    // Add a null so that we don't have to check
    // if the stack is empty before popping.
    parents.Push(null);
    Person parent = p;
    // Recurse through tree to root
    while (parent != null)
    {
        parents.Push(parent);
        parent = parent.Parent;
    }
    return parents;
}

更新：两个父堆栈现在都包含原始人，使比较逻辑更容易一些。

Answer 2

只是一个考虑：您不需要加载所有人。 如果您只加载没有父母的人，您将检索 1、3 和 5。 您可以使用 Children-property 访问 2、4 和 6。 要按该顺序（没有层次结构）获得所有 6 个的列表，您可以递归地遍历 3 个根节点并创建最终列表。