Comment utiliser les transactions avec Entity Framework?

Lorsque vous avez un code comme ceci:

Something something = new Something();
BlahEntities b = new BlahEntities()    
b.AddToSomethingSet(something);
b.SaveChanges();

comment courir que plus de l'intérieur d'une transaction?

InformationsquelleAutor pupeno | 2009-06-28

entity-framework transactions

26

Vous pouvez placer votre code à l'intérieur d'une étendue de Transaction
```
using(TransactionScope scope = new TransactionScope())
{
    //Your code
    scope.Complete(); // To commit.
}
```
TransactionScope est dans le Système.Les opérations de noms qui est situé dans l'assemblée du même nom (dont vous pouvez avoir besoin d'ajouter manuellement à votre projet).
- Comment est-ce possible - comment le TransactionScope savoir sur l'EF-contexte et/ou vice-versa?
- TransActionScope est une sorte de wrapper autour de tout ce que vous pouvez faire: msdn.microsoft.com/en-us/library/...
- Soyez prudent avec TransactionScope. Il introduit dépendances sur MS DTC qui est une douleur pour configurer et porte une lourde performance prix. Une fois que vous avez plus d'une opération à l'intérieur de la TransactionScope, il va initier une transaction distribuée. Il n'est plus seulement un simple DbTransaction sur ce fournisseur. Aussi, si vous utilisez un fournisseur de base de données autre que Sql Server, il est probable qu'il ne prend pas en charge les transactions distribuées...
- il sera promu lorsque vous avez plus d'une opération, n'est-il pas lorsqu'une transaction s'étend sur plus d'une base de données?
- Les transactions locales sont encouragées à distribués même si vous interrogez la même base de données. Si vous utilisez SQL Server 2005 (ou ci-dessus), il va utiliser le léger transactions avant la promotion. Si vous utilisez un fournisseur qui ne prend pas en charge la promotion, vous devrez payer l'amende de la performance, même si faire qu'une seule requête à l'intérieur de la portée.
- Ce n'est pas travailler avec plusieurs contexte. (par exemple: OrderContext, ShippingContext)
InformationsquelleAutor Shiraz Bhaiji
55

ObjectContext a une propriété de la connexion que vous pouvez utiliser pour gérer les transactions.
```
using (var context = new BlahEntities())
using (var tx = context.BeginTransaction())
{
    //do db stuff here...
    tx.Commit();
}
```
Dans le cas d'une exception, la transaction sera annulée. Parce que l'appel à BeginTransaction (), qui exige et ouvrir une connexion, il est logique de placer l'appel BeginTransaction éventuellement dans une méthode d'extension.
```
public static DbTransaction BeginTransaction(this ObjectContext context)
{
    if (context.Connection.State != ConnectionState.Open)
    {
        context.Connection.Open();
    }
    return context.Connection.BeginTransaction();
}
```
Un scénario où je crois que cette approche pourrait être utile au cours de TransactionScope, c'est quand vous avez accès à deux sources de données, et seulement besoin de contrôle de transaction sur l'une des connexions. Je pense que dans ce cas, la TransactionScope fera la promotion d'une transaction distribuée qui pourrait ne pas être nécessaire.
- Cela ne fonctionne plus dans EF4.1. Vous devez appeler context.Connection.BeginTransaction.
- Dans les peco, il fonctionne, vous n'avez pas lu la fin -- Kim introduit la méthode d'extension. Kim -- vous êtes l'homme!!! Vous m'a beaucoup aidé, je vous remercie beaucoup.
- merci pour l'aide, cela m'a vraiment aidé. Cependant, je veux savoir si le contexte.Connexion.BeginTransaction() s'aggrave pour une transaction distribuée (MSDTC)? Je veux éviter de MSDTC, est-ce possible?
- C'est de loin mon préféré répondre parce que TransactionScope est une pure utopie qui n'est pas largement mis en œuvre. @Baig, le contexte.Connexion.BeginTransaction() ne sera jamais jamais dégénérer en une transaction distribuée (MSDTC).
InformationsquelleAutor Kim Major
9

Je sais que pour LINQ to SQL, le contexte de données permettra de créer une transaction pour SubmitChanges() si il n'y a aucune ambiante transaction (TransactionScope est une "ambiance" de la transaction). Je n'ai pas vu cette documenté pour LINQ to entities, mais j'ai vu le comportement de suggérer que c'est vrai pour Entity Framework ainsi.

Donc, tant que vous utilisez un SubmitChanges() (L2SQL) ou SaveChanges() (Linq to entities) pour tous les changements liés à l', vous devriez être OK sans l'aide de TransactionScope. Vous avez besoin d'un TransactionScope quand
1. De l'enregistrement de plusieurs changements avec plusieurs SubmitChanges/SaveChanges pour une transaction.
2. Mise à jour de plusieurs sources de données en une seule transaction (par exemple, Linq et ASP.NET l'adhésion fournisseur SQL).
3. L'appel à d'autres méthodes qui peuvent faire leurs propres mises à jour.
J'ai eu du mal avec imbriqué TransactionScopes. Ils sont censés travailler, et simple des cas de test de travail, mais quand je rentre dans le code de production, la "intérieure" de la transaction semble être le même objet que la transaction externe. Les symptômes comprennent les erreurs qui sont soit "transaction validée, vous ne pouvez pas utiliser cette transaction plus" ou "objet de la transaction a déjà été éliminés". Les erreurs se produisent à l'extérieur de transaction après l'intérieure de la transaction a fait son travail.
- Grâce cyloncat pour la description longue. Ce que je suis en train de faire est de créer l'enregistrement, de l'enregistrer et de créer un fichier avec l'id de l'enregistrement. Seulement lors de la création des fichiers réussit puis-je valider la transaction. Du sens?
- Oui, c'est un excellent exemple de quand et comment utiliser une transaction.
InformationsquelleAutor Cylon Cat

using System.Transactions;

using (TransactionScope scope = new TransactionScope())
{
    try
    {
        using(DataContext contextObject = new DataContext(ConnectionString))
        {
            contextObject.Connection.Open();
            //First SaveChange method.
            contextObject.SaveChanges();

            //Second SaveChange method.
            contextObject.SaveChanges();
            //--continue to nth save changes

            //If all execution successful
            scope.Complete();   
       }
    }
    catch(Exception ex)
    {
        //If any exception is caught, roll back the entire transaction and end the scope.
        scope.Dispose();
    }
    finally
    {
        //Close the opened connection
        if (contextObject.Connection.State == ConnectionState.Open)
        {
            contextObject.Connection.Close();
        }
    }
}

Trouver le lien ci-dessous pour une explication détaillée https://msdn.microsoft.com/en-us/data/dn456843.aspx

InformationsquelleAutor Sabyasachi Mishra

0

Dans toutes les versions de Entity Framework, chaque fois que vous exécutez SaveChanges() pour insérer, mettre à jour ou supprimer dans la base de données du cadre envelopper cette opération dans une transaction. Cette opération ne dure assez longtemps à l'exécution de l'opération, puis se termine. Lors de l'exécution d'une autre opération de ce type, une nouvelle transaction est démarrée.
Pour les plus récents Entity Framework version: 6.0 +

Lire La Suite Ici: EntityFramework et de Transaction

InformationsquelleAutor Mesut Talebi2

Vous devez vous connecter pour publier un commentaire.