Have you ever tried to update specific fields of an entity using Entity Framework? If yes, then I can assume that System.Data.Entity.Validation.DbEntityValidationResult – Validation failed for one or more entities. See ‘EntityValidationErrors’ property for more details. Exception is not something new to you. 

While working recently on a project for which I was using Entity Framework 5.x CF (the part with code first is not relevant) I bumped into an interesting piece of code. The main idea behind it is to perform updates for a single property and ignore the rest even if they don't respect the constraints defined in the model. Please note that I have found PartialEntityValidation class somewhere on the internet and unfortunately I do not remember where, I was not able to find it again. The only changes made by me are related to code formatting. I will present the code first and explain the logic behind it afterwards.

using System.Collections.Generic;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Validation;

namespace MyProject.Data.Contexts.Concrete
{
    public class PartialEntityValidation
    {
        private readonly IDictionary<DbEntityEntry, string[]> _store;

        public PartialEntityValidation()
        {
            _store = new Dictionary<DbEntityEntry, string[]>();
        }

        public void Register(DbEntityEntry entry, string[] properties)
        {
            if (_store.ContainsKey(entry))
                _store[entry] = properties;
            else
                _store.Add(entry, properties);
        }

        public void Unregister(DbEntityEntry entry)
        {
            _store.Remove(entry);
        }
        public bool IsResponsibleFor(DbEntityEntry entry)
        {
            return _store.ContainsKey(entry);
        }
        public void Validate(DbEntityValidationResult validationResult)
        {
            var entry = validationResult.Entry;
            foreach (var property in _store[entry])
            {
                var validationErrors = entry.Property(property).GetValidationErrors();
                foreach (var validationError in validationErrors)
                    validationResult.ValidationErrors.Add(validationError);
            }
        }
    }
}

Now it is time to see how to use PartialEntityValidation class. In My case I have exposed it as a public read only property of the context and had ValidateEntity method overridden  at context level.

using System;   
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Data.Entity.Validation;

namespace MyProject.Data.Contexts.Concrete
{
    public class MyContext : DbContext
    {
        private readonly PartialEntityValidation _partialEntityValidation;

        static MyContext()
        {
            Database.SetInitializer<T>(null);
        }

        protected MyContext()
            : base("MyDb")
        {
            _partialEntityValidation = new PartialEntityValidation();
            Configuration.LazyLoadingEnabled = false;
        }

        public PartialEntityValidation PartialValidation { get { return _partialEntityValidation; } }

        protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry, IDictionary<object, object> items)
        {
            if (PartialValidation.IsResponsibleFor(entityEntry))
            {
                var validationResult = new DbEntityValidationResult(entityEntry, new List<DbValidationError>());
                PartialValidation.Validate(validationResult);

                return validationResult;
            }

            return base.ValidateEntity(entityEntry, items);
        }
    }
}

using System;
using System.Linq;
using System.Linq.Expressions;

namespace MyProject.Data.Repositories.Concrete
{
    public class MyRepository
    {
		private readonly MyContext _context;
	
        public MyRepository(MyContext context)
        {
			_context = context;
		}

        public void DeleteProduct(Guid productId)
        {
            var product = new Product { ProductId = productId, IsDeleted = true };
            _context.PartialValidation.Register(_context.Entry(product), new[] { "IsDeleted" });
            Update<Product>(workspace, p => p.IsDeleted);
            _context.SaveChanges();
            ((IObjectContextAdapter)_context).ObjectContext.Detach(product);
        }
		
		public void Update<T>(T entity, Expression<Func<T, object>> property) where T : class
        {
            var  entry = _context.Entry(entity);
            _context.Set<T>().Attach(entity);
            entry.Property(property).IsModified = true;
        }
    }
}