How to add record to multiple tables in MVC through EF Repositry

Question

I have three models like below First Student Model

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

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

}

Second Class Model

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

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

And the third one is Student Class

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; }
    }

And here are my abstract classes for Student and Class

    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);
    }
}

And repository for both the classes are:

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;
        }
    }
}

and my view for class and section

<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" />

Now I want when we add student to database there I want to save to other data to Student table and class information to StudentClass table. how can i do it??? thanks in advance

Answer 1

This is more of a question of design patterns and the way you are working. Depending on your needs, the save should be handled by a service, lets call yours StudentService.cs

This will take an instance of both the EFClassRepository & EFStudentRepository

The service interface IStudentService.cs should be used by the controller of the page you are saving on and this should call save on the service, which in turn will take whatever object you are passing from the page and use those details to call a save on both repositories. So as a quick example:

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:

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

Your model would contain at min the requirement for holidng the student and class, assuming you dont want to just save a blank class for each student with no info:

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;
        }
    }

You could of course just ref both repositories within the controller and drop the service but its about re-usability and you should really push that up to a service to handle, the controller needs to be viewed as the code behind of the page and be as minimal and dumb as possible, leave the thinking to the services, presenters, etc etc.

It would also be good to get into the habit of making your classes immutable as above, fields and properties should be set in the constructor and methods, not accessed directly, helps structure some code integrity and prevent unintentional changes.