Question

So I’m working on this Entity Framework project that’ll be used as kind of a DAL and when running stress tests (starting a couple of updates on entities through Thread()’s) and I’m getting these:

_innerException = {“Transaction (Process ID 94) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction.”}

Here’s some example of how I implemented my classes’ methods:

public class OrderController
{

    public Order Select(long orderID)
    {
        using (var ctx = new BackEndEntities())
        {

            try
            {
                var res = from n in ctx.Orders
                                       .Include("OrderedServices.Professional")
                                       .Include("Agency")
                                       .Include("Agent")
                          where n.OrderID == orderID
                          select n;
                return res.FirstOrDefault();
            }
            catch (Exception ex)
            {
                throw ex;
            }
         }
    }

    public bool Update(Order order)
    {
        using (var ctx = new BackEndEntities())
        {
            try
            {
                order.ModificationDate = DateTime.Now;
                ctx.Orders.Attach(order);
                ctx.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}

and:

public class AgentController
{

    public Agent Select(long agentID)
    {
        using (var ctx = new BackEndEntities())
        {
            try
            {
                var res = from n in ctx.Agents.Include("Orders")
                          where n.AgentID == agentID
                          select n;
                return res.FirstOrDefault();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

    }

    public bool Update(Agent agent)
    {
        using (var ctx = new BackEndEntities())
        {
            try
            {
                agent.ModificationDate = DateTime.Now;
                ctx.Agents.Attach(agent);
                ctx.ObjectStateManager.ChangeObjectState(agent, System.Data.EntityState.Modified);
                ctx.SaveChanges();
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}

Obviously, the code here probably could be better but I’m rather of an EF newbie. But I think my problem is rather a design problem with the context.

I remember someone here mentioning that if my context is NOT shared, I won’t run into these deadlock issues.

This does not seem ‘shared’ to me as I do a using new BackEndEntities() in each method, so what do I have to change to make it more robust ?

This DAL will be used in a web service exposed on the internet (after code review of coure) so I have no control on how much it’ll be stressed and lots of different instances might want to update the same entity.

Thanks!

Answer 1

Deadlock freedom is a pretty hard problem in a big system. It has nothing to do with EF by itself.

Shortening the lifetime of your transactions reduces deadlocks but it introduces data inconsistencies. In those places where you were deadlocking previously you are now destroying data (without any notification).

So choose your context lifetime and your transaction lifetime according to the logical transaction, not according to physical considerations.

Turn on snapshot isolation. This takes reading transactions totally out of the equation.

For writing transactions you need to find a lock ordering. Often it is the easiest way to lock pessimistically and at a higher level. Example: Are you always modifying data in the context of a customer? Take an update lock on that customer as the first statement of your transactions. That provides total deadlock freedom by serializing access to that customer.