ASP.NET web application + Entity Framework 4.0 with Concurrency Check

Question

I have an entity like this:

public class Player
{
    [Required]
    [Key]
    public int Id { get; set; }
    [Required]
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string NativeCountry { get; set; }
    [ConcurrencyCheck]
    public DateTime LastModified { get; set; }
    public virtual int TeamId { get; set; }

    //navigational property
    public virtual Team Team { get; set; }
    public virtual ICollection<Tournament> Tournaments { get; set; }
}

this is how i configure Player entity:

public PlayerConfiguration()
{
    Property(e => e.Id).IsRequired();
    Property(e => e.FirstName).IsRequired().IsConcurrencyToken(true);
    Property(e => e.NativeCountry).IsOptional();
    Property(e => e.LastModified).IsOptional().IsConcurrencyToken(true);

    HasRequired(e => e.Team).WithMany(s => s.Players).HasForeignKey(f => f.TeamId);
}

overridden OnModelCreating

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    Configuration.ValidateOnSaveEnabled = false;
    Configuration.LazyLoadingEnabled = true;

    modelBuilder.Configurations.Add(new PlayerConfiguration());
    modelBuilder.Configurations.Add(new TeamConfiguration());
    modelBuilder.Configurations.Add(new TournamentConfiguration());

    modelBuilder.Entity<Player>().ToTable("Player");
    modelBuilder.Entity<Team>().ToTable("Team");
    modelBuilder.Entity<Tournament>().ToTable("Tournament");

    base.OnModelCreating(modelBuilder);
}

somewhere I do this to update a player:

db.Entry<Player>(player).State = System.Data.EntityState.Modified;
try
{
    db.SaveChanges();
}
catch (DbUpdateConcurrencyException ex)
{

}

when I try to update any given player at the same time, using two browsers, nothing happens. I don't want to use a TimeStamp annotation, because it will cost me one extra column. How can I use the existing DateTime LastModified column to track concurrency. I even tried making FirstName (and others) as ConcurrencyToken, but again nothing happened. How does this [ConcurrencyCheck] work in asp.net web application.?? please help..

Answer 1

It looks like your code doesn't change LastModified property so you are using still the same concurrency token. That is a reason why people use Timestamp column because timestamp is automatically handled by database and you don't have to deal with it.

To use concurrency token your entity must follow very strict rules.

• Your entity must hold old value of concurrency token (in case of ASP.NET it requires round tripping concurrency token to client and receiving it back with modified data).
• If you don't use database generated concurrency token (timestamp or row version) you must set it manually each time you are going to change the record
• If you work with detached entities the new token can be set only ofter you attach the entity to the context otherwise you will get exception every time you try to save updated data

Here is sample code to validate that concurrency checking works:

class Program
{
    static void Main(string[] args)
    {
        using (var context = new Context())
        {
            context.Database.Delete();
            context.Database.CreateIfNotExists();

            context.Players.Add(new Player { FirstName = "ABC", LastName = "EFG", NativeCountry = "XYZ", LastModified = DateTime.Now});
            context.SaveChanges();
        }

        using (var context = new Context())
        {
            var player = context.Players.First();

            // Break here, go to database and change LastModified date
            player.LastModified = DateTime.Now;
            // If you changed LastModified date you will get an exception
            context.SaveChanges();
        }
    }
}

Answer 2

this is what I did to make it work:

Player entity:

[ConcurrencyCheck]
public DateTime LastModified { get; set; }

in my code, onLoad of the form, called this function:

private static DateTime TimeStamp;
protected void LoadData()
    {
        Player player = new PlayerRepository().First(plyr => plyr.Id == Id);
        if (player != null)
        {   
           TimeStamp = player.LastModified;
            //rest of the code
        }
     }

and upon click of the save button i.e. while updating entity:

    protected void btnSave_Click(object sender, EventArgs e)
    {
        var playerRepo = new PlayerRepository();
        var teamRepo = new TeamRepository();

          if (Page.IsValid)
          {
            Player player;
            if (this.Id == 0)//add
            {
                player = new Player();
                //rest of the code
            }
            else //edit
              player = playerRepo.First(p => p.Id == Id);

            player.LastModified = DateTime.Now;

            //custom logic
            if (this.Id == 0) // add
            {
                playerRepo.Add(player);
                playerRepo.SaveChanges();
            }
            else // edit
            {
                try
                {
                    playerRepo.OriginalValue(player, "LastModified", TimeStamp);
                    playerRepo.SaveChanges();
                }
                catch (DbUpdateConcurrencyException ex)
                {
                   //custom logic
                }

            }
      }

and OriginalValue in the AbstractRepository is this:

    public void OriginalValue(TEntity entity, string propertyName, dynamic value)
    {
        Context.Entry<TEntity>(entity).OriginalValues[propertyName] = value;
    }

so explicitly i had to change the OriginalValue of the ConcurrencyCheck marked column to the older one.