Transaktions-deadlocks, wie design richtig?

Also arbeite ich an diesem Projekt von Entity Framework, die verwendet werden können als eine Art DAL und beim ausführen von stress-tests (beginnend ein paar updates auf Entitäten, die durch Gewinde()'s) und ich bekomme diese:

_innerException = {"Transaktion (Prozess-ID 94) befand sich auf sperren von Ressourcen mit einem anderen Prozess und wurde als Deadlockopfer ausgewählt. Wiederholung der Transaktion."}

Hier einige Beispiel, wie ich umgesetzt habe meine Klassen " Methoden:

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;
            }
        }
    }
}

und:

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;
            }
        }
    }
}

Offensichtlich, den code hier wahrscheinlich könnte besser sein, aber ich bin eher ein EF-Neuling. Aber ich denke, mein problem ist eher ein design problem mit Kontext.

Ich erinnere mich, jemanden hier zu erwähnen, dass, wenn mein Rahmen ist NICHT freigegeben, ich kann nicht laufen in diesen deadlock-Probleme.

Scheint dies nicht 'shared', um mich, wie ich mit neuen BackEndEntities() in jeder Methode, also, was muss ich ändern, um es robuster ist ?

Dieser DAL wird in einem web-Dienst im internet verfügbar gemacht (nach code-review Gang), also habe ich keine Kontrolle darüber, wie viel es werde betont werden und viele verschiedene Instanzen aktualisieren möchten, auf die gleiche Entität.

Dank!