C# DataContext.Entry方法代码示例

 public void Test_LockForEditing()
 {
     try
     {
         User iUser = UsersRepository.Instance.GetAllUsers().First();
         Assert.IsNull(iUser.Lock_);
         using (DataContext testContext = new DataContext(connection))
         {
             User testUser = testContext.Users.Find(iUser.ID);
             testContext.Lock<User>(testUser);
             testContext.Entry(testUser).Reload();
             Assert.IsNotNull(testUser.Lock_);
             testContext.Unlock<User>(testUser);
             Assert.IsNull(iUser.Lock_);
         }
     }
     catch (Exception ex)
     {
         Assert.Fail(ex.Message);
     }
 }

		/// <summary>
		/// Attaches the entity to the given context with the specified state.
		/// </summary>
		/// <param name="db">The db context</param>
		/// <param name="state">The entity state</param>
		public void Attach(DataContext db, EntityState state) {
			db.Entry(this).State = state;
		}

 public void updateGV(int id, string value, string date, int regId, int gradeId, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var original = db.GradeValues.Include("Registration").Include("Grade").Where(orig => orig.GradeValueID == id).FirstOrDefault();
             if (original != null)
             {
                 if (regId != original.Registration.RegistrationID || gradeId != original.Grade.GradeID)
                 {
                     if (isGrade(gradeId, regId))
                     {
                         MessageBox.Show("Student already have this grade value.", "GradeValue Update Error");
                         return;
                     }
                     var reg = db.Registrations.Find(regId);
                     original.Registration = reg;
                     var g = db.Grades.Find(gradeId);
                     original.Grade = g;
                 }
                 if (!string.IsNullOrEmpty(value))
                 {
                     original.Value = value.ToUpper();
                 }
                 if (!string.IsNullOrEmpty(date))
                 {
                     original.Date = date;
                 }
                 original.TimeStamp = timestamp;
                 db.GradeValues.Attach(original);
                 db.Entry(original).State = EntityState.Modified;
                 db.SaveChanges();
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbUpdateException ex)
     {
         MessageBox.Show("GradeValue Update Error", "GradeValue Update Error");
         return;
     }
     catch (DbEntityValidationException e)
     {
         throw;
     }
 }

 public void updateRegistration(int id, int realId, int studId, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var orig = db.Registrations.Include("Realisation").Include("Student").Where(o => o.RegistrationID == id).FirstOrDefault();
             if (orig != null)
             {
                 if (orig.Realisation.RealisationID != realId || orig.Student.StudentID != studId)
                 {
                     if (db.Registrations.Where(o => o.Realisation.RealisationID == realId).Where(o => o.Student.StudentID == studId).FirstOrDefault() != null)
                     {
                         MessageBox.Show("Student is already registered to this realisation.", "Realisation Update Error");
                         return;
                     }
                     else
                     {
                         var real = db.Realisations.Find(realId);
                         orig.Realisation = real;
                         var stud = db.Students.Find(studId);
                         orig.Student = stud;
                         orig.TimeStamp = timestamp;
                         db.Registrations.Attach(orig);
                         db.Entry(orig).State = EntityState.Modified;
                         db.SaveChanges();
                     }
                 }
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbEntityValidationException e)
     {
         throw;
     }
 }

 public void updateGrade(int id, string gradeName, string maxValue, int realId, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var original = db.Grades.Include("Realisation").Where(orig => orig.GradeID == id).FirstOrDefault();
             if (original != null)
             {
                 if (realId != original.Realisation.RealisationID)
                 {
                     var real = db.Realisations.Find(realId);
                     original.Realisation = real;
                 }
                 if (!string.IsNullOrEmpty(maxValue))
                 {
                     string Stud = string.Empty;
                     List<GradeValue> gv = db.GradeValues.Include("Grade").Include("Registration").Include("Registration.Student").Where(o => o.Grade.GradeID == id).ToList();
                     if (gv != null)
                     {
                         foreach(GradeValue v in gv)
                         {
                             if (!Validation(maxValue, v.Value))
                             {
                                 Stud = string.Concat(Stud, "\n", v.Registration.Student.LastName);
                                 Console.WriteLine(v.Registration.Student.LastName);
                             }
                         }
                         if (!string.IsNullOrEmpty(Stud))
                         {
                             MessageBox.Show("You have to change or delete these students marks:" + Stud, "Grade MaxValue Update Error");
                             return;
                         }
                     }
                     original.MaxValue = maxValue.ToUpper();
                 }
                 if (!string.IsNullOrEmpty(gradeName))
                 {
                     if (db.Grades.Include("Realisation").Where(o => o.Realisation.RealisationID == realId).Where(o => o.Name == gradeName).FirstOrDefault() != null)
                     {
                         MessageBox.Show("Grade name must be unique in realisation.", "Grade Update Error");
                         return;
                     }
                     original.Name = gradeName;
                 }
                 original.TimeStamp = timestamp;
                 db.Grades.Attach(original);
                 db.Entry(original).State = EntityState.Modified;
                 db.SaveChanges();
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbUpdateException ex)
     {
         MessageBox.Show("Grade Update Error", "Grade Update Error");
         return;
     }
     catch (DbEntityValidationException e)
     {
         throw;
     }
 }

 public void updateRealisation(int id, int semId, int subId, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var orig = db.Realisations.Include("Subject").Include("Semester").Where(o => o.RealisationID == id).FirstOrDefault();
             if (orig != null)
             {
                 if (orig.Semester.SemesterID != semId || orig.Subject.SubjectID != subId) //jeśli coś się zmieniło
                 {
                     if (db.Realisations.Where(o => o.Subject.SubjectID == subId).Where(o => o.Semester.SemesterID == semId).FirstOrDefault() != null)
                     {
                         MessageBox.Show("There is already in this semester such subject.","Realisation Update Error");
                         return;
                     }
                     else
                     {
                         var sem = db.Semesters.Find(semId);
                         orig.Semester = sem;
                         var sub = db.Subjects.Find(subId);
                         orig.Subject = sub;
                         orig.TimeStamp = timestamp;
                         db.Realisations.Attach(orig);
                         db.Entry(orig).State = EntityState.Modified;
                         db.SaveChanges();
                     }
                 }
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbEntityValidationException e)
     {
         throw;
     }
 }

 public void updateSemester(int id, string n, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var original = db.Semesters.Where(orig => orig.SemesterID == id).FirstOrDefault();
             if (original != null)
             {
                 if (!original.Name.Equals(n))
                 {
                     original.Name = n;
                     original.TimeStamp = timestamp;
                     db.Semesters.Attach(original);
                     db.Entry(original).State = EntityState.Modified;
                     db.SaveChanges();
                 }
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbEntityValidationException e)
     {
         throw;
     }
 }

 public void updateSubject(int id, string NewSubName, string NewConspect, string NewUrl, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var original = db.Subjects.Where(orig => orig.SubjectID == id).FirstOrDefault();
             if (original != null)
             {
                 if (!string.IsNullOrEmpty(NewSubName))
                     original.Name = NewSubName;
                 if (!string.IsNullOrEmpty(NewConspect))
                     original.Conspect = NewConspect;
                 if (!string.IsNullOrEmpty(NewUrl))
                     original.url = NewUrl;
                 original.TimeStamp = timestamp;
                 db.Subjects.Attach(original);
                 db.Entry(original).State = EntityState.Modified;
                 db.SaveChanges();
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbEntityValidationException e)
     { throw; }
 }

 public void updateGroup(int id, string n, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var original = db.Groups.Where(orig => orig.GroupID == id).FirstOrDefault();
             if (original != null)
             {
                 if (!original.Name.Equals(n))
                 {
                     original.Name = n;
                     original.TimeStamp = timestamp;
                     db.Groups.Attach(original);
                     db.Entry(original).State = EntityState.Modified;
                     db.SaveChanges();
                 }
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbEntityValidationException e)
     {
         foreach (var eve in e.EntityValidationErrors)
         {
             Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                 eve.Entry.Entity.GetType().Name, eve.Entry.State);
             foreach (var ve in eve.ValidationErrors)
             {
                 Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                     ve.PropertyName, ve.ErrorMessage);
             }
         }
         throw;
     }
 }

 public void updateStudent(int id, string ind, string first, string last, int groupId, byte[] timestamp)
 {
     try
     {
         using (var db = new DataContext())
         {
             var original = db.Students.Include("Group").Where(orig => orig.StudentID == id).FirstOrDefault(); 
             if (original != null)
             {
                 if (!string.IsNullOrEmpty(first))
                     original.FirstName = first;
                 if (!string.IsNullOrEmpty(ind))
                     original.IndexNo = ind;
                 if (!string.IsNullOrEmpty(last))
                     original.LastName = last;
                 if (groupId!=original.Group.GroupID )
                 {
                     var group = db.Groups.Find(groupId);
                     original.Group = group;
                 }
                 original.TimeStamp = timestamp;
                 db.Students.Attach(original);
                 db.Entry(original).State = EntityState.Modified;
                 db.SaveChanges();
             }
         }
     }
     catch (DbUpdateConcurrencyException ex)
     {
         throw;
     }
     catch (DbEntityValidationException e)
     {
         foreach (var eve in e.EntityValidationErrors)
         {
             Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                 eve.Entry.Entity.GetType().Name, eve.Entry.State);
             foreach (var ve in eve.ValidationErrors)
             {
                 Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                     ve.PropertyName, ve.ErrorMessage);
             }
         }
         throw;
     }
 }