C# 如何通过EF Repository向MVC中的多个表添加记录

我有如下三种型号 第一学生模型

public class Student
{
    public int ID { get; set; }

    [ForeignKey("account")]
    public int AccountID { get; set; }
    public Account account{ get; set; }  
    //some more

}

二级模型

public class ClassMigration
{
    public int ID { get; set; }
    public String Name { get; set; }

    public bool A { get; set; }
    //etc
}

第三个是学生班

public class StudentClass
    {
        public int ID { get; set; }

        [ForeignKey("student")]
        public int StudentID { get; set; }
        public Student student { get; set; }

        [ForeignKey("clas")]
        public int ClassID { get; set; }
        public ClassMigration clas { get; set; }

        public String Section { get; set; }

        public String Session { get; set; }
    }

这是我为学生和班级准备的抽象课程

    namespace Domain.Abstract
{
    public interface IStudent
    {
        IEnumerable<Student> Students { get; }
        Student SaveStudent(Student student);
        Student DeleteStudent(int ID);
    }
}



namespace Domain.Abstract
{
    public interface IClassMigration
    {
        IEnumerable<ClassMigration> Classes{ get; }
        ClassMigration SaveClass(ClassMigration clas);
        ClassMigration DeleteClass(int ID);
    }
}

namespace-Domain.Abstract
{
公共接口是学生
{
IEnumerable学生{get；}
学生储蓄学生（学生）；
学生删除学生（int ID）；
}
}
命名空间域.Abstract
{
公共接口IClassMigration
{
IEnumerable类{get；}
类迁移存储类（类迁移类）；
类迁移删除类（int-ID）；
}
}

这两个类的存储库是：

namespace Domain.Concret
{
    public class EFStudentRepository:IStudent
    {
        public readonly DbAccess context = new DbAccess();

        public IEnumerable<Entities.Student> Students
        {
            get { return context.Students; }
        }

        public Student SaveStudent(Entities.Student student)
        {
            if (student.ID == 0)
            {
                Account account = new Account();
                account.UserName = student.RegistrationNo;
                account.Password = "123456";
                account.Role = UserRole.Student;
                context.Accounts.Add(account);
                context.SaveChanges();
                student.AccountID = context.Accounts.Max(m => m.ID);

                context.Students.Add(student);
            }
            else
            {
                var org = context.Students.Find(student.ID);
                if (org != null)
                {
                    context.Entry(org).CurrentValues.SetValues(student);
                }
            }
            context.SaveChanges();
            if(student.ID==0)
            {
                student.ID = context.Students.Max(m => m.ID);
            }
            return student;
        }

        public Entities.Student DeleteStudent(int ID)
        {
            var std = context.Students.Find(ID);
            if (std != null)
            {
                context.Students.Remove(std);
                context.SaveChanges();
            }
            return std;
        }
    }
}



namespace Domain.Concret
{
    public class EFClassRepository:IClassMigration
    {
        public DbAccess context = new DbAccess();
        public IEnumerable<Entities.ClassMigration> Classes
        {
            get { return context.Classes; }
        }

        public Entities.ClassMigration SaveClass(Entities.ClassMigration clas)
        {
            if (clas.ID == 0)
            {

                context.Classes.Add(clas);
            }
            else
            {
                var org = context.Classes.Find(clas.ID);
                if (org != null)
                {
                    context.Entry(org).CurrentValues.SetValues(clas);
                }
            }
            context.SaveChanges();
            if (clas.ID == 0)
            {
                clas.ID = context.Classes.Max(m => m.ID);
            }
            return clas;
        }

        public Entities.ClassMigration DeleteClass(int ID)
        {
            var clas = context.Classes.Find(ID);
            if (clas != null)
            {
                context.Classes.Remove(clas);
                context.SaveChanges();
            }
            return clas;
        }
    }
}

命名空间域.Concret
{
公共课EFStudentRepository:IStudent
{
public readonly DbAccess context=new DbAccess（）；
公立学校学生人数众多
{
获取{return context.Students；}
}
公共学生存储学生（Entities.Student-Student）
{
如果（student.ID==0）
{
账户=新账户（）；
account.UserName=student.RegistrationNo；
account.Password=“123456”；
account.Role=UserRole.Student；
context.Accounts.Add（account）；
SaveChanges（）；
student.AccountID=context.Accounts.Max（m=>m.ID）；
context.student.Add（学生）；
}
其他的
{
var org=context.Students.Find（student.ID）；
如果（组织！=null）
{
context.Entry（org.CurrentValues.SetValues（student）；
}
}
SaveChanges（）；
如果（学生ID==0）
{
student.ID=context.Students.Max（m=>m.ID）；
}
留学生；
}
公共实体。学生删除学生（int ID）
{
var std=context.Students.Find（ID）；
如果（std！=null）
{
上下文。学生。删除（std）；
SaveChanges（）；
}
返回std；
}
}
}
命名空间域.Concret
{
公共类EFClassRepository:IClassMigration
{
public DbAccess context=new DbAccess（）；
公共IEnumerable类
{
获取{return context.Classes；}
}
public Entities.ClassMigration存储类（Entities.ClassMigration clas）
{
如果（类别ID==0）
{
context.Classes.Add（clas）；
}
其他的
{
var org=context.Classes.Find（clas.ID）；
如果（组织！=null）
{
context.Entry（org.CurrentValues.SetValues（clas）；
}
}
SaveChanges（）；
如果（类别ID==0）
{
clas.ID=context.Classes.Max（m=>m.ID）；
}
返回clas；
}
public Entities.ClassMigration DeleteClass（int-ID）
{
var clas=context.Classes.Find（ID）；
如果（clas！=null）
{
context.Classes.Remove（clas）；
SaveChanges（）；
}
返回clas；
}
}
}

以及我对班级和部门的看法

<div class="form-group">
                        <label for="Class">Class</label>
                        @Html.DropDownList("Class", @ViewBag.Classes as SelectList, new { @class = "form-control" })
                    </div>
                    <div class="form-group">
                        <label for="Section">Select Section</label>
                        <select id="Section" class="form-control">
                            <option selected="selected" value="A">A</option>
                            <option value="B">B</option>
                            <option value="C">C</option>
                            <option value="D">D</option>
                            <option value="E">E</option>
                            <option value="F">F</option>
                        </select>
                    </div>
                    <div class="form-group">
                        <label for="FatherName">Father Name</label>
                        <input type="text" class="form-control" id="FatherName" placeholder="Father Name" />

等级
@Html.DropDownList（“Class”，@ViewBag.Classes作为SelectList，new{@Class=“form control”}）
选择部分
A.
B
C
D
E
F
父名

---

现在我想，当我们将学生添加到数据库中时，我想将其他数据保存到学生表中，并将班级信息保存到StudentClass表中。我该怎么做？？？提前感谢

这更多的是关于设计模式和工作方式的问题。 根据您的需要，保存应由一个服务处理，让我们调用您的StudentService.cs

这将以EFClassRepository和EFStudentRepository为例

服务接口IStudentService.cs应由您正在保存的页面的控制器使用，这应调用服务上的save，服务上的save将接收您从页面传递的任何对象，并使用这些详细信息调用两个存储库上的save。举个简单的例子：

public class StudentService : IStudentService
    {

        private readonly IStudentRepository studentRepository;
        private readonly IClassRepository classRepository;

        public StudentService(IStudentRepository studentRepository, IClassRepository classRepository)
        {
            if (studentRepository == null) throw new ArgumentNullException(nameof(studentRepository));
            if (classRepository == null) throw new ArgumentNullException(nameof(classRepository));

            this.studentRepository = studentRepository;
            this.classRepository = classRepository;
        }

        public void Save(Student student, Class studentsClass)
        {
            if (student == null) throw new ArgumentNullException(nameof(student));
            if (studentsClass == null) throw new ArgumentNullException(nameof(studentsClass));

            studentRepository.Save(student);
            classRepository.Save(studentsClass);
        }
    }

接口：

interface IStudentService
    {
        void Save(Student student, Class studentsClass);
    }

假设您不想只为每个学生保存一个没有任何信息的空白类，那么您的模型将至少包含对学生和类的保留要求：

public class StudentPageModel
    {
        public int SchoolYear { get; private set; }
        public Student Student { get; private set; }

        public Class Class { get; private set; }

        public StudentPageModel(int schoolYear, Student student, Class studentClass)
        {
            SchoolYear = schoolYear;
            Student = student;
            Class = studentClass;
        }
    }

当然，您可以在控制器中引用两个存储库并删除服务，但这是关于可重用性的，您应该真正将其推到一个要处理的服务上，控制器需要被视为页面背后的代码，并且尽可能地最小化和哑哑化，将想法留给服务、演示者等

---

养成使类不可变的习惯也是很好的，如上所述，字段和属性应该在构造函数和方法中设置，而不是直接访问，帮助构建一些代码完整性并防止意外更改。

创建一个同时更新

Student

表和

StudentClass

表的方法有什么问题？