begin tran
    efContext.ExecuteSqlRaw("update users set time = getdate() where id = 5")
        var user = efContext.Single(a => a.id == 5);
        user.time = Now
        efContex.Users.Update(user);
        efContext.SaveChanges()
commit tran

 catch (DbUpdateConcurrencyException ex)
    {
        foreach (var entry in ex.Entries)
        {
            if (entry.Entity is Person)
            {
                var proposedValues = entry.CurrentValues;
                var databaseValues = entry.GetDatabaseValues();

                foreach (var property in proposedValues.Properties)
                {
                    var proposedValue = proposedValues[property];
                    var databaseValue = databaseValues[property];

                    // TODO: decide which value should be written to database
                    // proposedValues[property] = <value to be saved>;
                }

                // Refresh original values to bypass next concurrency check
                entry.OriginalValues.SetValues(databaseValues);
            }
            else
            {
                throw new NotSupportedException(
                    "Don't know how to handle concurrency conflicts for "
                    + entry.Metadata.Name);
            }
        }
    }

M>begin tran
M>    efContext.ExecuteSqlRaw("update users set time = getdate() where id = 5")
M>        var user = efContext.Single(a => a.id == 5);
M>        user.time = Now
M>        efContex.Users.Update(user);
M>        efContext.SaveChanges()
M>commit tran
M>

M> catch (DbUpdateConcurrencyException ex)
M>    {
M>        foreach (var entry in ex.Entries)
M>        {
M>            if (entry.Entity is Person)
M>            {
M>                var proposedValues = entry.CurrentValues;
M>                var databaseValues = entry.GetDatabaseValues();

M>                foreach (var property in proposedValues.Properties)
M>                {
M>                    var proposedValue = proposedValues[property];
M>                    var databaseValue = databaseValues[property];

M>                    // TODO: decide which value should be written to database
M>                    // proposedValues[property] = <value to be saved>;
M>                }

M>                // Refresh original values to bypass next concurrency check
M>                entry.OriginalValues.SetValues(databaseValues);
M>            }
M>            else
M>            {
M>                throw new NotSupportedException(
M>                    "Don't know how to handle concurrency conflicts for "
M>                    + entry.Metadata.Name);
M>            }
M>        }
M>    }
M>

 using (var db=new Db())
            {
                var m = db.Managers.Find(1);
                m.Name = "MyName_1";
                db.SaveChanges();
            }

  using (var db = new Db())
            {
                var m = new Manager() { Id = 1, Name = "MyName_2", Family = "Pupkin" };

                db.Attach<Manager>(m).State = EntityState.Modified;
                db.SaveChanges();
            }

Algorithms built around CAS typically read some key memory location and remember the old value. Based on that old value, they compute some new value. Then they try to swap in the new value using CAS, where the comparison checks for the location still being equal to the old value. If CAS indicates that the attempt has failed, it has to be repeated from the beginning: the location is re-read, a new value is re-computed and the CAS is tried again.

if (entry.Entity is Promo)
                    {
                        var proposedValues = entry.CurrentValues;
                        var databaseValues = entry.GetDatabaseValues();
                        
                        foreach (var property in proposedValues.Properties)
                        {
                            var proposedValue = proposedValues[property];
                            var databaseValue = databaseValues[property];

                            // TODO: decide which value should be written to database
                            proposedValues[property] = proposedValue;
                        }

                        // Refresh original values to bypass next concurrency check
                        entry.OriginalValues.SetValues(proposedValues);
                    }