title: Transaction deadlocks, how to design properly?
body: <p>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:</p>
  
  <blockquote>
    <p>_innerException = {"Transaction (Process ID 94) was deadlocked on lock resources with another process and has been chosen as the deadlock victim. Rerun the transaction."}</p>
  </blockquote>
  
  <p>Here's some example of how I implemented my classes' methods:</p>
  
  <pre><code>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;
              }
          }
      }
  }
  </code></pre>
  
  <p>and:</p>
  
  <pre><code>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;
              }
          }
      }
  }
  </code></pre>
  
  <p>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.</p>
  
  <p>I remember someone here mentioning that if my context is NOT shared, I won't run into these deadlock issues.</p>
  
  <p>This does not seem 'shared' to me as I do a <em>using new BackEndEntities()</em> in each method, so what do I have to change to make it more robust ?</p>
  
  <p>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.</p>
  
  <p>Thanks!</p>