public class ExamRepository : IExamRepository

    {

        private ExamRepositoryContext _contextfield;

        private ExamRepositoryContext _context

        {

            get

            {

                if (_contextfield == null)

                    _contextfield = new ExamRepositoryContext();

                return _contextfield;

            }

        }

​

        public void Add<T>(T entity) where T : DomainEntityBase

        {

            _context.Set<T>().Add(entity);

            _context.SaveChanges();

        }

​

        public void AssignExamSourceToReader(int readerId, int examSourceId)

        {

            var reader = _context.Readers.Find(readerId);

            var examSource = _context.ExamSources.Find(examSourceId);

            if (reader != null && examSource != null)

            {

                reader.ExamSources.Add(examSource);

            }

            _context.SaveChanges();

        }

​

​

        public void Delete<T>(T entity) where T : DomainEntityBase

        {

            _context.Set<T>().Remove(entity);

            _context.SaveChanges();

        }

​

        public void Delete<T>(int id) where T : DomainEntityBase

        {

            var entity = _context.Set<T>().Find(id);

            if (entity != null)

                Delete<T>(entity);

        }

​

        public void Delete<T>(IEnumerable<T> entities) where T : DomainEntityBase

        {

​

            _context.Set<T>().RemoveRange(entities);

            _context.SaveChanges();

        }

        public void DeletePatients(IEnumerable<Patient> patients)

        {

            _context.Patients.RemoveRange(patients);

            _context.SaveChanges();

        }

​

        public void DeletePatientsWithoutExams()

        {

            _context.Database.ExecuteSqlCommand("EXEC pr_DeletePatientsWithoutExams");

        }

​

​

        public IQueryable<T> Get<T>() where T : DomainEntityBase

        {

​

            return _context.Set<T>();

        }

​

        public IQueryable<ExamNoteDiscrepancy> GetDiscrepancies()

        {

            return _context.ExamNoteDiscrepancies

                .Include(d => d.ExamNote).Include(d => d.ExamNote.Reader).Include(d => d.ExamNote.Exam).Include(d => d.ExamNote.Exam.ExamSource)

                .Include(d => d.Reader)

                .Include(d => d.DiscrepancyType);

        }

​

        public IQueryable<ExamNote> GetExamNotes()

        {

            return _context.ExamNotes

                .Include(n => n.Reader)

                .Include(n => n.Exam);

        }

​

        public IQueryable<Patient> GetPatients()

        {

            return _context.Patients;

        }

​

        public IQueryable<Reader> GetReaders()

        {

            return _context.Readers

                .Include(r => r.ExamSources);

        }

​

        public void RemoveExamSourceFromReader(int readerId, int examSourceId)

        {

            var reader = _context.Readers.Find(readerId);

            var examSource = _context.ExamSources.Find(examSourceId);

            if (reader != null && examSource != null)

            {

                reader.ExamSources.Remove(examSource);

            }

            _context.SaveChanges();

        }

        public void SaveChanges()

        {

            _context.SaveChanges();

        }

​

​

        public void Update<T>(T entity) where T : DomainEntityBase

        {

            Update<T>(entity, true);

        }

        public void Update<T>(IEnumerable<T> entities) where T : DomainEntityBase

        {

            foreach (var entity in entities)

                Update<T>(entity, false);

            _context.SaveChanges();

        }

​

        public void Update<T>(T entity, bool saveChanges) where T : DomainEntityBase

        {

            //We query local context first to see if it's there.

            var attachedEntity = _context.Set<T>().Local.Where(e => e.Id == entity.Id).FirstOrDefault();

​

            //We have it in the context, need to update.

            if (attachedEntity == null)

                attachedEntity = _context.Set<T>().Find(entity.Id);

​

            var attachedEntry = _context.Entry(attachedEntity);

            attachedEntry.CurrentValues.SetValues(entity);

​

            try

            {

                _context.SaveChanges();

            }

            catch (DbEntityValidationException ex)

            {

                // Retrieve the error messages as a list of strings.

                var errorMessages = ex.EntityValidationErrors

                    .SelectMany(x => x.ValidationErrors)

                    .Select(x => x.ErrorMessage);

​

                // Join the list to a single string.

                var fullErrorMessage = string.Join(";", errorMessages);

​

                // Combine the original exception message with the new one.

                var exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);

​

                // Throw a new DbEntityValidationException with the improved exception message.

                throw new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors);

            }

        }

​

        #region IDisposable Support

        private bool disposedValue = false; // To detect redundant calls

​

        protected virtual void Dispose(bool disposing)

        {

            if (!disposedValue)

            {

                if (disposing)

                {

                    // TODO: dispose managed state (managed objects).

                }

​

                // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.

                // TODO: set large fields to null.

                _context.Dispose();

​

                disposedValue = true;

            }

        }

​

        public void Dispose()

        {

            Dispose(true);

        }

​

​

​

​

        #endregion

​

    }