C# EntityFramework 6 Mysql.NET Connector 6.9.9代码优先迁移

我有一个包含两个项目的解决方案，一个asp.net核心mvc 1.0.1和一个带有EF6的.net 4.6.1类库，其中包含我的实体、域模型、抽象和视图模型。我在asp.net核心项目中添加了类库作为参考。我将类库项目设置为启动项目，并启用迁移，甚至成功添加。但一旦我更新了数据库，我就会得到一个错误序列，其中不包含匹配的元素。因此，我切换并创建了同一个项目，但没有拆分为类库和web项目，它现在是一个asp.net mvc5项目，在启用迁移后，我甚至不能添加迁移。我添加了mysql.data.entity 6.9.9，并按照mysql本身的说明和互联网上的其他富指令进行操作，但仍然得到相同的错误

以下是我的dbcontext：

public class SchoolDb : IdentityDbContext<ApplicationUser>
{
    public static string ConnString { get; set; } =
        "Server=localhost; Database=schooldb; Uid=root; Pwd=l1nux43va;";
    public SchoolDb() : base("SchoolDb")
    {

    }

    public static SchoolDb Create()
    {
        return new SchoolDb();
    }

    public DbSet<Attendance> Attendance { get; set; }
    public DbSet<Class> Classes { get; set; }
    public DbSet<Student> Students { get; set; }
    public DbSet<Result> Results { get; set; }
    public DbSet<Teacher> Teachers { get; set; }
    public DbSet<MedicalHistory> MedicalHistories { get; set; }
    public DbSet<School> Schools { get; set; }
    public DbSet<Subject> Subjects { get; set; }
    public DbSet<Payment> Payments { get; set; }
    public DbSet<SchoolSession> Sessions { get; set; }
    public DbSet<TermWork> TermWorks { get; set; }
    public DbSet<Staff> Staff { get; set; }
    public DbSet<ScoreGrade> ScoreGrades { get; set; }
    public DbSet<LessonPlan> LessonPlans { get; set; }
    public DbSet<Hostel> Hostels { get; set; }
    public DbSet<Guardian> Guardians { get; set; }
    public DbSet<BehaviourActivity> BehaviourActivities { get; set; }
    public DbSet<Rating> Ratings { get; set; }
    public DbSet<TermWorkType> TermWorkTypes { get; set; }
    public DbSet<EntranceExam> EntranceExam { get; set; }
    public DbSet<EntranceExamCandidate> EntranceExamCandidate { get; set; }
    public DbSet<EntranceExamSubject> EntranceExamSubject { get; set; }




    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Conventions.Remove<ManyToManyCascadeDeleteConvention>();
        modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
        modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();

        //fluent annotations
        modelBuilder.Entity<Attendance>()
                    .HasMany(a => a.Students);
        modelBuilder.Entity<Attendance>()
                    .HasRequired(a => a.FormTeacher);
        modelBuilder.Entity<BehaviourActivity>()
                    .HasRequired(b => b.Rating)
                    .WithOptional(r => r.BehaviourActivity);

        modelBuilder.Entity<Class>()
                    .HasRequired(c => c.FormTeacher);
        modelBuilder.Entity<Class>()
                    .HasOptional(c => c.Subjects).WithOptionalPrincipal();
        modelBuilder.Entity<Club>()
                    .HasMany(c => c.Students);
        modelBuilder.Entity<EntranceExam>()
                    .HasMany(e => e.EntranceExamCandidate)
                    .WithRequired(e => e.EntranceExam).WillCascadeOnDelete(true);
        modelBuilder.Entity<EntranceExam>()
                    .HasMany(e => e.ExamSubjects)
                    .WithRequired(s => s.EntranceExam);
        modelBuilder.Entity<EntranceExamCandidate>()
                    .HasMany(e => e.ExamSubjects)
                    .WithRequired(s => s.EntranceExamCandidate);
        modelBuilder.Entity<Guardian>()
                    .HasMany(g => g.Students)
                    .WithRequired(s => s.Guardian);
        modelBuilder.Entity<Hostel>()
                    .HasMany(h => h.Students);
        modelBuilder.Entity<Hostel>()
                    .HasRequired(h => h.Patron);
        modelBuilder.Entity<MedicalHistory>()
                    .HasMany(m => m.Disabilities)
                    .WithRequired(d => d.MedicalHistory);
        modelBuilder.Entity<MedicalHistory>()
                    .HasMany(m => m.Illnesses)
                    .WithRequired(i => i.MedicalHistory);
        modelBuilder.Entity<MedicalHistory>()
                    .HasMany(m => m.Allergies)
                    .WithRequired(a => a.MedicalHistory);
        modelBuilder.Entity<Payment>()
                    .HasMany(p => p.PaymentTypes);
        modelBuilder.Entity<Payment>()
                    .HasRequired(p => p.SchoolSession);
        modelBuilder.Entity<Result>()
                    .HasRequired(r => r.Student);
        modelBuilder.Entity<Result>()
                    .HasRequired(r => r.SchoolSession);
        modelBuilder.Entity<Result>()
                    .HasRequired(r => r.Subject);
        modelBuilder.Entity<School>()
                    .HasMany(s => s.Students);
        modelBuilder.Entity<School>()
                    .HasMany(s => s.Teachers);
        modelBuilder.Entity<School>()
                    .HasMany(s => s.Staff)
                    .WithRequired(s => s.School);
        modelBuilder.Entity<SchoolSession>()
                    .HasRequired(ss => ss.School);
        modelBuilder.Entity<Student>()
                    .HasMany(s => s.Payments)
                    .WithRequired(p => p.Student);
        //modelBuilder.Entity<Student>()
        //            .HasMany(s => s.Subjects)
        //            .WithMany(s => s.Students)
        //            .Map(m =>
        //            {
        //                m.MapLeftKey("StudentId");
        //                m.MapRightKey("SubjectId");
        //                m.ToTable("StudentsSubjects");
        //            });
        modelBuilder.Entity<Student>()
                    .HasOptional(s => s.MedicalHistory)
                    .WithRequired(m => m.Student);
        modelBuilder.Entity<Student>()
                    .HasRequired(s => s.Class);
        modelBuilder.Entity<Subject>()
                    .HasOptional(s => s.ScoreGrade)
                    .WithOptionalPrincipal(sg => sg.Subject);
        modelBuilder.Entity<Teacher>()
                    .HasMany(t => t.LessonPlans)
                    .WithRequired(l => l.Teacher);
        //modelBuilder.Entity<Teacher>()
        //            .HasMany(t => t.Subjects)
        //            .WithMany(s => s.Teachers)
        //            .Map(m =>
        //            {
        //                m.MapLeftKey("TeacherId");
        //                m.MapRightKey("SubjectId");
        //                m.ToTable("TeachersSubjects");
        //            });
        modelBuilder.Entity<TermWork>()
                    .HasRequired(t => t.Student);
        modelBuilder.Entity<TermWork>()
                    .HasRequired(t => t.SchoolSession);
        modelBuilder.Entity<TermWork>()
                    .HasRequired(t => t.Subject);
        modelBuilder.Entity<TermWork>()
                    .HasRequired(t => t.TermWorkType)
                    .WithOptional(tt => tt.TermWork);
    }
}

公立学校数据库：IdentityDbContext
{
公共静态字符串ConnString{get；set；}=
“服务器=localhost；数据库=schooldb；Uid=root；Pwd=l1nux43va；”；
公立学校数据库（）：基本（“学校数据库”）
{
}
公共静态SchoolDb Create（）
{
返回新的SchoolDb（）；
}
公共数据库集{get；set；}
公共数据库集类{get；set；}
公共数据库集学生{get；set；}
公共数据库集结果{get；set；}
公共数据库集{get；set；}
公共数据库集医疗历史记录{get；set；}
公立DbSet学校{get；set；}
公共数据库集主题{get；set；}
公共数据库集{get；set；}
公共数据库集会话{get；set；}
公共DbSet术语{get；set；}
公共DbSet Staff{get；set；}
公共DbSet ScoreGrades{get；set；}
公共数据库集LessonPlans{get；set；}
公共DbSet旅馆{get；set；}
公共数据库集监护人{get；set；}
公共数据库集活动{get；set；}
公共数据库集评级{get；set；}
公共数据库集TermWorkTypes{get；set；}
公共数据库集{get；set；}
公共数据库集入口ExamCandidate{get；set；}
公共DbSet examsubject{get；set；}
模型创建时受保护的覆盖无效（DbModelBuilder modelBuilder）
{
基于模型创建（modelBuilder）；
modelBuilder.Conventions.Remove（）；
modelBuilder.Conventions.Remove（）；
modelBuilder.Conventions.Remove（）；
//流畅的注释
modelBuilder.Entity（）
.有许多（a=>a.学生）；
modelBuilder.Entity（）
.HasRequired（a=>a.FormTeacher）；
modelBuilder.Entity（）
.HasRequired（b=>b.Rating）
.可选（r=>r.activity）；
modelBuilder.Entity（）
.HasRequired（c=>c.FormTeacher）；
modelBuilder.Entity（）
.has可选（c=>c.Subjects）.WithOptionalPrincipal（）；
modelBuilder.Entity（）
.有许多（c=>c.学生）；
modelBuilder.Entity（）
.HasMany（e=>e.enterExamAndidate）
.WithRequired（e=>e.EnterTest）。将级联删除（true）；
modelBuilder.Entity（）
.HasMany（e=>e.ExamSubjects）
.需要时（s=>s.考试）；
modelBuilder.Entity（）
.HasMany（e=>e.ExamSubjects）
.具有必需的（s=>s.EnterExamAndDate）；
modelBuilder.Entity（）
.HasMany（g=>g.Students）
。需要（s=>s.Guardian）；
modelBuilder.Entity（）
.有许多（h=>h.学生）；
modelBuilder.Entity（）
.HasRequired（h=>h.Patron）；
modelBuilder.Entity（）
.HasMany（m=>m.Disabilities）
.需要（d=>d.医疗历史）；
modelBuilder.Entity（）
.有许多（m=>m.疾病）
.需要（i=>i.医疗历史）；
modelBuilder.Entity（）
.有很多（m=>m.过敏）
.需要（a=>a.医疗历史）；
modelBuilder.Entity（）
.HasMany（p=>p.PaymentTypes）；
modelBuilder.Entity（）
.hassrequired（p=>p.SchoolSession）；
modelBuilder.Entity（）
.HasRequired（r=>r.Student）；
modelBuilder.Entity（）
.HasRequired（r=>r.SchoolSession）；
modelBuilder.Entity（）
.HasRequired（r=>r.Subject）；
modelBuilder.Entity（）
.有许多（s=>s.学生）；
modelBuilder.Entity（）
.有许多（s=>s.教师）；
modelBuilder.Entity（）
.HasMany（s=>s.Staff）
.需要（s=>s.School）；
modelBuilder.Entity（）
.has必选（ss=>ss.School）；
modelBuilder.Entity（）
.HasMany（s=>s.Payments）
.需要（p=>p.Student）；
//modelBuilder.Entity（）
//.有许多（s=>s.科目）
//.有许多（s=>s.学生）
//.Map（m=>
//            {
//m.MapLeftKey（“学生ID”）；
//m.MapRightKey（“主体”）；
//m.ToTable（“学生对象”）；
//            });
modelBuilder.Entity（）
.has可选（s=>s.MedicalHistory）
.需要（m=>m.Student）；
modelBuilder.Entity（）
.has必需（s=>s.Class）；
modelBuilder.Entity（）
.HAS可选（s=>s.ScoreGrade）
.与期权委托人（sg=>sg.Subject）；
modelBuilder.Entity（）
.HasMany（t=>t.lesson计划）
.带必选项（l=>l.教师）；
//modelBuilder.Entity（）
//.有许多（t=>t个受试者）
//.机智