0

我正在尝试在应用程序级别以多对多关系管理一些简单的列表。teacher.AddStudent()每次在它们之间建立连接(例如,student.RemoveTeacher())时,我都希望更新两个对象中的关系。

我知道如果我使用 SQL,我会使用类似StudentTeachertable 的东西来管理关系,但我试图了解如何在应用程序中执行此操作。

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace StudentTeacher
{
    // create simple interface
    public interface IPerson {}

    // abstract class
    public abstract class Person : IPerson 
    {
        public int Id { get; set; }
    }

    // concrete "Teacher"
    public class Teacher : Person
    {
        // private list of student ids
        private List<int> _studentIds { get; set; }

        // readonly accessor
        public ReadOnlyCollection<int> StudentIds {
            get { return _studentIds.AsReadOnly(); }
        }

        // constructor
        public Teacher(int id) {
            Id = id;
            _studentIds = new List<int>();    
        }

        // add a student
        public void AddStudent(Student student)
        {
            if (!_studentIds.Contains(student.Id)) {
                _studentIds.Add(student.Id);
                student.AddTeacher(this);
            }
        }

        // remove a student
        public void RemoveStudent(Student student)
        {
            if (_studentIds.Contains(student.Id)) {
                _studentIds.Remove(student.Id);
                student.RemoveTeacher(this);
            }
        }

        public string ToString() {
            return String.Format("Id:{0} | StudentIds:{1}", Id, String.Join(",", StudentIds));
        }
    }

    /// concrete "Student"
    public class Student : Person
    {

        // private list of teacher ids
        private List<int> _teacherIds { get; set; }

        // readonly accessor
        public ReadOnlyCollection<int> TeacherIds {
            get { return _teacherIds.AsReadOnly(); }
        }

        // constructor
        public Student(int id) {
            Id = id;
            _teacherIds = new List<int>();    
        }

        // add a teacher
        public void AddTeacher(Teacher teacher)
        {
            if (!_teacherIds.Contains(teacher.Id)) {
                _teacherIds.Add(teacher.Id); 
                teacher.AddStudent(this);
            }
        }

        // remove teacher
        public void RemoveTeacher(Teacher teacher)
        {
            if (_teacherIds.Contains(teacher.Id)) {
                _teacherIds.Remove(teacher.Id);
                teacher.RemoveStudent(this);
            }
        }

        // simple override
        public string ToString() {
            return String.Format("Id:{0} | TeacherIds:{1}", Id, String.Join(",", TeacherIds));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // create teachers
            var teacher1 = new Teacher(101);
            var teacher2 = new Teacher(102);

            // create students
            var student1 = new Student(501);
            var student2 = new Student(502);
            var student3 = new Student(503);

            // create some relationships
            teacher1.AddStudent(student1);
            teacher1.AddStudent(student2);
            teacher1.AddStudent(student3);

            // see what's happening
            Console.WriteLine(teacher1.ToString()); // "Id:101 | StudentIds:501,502,503"
            Console.WriteLine(student1.ToString()); // "Id:501 | TeacherIds:101"
            Console.WriteLine(student2.ToString()); // "Id:502 | TeacherIds:101"
            Console.WriteLine(student3.ToString()); // "Id:503 | TeacherIds:101"

            // update student1, student2
            student1.AddTeacher(teacher2);
            student2.AddTeacher(teacher2);

            // -- Outputs 
            Console.WriteLine(student1.ToString()); // "Id:501 | TeacherIds:101,102"
            Console.WriteLine(student2.ToString()); // "Id:502 | TeacherIds:101,102"

            Console.ReadLine();
        }
    }
}

对我来说,直接调用相反方向的添加/删除方法感觉不对;

if (!_studentIds.Contains(student.Id)) {
    _studentIds.Add(student.Id);
    student.AddTeacher(this); // calling this directly feels bad
}

我有一种感觉,这很快就会变得非常混乱。我的问题是;

  • 我是否应该寻找添加诸如静态观察者之类的东西 StudentTeacherObserver并在其上引发事件,例如 OnTeacherAddedOnStudentAdded
  • 是否有管理此类关系的特定模式?
  • 是否有适合此目的的更好的数据结构,如果有,它是什么以及如何使用它?
4

2 回答 2

0

嵌套对象图 ( Teacher.Students[0].Teacher...) 通常会让人感到“混乱”,尤其是在决定是延迟加载关系(聊天)还是先加载所有对象,然后映射引用(胖)时。

不过,我认为你并没有想太多。如果不对数据访问做出某种类型的让步,多对多很难正确表示。我认为您需要更深入地评估您的业务问题,以发现更具体的场景以确定您是否需要更改任何内容。

于 2012-11-20T03:10:39.267 回答
0

最简单的事情就是选择一个赢家。所以不要实现这两种情况。这是一个有一点背景的链接:

http://www.ebenroux.co.za/post/2009/09/09/Many-to-Many-Aggregate-Roots.aspx

你必须想出适合你的方法。表示真实的对象也不总是一个好主意。简单地存储相关 ID 可能就足够了。在Order/OrderItemProduct示例中。可能没有理由在其中包含实际Product对象,OrderItem因为它不是Order聚合的一部分。您只Product使用OrderItem. 直到执行Order操作(实际上有人开始填充Order),它都可以更改。当然,关于停止流程(取消订单)和退回产品等的业务规则可能很繁琐,但从一种情况/业务到下一种情况/业务会发生变化。

关键是尝试“切割”您的对象图,以便您拥有明确定义的聚合。

这有助于延迟加载位。我从不使用延迟加载,并且会敦促我遇到的任何人尽最大努力避免它。这个想法实际上不是查询您的对象/域模型,但这完全是另一个讨论。

我希望这是有道理的 :)

于 2012-11-20T05:20:08.793 回答