var developmentTool = new DevelopmentTool() { Name = "Visual Studio 2017", 
Language = "C#" };

ctx.Tools.Add(developmentTool);

DevelopmentTool tool = /* something */;
Project project = /* something */;
Customer customer = /* something */; 

ctx.AddRange(tool, project, customer);

var affectedRecords = ctx.SaveChanges();

//load some entity.
var tool = ctx.Tools.FirstOrDefault();

ctx.SaveChanges(); //0

//change something.
tool.Name += "_changed";

//send changes.
var affectedRecords = ctx.SaveChanges(); //1

//load some entity.
var tool = ctx.Tools.FirstOrDefault();

//remove the entity.
ctx.Tools.Remove(tool);

//send changes.
var affectedRecords = ctx.SaveChanges(); //1

//load some entity.
var tool = ctx.Tools.FirstOrDefault();

//get the cache entry.
var entry = ctx.Entry(tool);

//get the entity state.
var state = entry.State; //EntityState.Unchanged

//get the original value of the Name property.
var originalName = entry.OriginalValues["Name"] as String; //Visual Studio 2017

//change something.
tool.Name += "_changed";

//get the current state
state = entry.State; //EntityState.Modified

//get the current value of the Name property.
var currentName = entry.CurrentValues["Name"] as String; //Visual Studio 2017_changed

//get all the added entities of type Project.
var addedProjects = ctx
  .ChangeTracker
  .Entries()
  .Where(x => x.State == EntityState.Added)
  .Select(x => x.Entity)
  .OfType<Project>();

  var rows =
  ctx.Database.ExecuteSqlCommand($"DELETE FROM Project WHERE ProjectId
  = {id}");

  var events =
  ctx.GetService<ILocalViewListener>();
  events.RegisterView((entry,
  state) =>
  {
    //entry contains the
  entity’s details.
    //state is the new state.
  });

  //when
  deleting a Project, delete its ProjectDetail.
  builder
    .Entity<Project>()
    .HasOne(b
  => b.Detail)
    .WithOne(d
  => d.Project)
    .OnDelete(DeleteBehavior.Cascade);

  //when
  deleting a ProjectResource, do not delete the Project. 
  builder
    .Entity<ProjectResource>()
    .HasOne(x
  => x.Project)
    .WithMany(x
  => x.ProjectResources)
    .OnDelete(DeleteBehavior.SetNull);

  //when
  deleting a Project, delete its ProjectResources. 
  builder
    .Entity<Project>()
    .HasMany(x
  => x.ProjectResources)
    .WithOne(x
  => x.Project)
    .OnDelete(DeleteBehavior.Cascade);

//load some entity.
var project = ctx.Projects.Find(1);

//set it to detached.
ctx.Entry(project).State = EntityState.Detached;

//time passes…

//load entity again.
project = ctx.Projects.Find(1);

  ctx.Entry(project).Reload();

  ctx

  .Entry(project)
    .Property(x
  => x.Name)

  .EntityEntry
    .Reload();

  ctx

  .Entry(customer)

  .Collection(x => x.Projects)

  .EntityEntry
    .Reload();

try
{
  ctx.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
  //the record was changed in the database, notify the user and fail.
}

public class Project
{
  [Concurrency][ConcurrencyCheck]
  public DateTime Timestamp { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
  modelBuilder
    .Entity<Project>()
    .Property(x => x.Name)
    .IsConcurrencyToken();
}

[Timestamp]
public byte [] RowVersion { get protected set; }

modelBuilder
  .Entity<Project>()
  .Property(x => x.RowVersion)
  .IsRowVersion();

//retrieve the instance from the ASP.NET context. 
var project = Session["StoredProject"] as Project;

var ctx = new ProjectsContext();

//attach it to the current context with a state of unchanged.
ctx.Entry(project).State = EntityState.Unchanged;

ctx.ChangeTracker.TrackGraph(rootEntity, node =>
{
  if (node.Entry.Entity is Project)
  {
    if ((node.Entry.Entity as Project).ProjectId != 0)
    {
      node.Entry.State = EntityState.Unchanged;
    }
    else
    {
      //other conditions 
    }
  }
);

public override int SaveChanges()
{
  var serviceProvider = GetService<IServiceProvider>();
  var items = new Dictionary<object, object>();

  foreach (var entry in ChangeTracker.Entries().Where(e => 
        (e.State == EntityState.Added) || (e.State == EntityState.Modified))
  {
    var entity = entry.Entity;
    var context = new ValidationContext(entity, serviceProvider, items);
    var results = new List<ValidationResult>();

    if (!Validator.TryValidateObject(entity, context, results, true))
    {
      foreach (var result in results)
      {
        if (result != ValidationResult.Success)
        {
          throw new ValidationException(result.ErrorMessage);
        }
      }
    }
  }

  return base.SaveChanges();
}

try
{
  //try to save all changes.
  ctx.SaveChanges();
}
catch (DbEntityValidationException ex)
{
  //validation errors were found that prevented saving changes.
  var errors = ex.EntityValidationErrors.ToList();
}

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, 
        Inherited = true)]
public sealed class IsEvenAttribute : ValidationAttribute
{
  protected override ValidationResult IsValid(object value, 
      ValidationContext validationContext)
  {
    //check if the value is null or empty.
    if ((value != null) && (!string.IsNullOrWhiteSpace(value.ToString())))
    {
      //check if the value can be converted to a long one.
      var number = Convert.ToDouble(value);
      //fail if the number is even.
      if ((number % 2) == 0)
      {
        return new ValidationResult(ErrorMessage, new [] 
          { validationContext.MemberName });
      }
    }
    return ValidationResult.Success;
  }
}

[IsEven(ErrorMessage = "Number must be even")]
public int Number { get set; }

[CustomValidation(typeof(CustomValidationRules), "IsEven", 
  ErrorMessage = "Number must be even")]
public int Number { get; set; }

public static ValidationResult IsEven(Object value, ValidationContext context)
{
  //check if the value is not null or empty.
  if ((value != null) && (!string.IsNullOrWhiteSpace(value.ToString())))
  {
    //check if the value can be converted to a long one.
    var number = Convert.ToDouble(value);
    //fail if the number is even.
    if ((number % 2) == 0)
    {
      return new ValidationResult(ErrorMessage, new [] 
        { validationContext.MemberName });
    }
    return ValidationResult.Success;
  }
}

public class Project : IValidatableObject
{
  //other members go here.
  public IEnumerable<ValidationResult> Validate(ValidationContext context)
  {
    if (ProjectManager == null)
    {
      yield return new ValidationResult("No project manager specified");
    }
    if (Developers.Any() == false)
    {
      yield return new ValidationResult("No developers specified");
    }
    if ((End != null) && (End.Value < Start))
    {
      yield return new ValidationResult("End of project is before start");
    }
  }
}

ctx.Database.BeginTransaction();

if (/*some condition*/)
{
  ctx.Database.CommitTransaction();
}
else
{
  ctx.Database.RollbackTransaction();
}

ctx.GetService<IRelationalTransactionManager>().UseTransaction(tx);

var con = ctx.Database.GetDbConnection();
con.Transaction = tx;

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
  optionsBuilder
    .UseSqlServer(
      connectionString: _nameOrConnectionString,
      sqlServerOptionsAction: opts =>
      {
        opts.EnableRetryOnFailure(3, TimeSpan.FromSeconds(3), new int[] {});
      });
    );

  base.OnConfiguring(optionsBuilder);
}

var strategy = ctx.Database.CreateExecutionStrategy();
strategy.Execute(() =>
{
  using (var tx = ctx.Database.BeginTransaction())
  {
    tx.Projects.Add(new Project { Name = "Big Project", 
Customer = new Customer { CustomerId = 1 }, Start = DateTime.UtcNow });  
    tx.Commit();
  }
});